diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,103 @@
 # Revision history for typst-hs
 
+## 0.9
+
+  * Tweak parsing of list items and headings to match Typst more closely
+    (#92, #58, #90, #92, Norbert Pozar).
+
+    - Handles trivia (whitespace, comments) as Typst (see #92).
+    - Replaces `stLineStartCol` by `stAtStart`: `stAtStart` is set to `True`
+      after an end of line, at the beginning of content or at the beginning
+      of a list item (since list items can be nested), and set to `False`
+      after any non-trivia markup. This appears simpler and more robust,
+      especially after comments.
+    - Removes `stIndent` state.
+       Indented block is handled completely in `pIndented` parser and does
+      not rely on `stIndent` state.
+
+  * Support `func()` for content elements in submodules (math etc.)
+    (#57, #95, Norbert Pozar). `func()` method now element names with
+    multiple fragements like `math.attach`.
+
+  * Match raw block handling of Typst 0.14 (#94, Norbert Pozar).
+    This commit should produce the same result.
+
+    - Automatically dedent raw text based on the shortest indent of the raw
+      code. In particular, do not use `stIndent` for this since Typst does not
+      dedent the code based on the indentation of the containing list item.
+    - Accept any identifier-like language tags.
+    - Strip the last line if it is only whitespace.
+    - If the last line's nonwhitespace chars ends with `, strip one
+      space from the end.
+
+  * Tweak comment parsing to match Typst (#93, Norbert Pozar).
+
+    - Line comments inside block comments are not parsed as line comments
+      anymore (partially addresses #90).
+    - Block comments do not need to be closed by */ and can be active until
+      the end of file (partially addresses #90).
+    - Error is properly reported when unmatched */ appears instead of
+      misparsing this as a beginning of strong elem.
+    - Stop line comments from eating the end of line character
+      This is important for correctly issuing parbreaks and spaces that
+      follow line comments and a preparation for simpler handling of indented
+      blocks.
+
+  * Hide `#let test..` definition from test parse output (Norbert Pozar).
+    After this change the test function `#let test(...` is only injected
+    at evaluation and its parsed AST no longer appears in `.out` files.
+    Other advantages:
+
+    - Source locations match the input file.
+    - Future changes to AST will not show up in every output.
+    - Easier to read test output.
+    - 5% faster test run (5s -> 4.75s)
+
+  * Simpler tracking of bracket nesting in markup (Norbert Pozar, #86).
+    Keep the count of unclosed brackets in `PState` instead of using a
+    `between` parser to prevent exponential parsing time due to backtracing.
+
+  * Improve handling of control flow statements at loop block boundaries
+    (Norbert Pozar).
+
+    - `break` and `continue` now only affect the innermost `for` and `while`
+      loop by resetting `evalFlowDirective` at the loop end.
+    - `return` now returns even when used inside a loop: it stops the loop the
+      same way `break` does but its state is not reset at the end of the
+      loop so propagates up to the function boundary.
+
+  * `array.join()`: do not prepend separator for length 1 arrays (Norbert
+    Pozar). Separator is now only inserted when the array has at least 2
+    elements.
+
+ *  Support nested destructuring binds and expressions in LHS of assignments
+    (Norbert Pozar).
+
+  * Parse (..expr) as Array (Norbert Pozar, #47).
+    Trailing comma is not required in an array expression with single spread
+    operator. Also spreads `none`.
+
+  * Support nested destructuring (Norbert Pozar).
+    Typst supports nesting of destructuring binds both in array
+    destructuring `(_, (_, _), _)` and dictionary destructuring
+    `(x: (_, _), y)`. This commit adds support for such nested
+    destructuring of arbitrary depth.
+
+    Changes AST for `BindPart` to allow for recursion [API change].
+
+    -  `Simple (Maybe Identifier)` -> `Simple Bind`
+    -  `WithKey Identifier (Maybe Identifier)` -> `WithKey Identifier Bind`
+
+    It also disallows "unnamed patterns" when destructuring from a
+    dictionary (to match Typst behavior):
+
+    ```typst
+    #let (_, x) = (x: 1, y: 1)
+    //    ^ unnamed
+    #let ((a, b), x) = (x: 1, y: 1)
+    //    ^^^^^^ unnamed
+    ```
+
 ## 0.8.1
 
   * Fix parsing and evaluation of closures with _ (#84, Norbert Pozar).
diff --git a/src/Typst/Bind.hs b/src/Typst/Bind.hs
--- a/src/Typst/Bind.hs
+++ b/src/Typst/Bind.hs
@@ -1,105 +1,124 @@
 {-# LANGUAGE RankNTypes #-}
 
-module Typst.Bind (destructuringBind) where
+module Typst.Bind (destructuringBind, doBind) where
 
 import Control.Monad.State
 import qualified Data.Map.Ordered as OM
-import Data.Maybe (fromMaybe)
 import qualified Data.Vector as V
 import Typst.Syntax
 import Typst.Types
 
+
+doBind ::
+  Monad m =>
+  (forall m'. Monad m' => Expr -> Val -> MP m' ()) ->
+  Bind ->
+  Val ->
+  MP m ()
+doBind _ (BasicBind Nothing) _ = pure ()
+doBind updateExpression (BasicBind (Just ident)) val = updateExpression (Ident ident) val
+doBind updateExpression (ExprBind expr) val = updateExpression expr val
+doBind updateExpression (DestructuringBind parts) val =
+  destructuringBind updateExpression parts val
+
 destructuringBind ::
   Monad m =>
-  (forall m'. Monad m' => Identifier -> Val -> MP m' ()) ->
+  (forall m'. Monad m' => Expr -> Val -> MP m' ()) ->
   [BindPart] ->
   Val ->
   MP m ()
-destructuringBind setIdentifier parts val = do
+destructuringBind updateExpression parts val = do
   let isSink Sink {} = True
+      isSink ExprSink {} = True
       isSink _ = False
   let (fronts, rest) = break isSink parts
   let (sinks, backs) = span isSink rest
   mbsink <- case sinks of
-    [Sink s] -> pure s
+    [s] -> pure $ Just s
     [] -> pure Nothing
     _ -> fail "Bind cannot contain multiple sinks"
   case val of
     VDict m ->
-      evalStateT (destructureDict setIdentifier fronts backs mbsink) m
+      evalStateT (destructureDict updateExpression fronts backs mbsink) m
     VArray v ->
-      evalStateT (destructureArray setIdentifier fronts backs mbsink) v
+      evalStateT (destructureArray updateExpression fronts backs mbsink) v
     _ -> fail "Only Array or Dictionary values can be destructured"
 
 destructureDict ::
   Monad m =>
-  (forall m'. Monad m' => Identifier -> Val -> MP m' ()) ->
+  (forall m'. Monad m' => Expr -> Val -> MP m' ()) ->
   [BindPart] ->
   [BindPart] ->
-  Maybe Identifier ->
+  Maybe BindPart ->
   StateT (OM.OMap Identifier Val) (MP m) ()
-destructureDict setIdentifier fronts backs mbsink = do
+destructureDict updateExpression fronts backs mbsink = do
   mapM_ handleDictBind (fronts ++ backs)
   case mbsink of
-    Just i -> get >>= lift . setIdentifier i . VDict
+    Just (Sink (Just i)) -> get >>= lift . updateExpression (Ident i) . VDict
+    Just (ExprSink expr) -> get >>= lift . updateExpression expr . VDict
+    Just (Sink Nothing) -> pure ()
     Nothing -> pure ()
+    Just _ -> fail "unreachable: expected Sink or SinkExpr"
   where
     handleDictBind :: Monad m => BindPart -> StateT (OM.OMap Identifier Val) (MP m) ()
     handleDictBind (Sink {}) = fail "Bind cannot contain multiple sinks"
-    handleDictBind (Simple Nothing) = pure ()
-    handleDictBind (Simple (Just i)) = do
+    handleDictBind (ExprSink {}) = fail "Bind cannot contain multiple sinks"
+    handleDictBind (Simple (BasicBind (Just i))) = do
       m <- get
       case OM.lookup i m of
         Nothing ->
           fail $ "Destructuring key not found in dictionary: " <> show i
         Just v -> do
           put $ OM.delete i m
-          lift $ setIdentifier i v
-    handleDictBind (WithKey key mbident) = do
+          lift $ updateExpression (Ident i) v
+    handleDictBind (Simple _) = fail "cannot destructure unnamed pattern from dictionary"
+    handleDictBind (WithKey key bind) = do
       m <- get
       case OM.lookup key m of
         Nothing ->
           fail $ "Destructuring key not found in dictionary: " <> show key
         Just v -> do
           put $ OM.delete key m
-          lift $ setIdentifier (fromMaybe key mbident) v
+          lift $ doBind updateExpression bind v
 
+
 destructureArray ::
   Monad m =>
-  (forall m'. Monad m' => Identifier -> Val -> MP m' ()) ->
+  (forall m'. Monad m' => Expr -> Val -> MP m' ()) ->
   [BindPart] ->
   [BindPart] ->
-  Maybe Identifier ->
+  Maybe BindPart ->
   StateT (V.Vector Val) (MP m) ()
-destructureArray setIdentifier fronts backs mbsink = do
+destructureArray updateExpression fronts backs mbsink = do
   mapM_ handleFrontBind fronts
   mapM_ handleBackBind (reverse backs)
   case mbsink of
-    Just i -> get >>= lift . setIdentifier i . VArray
+    Just (Sink (Just i)) -> get >>= lift . updateExpression (Ident i) . VArray
+    Just (ExprSink expr) -> get >>= lift . updateExpression expr . VArray
+    Just (Sink Nothing) -> pure ()
     Nothing -> pure ()
+    Just _ -> fail "unreachable: expected Sink or SinkExpr"
   where
     handleFrontBind :: Monad m => BindPart -> StateT (V.Vector Val) (MP m) ()
     handleFrontBind (Sink {}) = fail "Bind cannot contain multiple sinks"
+    handleFrontBind (ExprSink {}) = fail "Bind cannot contain multiple sinks"
     handleFrontBind (WithKey {}) = fail "Cannot destructure array with key"
-    handleFrontBind (Simple mbi) = do
+    handleFrontBind (Simple bind) = do
       v <- get
       case V.uncons v of
         Nothing -> fail "Array does not contain enough elements to destructure"
         Just (x, v') -> do
           put v'
-          case mbi of
-            Nothing -> pure ()
-            Just i -> lift $ setIdentifier i x
+          lift $ doBind updateExpression bind x
 
     handleBackBind :: Monad m => BindPart -> StateT (V.Vector Val) (MP m) ()
     handleBackBind (Sink {}) = fail "Bind cannot contain multiple sinks"
+    handleBackBind (ExprSink {}) = fail "Bind cannot contain multiple sinks"
     handleBackBind (WithKey {}) = fail "Cannot destructure array with key"
-    handleBackBind (Simple mbi) = do
+    handleBackBind (Simple bind) = do
       v <- get
       case V.unsnoc v of
         Nothing -> fail "Array does not contain enough elements to destructure"
         Just (v', x) -> do
           put v'
-          case mbi of
-            Nothing -> pure ()
-            Just i -> lift $ setIdentifier i x
+          lift $ doBind updateExpression bind x
diff --git a/src/Typst/Evaluate.hs b/src/Typst/Evaluate.hs
--- a/src/Typst/Evaluate.hs
+++ b/src/Typst/Evaluate.hs
@@ -14,7 +14,7 @@
   )
 where
 
-import Control.Monad (MonadPlus (mplus), foldM, foldM_)
+import Control.Monad (MonadPlus (mplus), foldM, foldM_, when)
 import Control.Monad.State (MonadTrans (lift))
 import Data.List (intersperse, sortOn)
 import Data.Foldable (toList)
@@ -32,7 +32,7 @@
 import System.FilePath (replaceFileName, takeBaseName,
                         takeFileName, takeDirectory, (</>))
 import Text.Parsec
-import Typst.Bind (destructuringBind)
+import Typst.Bind (destructuringBind, doBind)
 import Typst.Constructors (getConstructor)
 import Typst.Methods (getMethod)
 import Typst.Module.Standard (loadFileText, standardModule, symModule, getPath)
@@ -217,9 +217,6 @@
     Strong ms -> do
       body <- pInnerContents ms
       element "strong" Arguments {positional = [VContent body], named = OM.empty}
-    Bracketed ms -> do
-      body <- pInnerContents ms
-      pure $ (Txt "[" Seq.<| body) Seq.|> Txt "]"
     RawBlock lang txt ->
       element
         "raw"
@@ -247,6 +244,7 @@
                 ]
           }
     Heading level ms -> do
+      skipMany $ satisfyTok isBreak
       content <- pInnerContents ms
       element
         "heading"
@@ -480,6 +478,7 @@
                    val <- evalExpr y
                    case val of
                      VArray ys -> pure (xs <> ys)
+                     VNone -> pure xs
                      _ -> fail $ "Could not spread " <> show (valType val) <>
                                  " into array"
                  Reg e -> do
@@ -538,10 +537,7 @@
     Ident ident -> lookupIdentifier ident
     Let bind e -> do
       val <- evalExpr e
-      case bind of
-        BasicBind (Just ident) -> addIdentifier ident val
-        BasicBind Nothing -> pure ()
-        DestructuringBind parts -> destructuringBind addIdentifier parts val
+      doBind addIdentifierByExpr bind val
       pure VNone
     LetFunc name params e -> do
       val <- toFunction (Just name) params e
@@ -768,10 +764,13 @@
     Assign e1 e2 -> do
       val <- evalExpr e2
       case e1 of
-        Binding (BasicBind (Just ident)) -> updateIdentifier ident val
-        Binding (BasicBind Nothing) -> pure ()
-        Binding (DestructuringBind parts) ->
-          destructuringBind updateIdentifier parts val
+        Binding bind -> doBind updateExpression bind val
+        Array spreadables -> do
+          bind <- arrayExprToBind spreadables
+          doBind updateExpression bind val
+        Dict spreadables -> do
+          bind <- dictExprToBind spreadables
+          doBind updateExpression bind val
         x -> updateExpression x val
       pure VNone
     If clauses -> do
@@ -789,23 +788,16 @@
             case condval of
               VBoolean True -> do
                 val <- evalExpr e2
-                hadBreak <- (== FlowBreak) . evalFlowDirective <$> getState
-                joinVals result val >>= if hadBreak then pure else go
+                joinVals result val >>= ifNotBreakOrReturn go
               VBoolean False -> pure result
               _ -> fail "While loop requires a boolean condition"
-      updateState $ \st -> st {evalFlowDirective = FlowNormal}
-      go VNone
+      go VNone >>= finalizeLoop
     For bind e1 e2 -> do
       let go [] result = pure result
           go (x : xs) result = do
-            case bind of
-              BasicBind (Just ident) -> addIdentifier ident x
-              BasicBind Nothing -> pure ()
-              DestructuringBind parts ->
-                destructuringBind addIdentifier parts x
+            doBind addIdentifierByExpr bind x
             val <- evalExpr e2
-            hadBreak <- (== FlowBreak) . evalFlowDirective <$> getState
-            joinVals result val >>= if hadBreak then pure else go xs
+            joinVals result val >>= ifNotBreakOrReturn (go xs)
       source <- evalExpr e1
       items <- case source of
         VString t -> pure $ map (VString . T.singleton) (T.unpack t)
@@ -818,8 +810,7 @@
               )
               (OM.assocs m)
         _ -> fail $ "For expression requires an Array or Dictionary"
-      updateState $ \st -> st {evalFlowDirective = FlowNormal}
-      go items VNone
+      go items VNone >>= finalizeLoop
     Context e -> do
       evalExpr e -- TODO for now we just ignore "context"
     Return mbe -> do
@@ -895,7 +886,7 @@
               case positional as of
                 [] -> fail ("Expected parameter " <> show parts)
                 (x : xs) -> do
-                  destructuringBind addIdentifier parts x
+                  destructuringBind addIdentifierByExpr parts x
                   pure $ as {positional = xs}
             setParam as SkipParam = do
               case positional as of
@@ -1119,6 +1110,12 @@
     ((s, i) : is) -> updateState $ \st ->
       st { evalIdentifiers = (s, M.insert ident val i) : is }
 
+addIdentifierByExpr :: Monad m => Expr -> Val -> MP m ()
+addIdentifierByExpr Underscore _ = pure ()
+addIdentifierByExpr (Ident ident) val = addIdentifier ident val
+addIdentifierByExpr _ _ = fail "expected pattern, found expression"
+
+
 updateIdentifier :: Monad m => Identifier -> Val -> MP m ()
 updateIdentifier ident val = do
   let go (True, is) (s, m) = pure (True, (s, m) : is)
@@ -1149,6 +1146,23 @@
       }
   pure result
 
+ifNotBreakOrReturn :: Monad m => (Val -> MP m Val) -> Val -> MP m Val
+ifNotBreakOrReturn go val = do
+  flow <- evalFlowDirective <$> getState
+  case flow of
+    FlowBreak -> pure val
+    FlowReturn _ -> pure val
+    _ -> go val
+
+finalizeLoop :: Monad m => Val -> MP m Val
+finalizeLoop result = do
+  flow <- evalFlowDirective <$> getState
+  -- do not reset FlowReturn
+  when (flow == FlowBreak || flow == FlowContinue) $
+    updateState $ \st -> st {evalFlowDirective = FlowNormal}
+  pure result
+  
+
 updateExpression :: Monad m => Expr -> Val -> MP m ()
 updateExpression
   (FuncCall (FieldAccess (Ident (Identifier "first")) e') []) val
@@ -1178,9 +1192,12 @@
     idx <- evalExpr arg
     case container of
       VArray v ->
-        case idx of
+        let toPos n = if n < 0
+              then V.length v + n
+              else n
+        in case idx of
           VInteger i ->
-            let i' = fromIntegral i
+            let i' = toPos $ fromIntegral i
             in case v V.!? i' of
                  Nothing | not allowNewIndices
                      -> fail $ "Vector does not contain index " <> show i'
@@ -1213,3 +1230,26 @@
 toSelector (VLabel t) = pure $ SelectLabel t
 toSelector (VSymbol (Symbol t _ _)) = pure $ SelectString t
 toSelector v = fail $ "could not convert " <> show v <> " to selector"
+
+arrayExprToBind :: Monad m => [Spreadable Expr] -> MP m Bind
+arrayExprToBind spredables = DestructuringBind <$> mapM spreadableToBindPart spredables
+    where
+      spreadableToBindPart (Reg expr) = Simple <$> exprToBind expr
+      spreadableToBindPart (Spr (Ident ident)) = pure $ Sink $ Just ident
+      spreadableToBindPart (Spr expr) = pure $ ExprSink expr
+
+dictExprToBind :: Monad m => [Spreadable (Expr, Expr)] -> MP m Bind
+dictExprToBind spredables = DestructuringBind <$> mapM spreadableToBindPart spredables
+    where
+      spreadableToBindPart (Reg (Ident ident, expr)) = WithKey ident <$> exprToBind expr
+      spreadableToBindPart (Reg (_, _)) = fail $ "expected identifier"
+      spreadableToBindPart (Spr (Ident ident)) = pure $ Sink $ Just ident
+      spreadableToBindPart (Spr expr) = pure $ ExprSink expr
+
+exprToBind :: Monad m => Expr -> MP m Bind
+exprToBind (Binding bind) = pure $ bind
+exprToBind Underscore = pure $ BasicBind $ Nothing
+exprToBind (Ident ident) = pure $ BasicBind $ Just ident
+exprToBind (Array spredables) = arrayExprToBind spredables
+exprToBind (Dict spredables) = dictExprToBind spredables
+exprToBind expr = pure $ ExprBind expr
diff --git a/src/Typst/Methods.hs b/src/Typst/Methods.hs
--- a/src/Typst/Methods.hs
+++ b/src/Typst/Methods.hs
@@ -322,7 +322,17 @@
       case fld of
         "func" -> pure $ makeFunction $ do
           case F.toList cs of
-            [Elt name _ _] -> lift $ lookupIdentifier name
+            [Elt name@(Identifier ident) _ _] -> lift $ do
+                      case T.splitOn "." ident of
+                        [] -> lookupIdentifier name
+                        (n:ns) -> do 
+                          lookupIdentifier (Identifier n) >>= go n ns
+                    where
+                      go _ [] i = pure i
+                      go path (n:ns) (VModule _ m) = case M.lookup (Identifier n) m of
+                            Just x -> go (path <> "." <> n) ns x
+                            Nothing -> fail $ "Module " <> show path <> " does not contain " <> show n
+                      go path _ _ = fail $ show path <> " is not a module"
             [Txt _] -> lift $ lookupIdentifier "text"
             _ -> pure $ makeFunction $ do
               xs <- allArgs
@@ -545,6 +555,7 @@
           let xs' = F.toList v
           let xs = case xs' of
                 [] -> []
+                [_] -> xs'
                 _ -> intersperse separator (init xs') ++ [lastsep, last xs']
           foldM joinVals VNone xs
         "sorted" -> pure $ makeFunction $ do
diff --git a/src/Typst/Parse.hs b/src/Typst/Parse.hs
--- a/src/Typst/Parse.hs
+++ b/src/Typst/Parse.hs
@@ -7,7 +7,7 @@
   )
 where
 
-import Data.List (sortOn)
+import Data.List (sortOn, intercalate, dropWhileEnd)
 import Control.Applicative (some)
 import Control.Monad (MonadPlus (mzero), guard, void, when)
 import Control.Monad.Identity (Identity)
@@ -37,24 +37,24 @@
     Right r -> Right r
 
 data PState = PState
-  { stIndent :: [Int],
-    stLineStartCol :: !Int,
+  { stAtStart :: !Bool,
     stAllowNewlines :: !Int, -- allow newlines if > 0
     stSpaceBefore :: Maybe (SourcePos, Text),
     stLastMathTok :: Maybe (SourcePos, Markup),
-    stContentBlockNesting :: Int
+    stContentBlockNesting :: Int,
+    stBracketNesting :: Int
   }
   deriving (Show)
 
 initialState :: PState
 initialState =
   PState
-    { stIndent = [],
-      stLineStartCol = 1,
+    { stAtStart = True,
       stAllowNewlines = 0,
       stSpaceBefore = Nothing,
       stLastMathTok = Nothing,
-      stContentBlockNesting = 0
+      stContentBlockNesting = 0,
+      stBracketNesting = 0
     }
 
 type P = Parsec Text PState
@@ -116,11 +116,17 @@
 inBraces pa = withNewlines (between (sym "{") (char '}') pa) <* ws
 
 pMarkup :: P Markup
-pMarkup =
-  pSpace
-    <|> pHeading
-    <|> pComment
-    <|> pEol
+pMarkup = pTrivia <|> pNonTriviaMarkup
+
+pTrivia :: P Markup
+pTrivia = pTriviaWithoutEol <|> pEol
+
+pTriviaWithoutEol :: P Markup
+pTriviaWithoutEol = pSpace <|> pComment
+
+pNonTriviaMarkup :: P Markup
+pNonTriviaMarkup = do
+  mp <- pHeading
     <|> pHardbreak
     <|> pStrong
     <|> pEmph
@@ -138,20 +144,20 @@
     <|> pLabelInContent
     <|> pRef
     <|> pHash
-    <|> pBracketed
     <|> pSymbol
-
--- We need to group paired brackets or the closing bracketed may be
--- taken to close a pContent block:
-pBracketed :: P Markup
-pBracketed =
-  Bracketed <$> try (between (char '[') (char ']') (many pMarkup))
+  updateState $ \st -> st {stAtStart = False}
+  pure mp
 
 pSymbol :: P Markup
 pSymbol = do
-  blockNesting <- stContentBlockNesting <$> getState
-  let isSpecial' c = isSpecial c && (c /= ']' || blockNesting == 0)
-  Text . T.singleton <$> satisfy isSpecial'
+  bracketNesting <- stBracketNesting <$> getState
+  let isSpecial' c = isSpecial c && (c /= ']' || bracketNesting > 0)
+  c <- satisfy isSpecial'
+  case c of
+    '[' -> updateState $ \st -> st { stBracketNesting = bracketNesting + 1}
+    ']' -> updateState $ \st -> st { stBracketNesting = bracketNesting - 1}
+    _ -> pure ()
+  pure $ Text $ T.singleton $ c
 
 -- equation ::= ('$' math* '$') | ('$ ' math* ' $')
 pEquation :: P Markup
@@ -433,45 +439,71 @@
   lexeme ( Text . T.singleton
             <$> satisfy (\c -> not (isSpace c) && c /= '$' && c /= '\\'))
 
-withIndent :: Int -> P a -> P a
-withIndent indent pa = do
-  oldIndent <- stIndent <$> getState
-  updateState $ \st -> st {stIndent = indent : oldIndent}
-  ms <- pa
-  updateState $ \st -> st {stIndent = oldIndent}
-  pure ms
+-- Parser that discards leading trivia, and does not parse trailing trivia
+-- unless followed by non-trivia markup. Stops when non-trivia markup would
+-- match `stop` parser.
+-- Does not allow new lines except in block comments.
+pSinglelineWhileNot :: Show a => P a -> P [Markup]
+pSinglelineWhileNot stop = do
+  (concat . drop 1 . concat) <$> many pSinglelineChunk
+  where
+    pSinglelineChunk :: P [[Markup]]
+    pSinglelineChunk = try $ do
+      trivia <- many1 pTriviaWithoutEol
+      markup <- many1 (notFollowedBy stop >> pNonTriviaMarkup)
+      pure [trivia, markup]
 
 -- list ::= '-' space markup
 -- enum ::= (digit+ '.' | '+') space markup
 -- desc ::= '/' space markup ':' space markup
 pListItem :: P Markup
 pListItem = do
+  getState >>= guard . stAtStart
   col <- sourceColumn <$> getPosition
-  startLine <- stLineStartCol <$> getState
-  guard (col == startLine)
   try
     ( do
-        void $ char '-'
-        void (char ' ') <|> pBlankline
-        BulletListItem <$> withIndent col (many pMarkup)
+        char '-' *> guardAfterListOrHeadingMarker
+        BulletListItem <$> pIndented col
     )
     <|> try
       ( do
           start <- (Nothing <$ char '+') <|> (Just <$> enumListStart)
-          void (char ' ') <|> pBlankline
-          EnumListItem start <$> withIndent col (many pMarkup)
+          guardAfterListOrHeadingMarker
+          EnumListItem start <$> pIndented col
       )
-    <|> try
-      ( do
+    <|> do
           -- desc list
-          void (char '/')
-          void (many1 (char ' '))
-          term <- manyTill pMarkup (char ':')
-          skipMany spaceChar
-          optional pBlankline
-          DescListItem term <$> withIndent col (many pMarkup)
-      )
+          try $ char '/' *> guardAfterListOrHeadingMarker
+          updateState $ \st -> st {stAtStart = False}
+          term <- pSinglelineWhileNot (char ':')
+          -- previous parser might have left trivia before `:`
+          skipMany pTriviaWithoutEol <* char ':'
+          updateState $ \st -> st {stAtStart = True}
+          DescListItem term <$> pIndented col
+  where
+    -- Parser that discards leading trivia, and does not parse trailing trivia
+    -- if not followed by properly indented non-trivia markup.
+    pIndented :: Int -> P [Markup]
+    pIndented indent = do
+      (concat . drop 1 . concat) <$> many pIndentedChunk
+      where
+        pIndentedChunk :: P [[Markup]]
+        pIndentedChunk = try $ do
+          -- there might be no trivia following `:` in desc list
+          trivia <- many pTrivia
+          col <- sourceColumn <$> getPosition
+          guard $ (col > indent) || not (any isEol trivia)
+          markup <- many1 pNonTriviaMarkup
+          pure [trivia, markup]
+          where
+            isEol SoftBreak = True
+            isEol ParBreak = True
+            isEol _ = False
 
+guardAfterListOrHeadingMarker :: P ()
+guardAfterListOrHeadingMarker = lookAhead $ 
+  void (satisfy isSpace) <|> void (string "//") <|> void (string "/*") <|>  eof
+
 enumListStart :: P Int
 enumListStart = do
   ds <- many1 digit
@@ -481,15 +513,20 @@
     Just x -> pure x
 
 -- line-comment = '//' (!unicode(Newline))*
--- block-comment = '/*' (. | block-comment)* '*/'
+-- block-comment = '/*' (block-comment | .)* ('*/' | eof)
 pComment :: P Markup
-pComment = Comment <$ (pLineComment <|> pBlockComment)
+pComment = (
+              do
+                pos <- getPosition
+                void $ string "*/"
+                setPosition pos
+                fail "Unexpected end of block comment"
+            ) <|> Comment <$ (pLineComment <|> pBlockComment)
 
 pLineComment :: P ()
 pLineComment = do
   void $ string "//"
   skipMany (satisfy (\c -> c /= '\n' && c /= '\r'))
-  void endOfLine <|> eof
 
 pBlockComment :: P ()
 pBlockComment = do
@@ -497,10 +534,9 @@
   void $
     manyTill
       ( pBlockComment
-          <|> pLineComment
           <|> void anyChar
       )
-      (string "*/")
+      (void (string "*/") <|> eof)
 
 pSpace :: P Markup
 pSpace = Space <$ some (satisfy (\c -> isSpace c && c /= '\r' && c /= '\n'))
@@ -508,6 +544,7 @@
 pEol :: P Markup
 pEol = do
   pBaseEol
+  updateState $ \st -> st {stAtStart = True}
   (ParBreak <$ many1 pBaseEol)
     <|> (ParBreak <$ pEndOfContent)
     <|> pure SoftBreak
@@ -515,18 +552,7 @@
 pBaseEol :: P ()
 pBaseEol = try $ do
   void endOfLine
-  -- fail if we can't indent enough
-  indents <- stIndent <$> getState
-  case indents of
-    (i : _) -> void (try (count i (char ' '))) <|> pBlankline
-    [] -> pure ()
-  eatPrefixSpaces
-
-eatPrefixSpaces :: P ()
-eatPrefixSpaces = do
   skipMany spaceChar
-  col <- sourceColumn <$> getPosition
-  updateState $ \st -> st {stLineStartCol = col}
 
 spaceChar :: P Char
 spaceChar = satisfy (\c -> c == ' ' || c == '\t')
@@ -535,11 +561,6 @@
 pHardbreak =
   HardBreak <$ try (char '\\' *> (void spaceChar <|> pBaseEol) *> skipMany spaceChar)
 
-pBlankline :: P ()
-pBlankline = try $ do
-  skipMany spaceChar
-  void (lookAhead endOfLine) <|> pEndOfContent
-
 pRawInline :: P Markup
 pRawInline =
   RawInline . T.pack
@@ -549,49 +570,73 @@
 pRawBlock = do
   void $ string "```"
   numticks <- (+ 3) . length <$> many (char '`')
-  lang <- T.pack <$> (many alphaNum <* optional (char ' '))
-  optional $ try $ skipMany (char ' ') *> pEol
-  let nl = newline <* optionalGobbleIndent
-  code <-
-    T.pack
-      <$> manyTill
-        (nl <|> anyChar)
-        (string (replicate numticks '`'))
-  skipMany (char '`')
-  pure $ RawBlock lang code
+  lang <- T.pack <$> option "" pLangTag
+  code <- manyTill anyChar (string (replicate numticks '`'))
 
-optionalGobbleIndent :: P ()
-optionalGobbleIndent = do
-  indents <- stIndent <$> getState
-  case indents of
-    (i : _) -> gobble i
-    [] -> pure ()
+  -- Dedent raw text; detailed description at
+  -- 0.14.2: https://github.com/typst/typst/blob/b33de9de113c91c184214b299bd7a8eb3070c3ab/crates/typst-syntax/src/lexer.rs#L310-L338 
+  
+  -- Use parser to handle CRLF; built-in `lines` would also strip trailing \n
+  let (most, lst) = either (\_ -> ([], "")) id $ runParser splitlines () "" code
+  let nonblankSkipFirst = filter (not . all isSpace) $ drop 1 most
+  -- The last line is always considered
+  let dedent = minOrZero $ map (length . takeWhile isSpace) $ lst:nonblankSkipFirst
+  
+  let mostDedented = case most of
+                        [] -> []
+                        (x:xs) | all isSpace x -> map (drop dedent) xs
+                        -- remove optional single space after the language tag/opening ```
+                        ((' ':x):xs) -> x:(map (drop dedent) xs) 
+                        (x:xs) -> x:(map (drop dedent) xs) 
+  let dedented = if not (all isSpace lst)
+                then mostDedented <> [stripOneSpaceIfEndsWithBacktick $ drop dedent lst]
+                else mostDedented
+
+  pure $ RawBlock lang (T.pack $ intercalate "\n" dedented)
   where
-    gobble :: Int -> P ()
-    gobble 0 = pure ()
-    gobble n = (char ' ' *> gobble (n - 1)) <|> pure ()
+    -- This parser should always succeed
+    splitlines :: Parsec String () ([String], String)
+    splitlines = do
+      most <- many (try $ manyTill anyChar endOfLine)
+      lst <- manyTill anyChar eof
+      pure (most, lst)
+    minOrZero [] = 0
+    minOrZero xs = minimum xs
+    -- Allowed lang tag might change in future Typst versions, see
+    -- https://github.com/typst/typst/pull/7337
+    pLangTag = do
+      c <- satisfy isIdentStart
+      cs <- many $ satisfy isIdentContinue
+      pure $ (c : cs)
+    stripOneSpaceIfEndsWithBacktick s = case dropWhileEnd isSpace s of
+        [] -> s
+        xs | last xs == '`' -> dropOneSpaceAtEnd s
+        _ -> s
+      where
+        dropOneSpaceAtEnd xs =
+          case reverse xs of
+            (' ' : rest) -> reverse rest
+            _            -> xs
 
 pStrong :: P Markup
-pStrong = Strong <$> (char '*' *> manyTill pMarkup (char '*'))
+pStrong = do
+  void $ char '*'
+  updateState $ \st -> st {stAtStart = False}
+  Strong <$> manyTill pMarkup (char '*')
 
 pEmph :: P Markup
-pEmph = Emph <$> (char '_' *> manyTill pMarkup (char '_'))
+pEmph = do
+  void $ char '_'
+  updateState $ \st -> st {stAtStart = False}
+  Emph <$> manyTill pMarkup (char '_')
 
 pHeading :: P Markup
 pHeading = try $ do
-  col <- sourceColumn <$> getPosition
-  lineStartCol <- stLineStartCol <$> getState
-  guard (col == lineStartCol)
+  getState >>= guard . stAtStart
   lev <- length <$> many1 (char '=')
-  void (many1 (char ' ')) <|> void (lookAhead endOfLine)
-  -- Note: == hi _foo
-  -- bar_ is parsed as a heading with "hi emph(foobar)"
-  ms <- manyTill pMarkup (    void pEol
-                          <|> pEndOfContent
-                          <|> void (lookAhead (try (spaces *> pLabel)))
-                          <|> void (lookAhead (char ']')))
-  skipMany spaceChar
-  pure $ Heading lev ms
+  guardAfterListOrHeadingMarker
+  updateState $ \st -> st {stAtStart = False}
+  Heading lev <$> pSinglelineWhileNot pLabel
 
 pUrl :: P Markup
 pUrl = try $ do
@@ -846,7 +891,8 @@
     <|> ident_parser
     <|> pArrayExpr
     <|> pDictExpr
-    <|> inParens pExpr
+    <|> try (inParens pExpr)
+    <|> (Binding <$> pDestructuringBind True)
     <|> pLabel
     <|> (Block . Content . (: [])
          <$> lexeme (pRawBlock <|> pRawInline <|> pEquation))
@@ -1040,25 +1086,25 @@
 -- content-block ::= '[' markup ']'
 pContent :: P Block
 pContent = do
+  pos <- getPosition
   void $ char '['
-  col <- sourceColumn <$> getPosition
-  oldLineStartCol <- stLineStartCol <$> getState
-  oldIndent <- stIndent <$> getState
+  oldBracketNesting <- stBracketNesting <$> getState
   updateState $ \st ->
     st
-      { stLineStartCol = col,
+      { stAtStart = True,
         stContentBlockNesting =
           stContentBlockNesting st + 1,
-        stIndent = []
+        stBracketNesting = 0
       }
-  ms <- manyTill pMarkup (char ']')
+  ms <- many pMarkup
+  void $ (char ']' <?> "unclosed delimiter at" <> show pos)
   ws
   updateState $ \st ->
     st
-      { stLineStartCol = oldLineStartCol,
+      { stAtStart = False,
         stContentBlockNesting =
           stContentBlockNesting st - 1,
-        stIndent = oldIndent
+        stBracketNesting = oldBracketNesting
       }
   pure $ Content ms
 
@@ -1070,7 +1116,7 @@
       then void (lookAhead (char ']'))
       else mzero
 
--- array-expr ::= '(' ((expr ',') | (expr (',' expr)+ ','?))? ')'
+-- array-expr ::= '(' (('..' expr) | (expr ',') | (expr (',' expr)+ ','?))? ')'
 pArrayExpr :: P Expr
 pArrayExpr =
   try $
@@ -1078,9 +1124,9 @@
       ( do
           v <- pSpread <|> (Reg <$> pExpr)
           vs <- many $ try $ sym "," *> (pSpread <|> (Reg <$> pExpr))
-          if null vs
-            then void $ sym ","
-            else optional $ void $ sym ","
+          case (v, vs) of
+            ((Reg _), []) -> void $ sym ","
+            _ -> optional $ void $ sym ","
           pure $ Array (v : vs)
       )
         <|> (Array [] <$ optional (void $ sym ","))
@@ -1165,11 +1211,20 @@
       i <- try pIdentifier
       (DefaultParam i <$> (sym ":" *> pExpr)) <|> pure (NormalParam i)
     pDestructuringParam = do
-      DestructuringBind parts <- pDestructuringBind
+      DestructuringBind parts <- pDestructuringBind False
       pure $ DestructuringParam parts
 
-pBind :: P Bind
-pBind = pBasicBind <|> pDestructuringBind
+pBind :: Bool -> P Bind
+pBind False = pBasicBind <|> pDestructuringBind False
+-- arbitrary expressions are allowed in assignment binds but DestructuringBind is preferred
+pBind True = pDestructuringBind True <|> pExprBind
+  where
+    pExprBind = do
+      expr <- pExpr
+      pure $ case expr of
+        Underscore -> BasicBind Nothing
+        Ident ident -> BasicBind $ Just ident
+        _ -> ExprBind expr
 
 pBasicBind :: P Bind
 pBasicBind = BasicBind <$> try (pBindIdentifier <|> inParens pBindIdentifier)
@@ -1181,30 +1236,34 @@
      then pure Nothing
      else pure $ Just ident
 
-pDestructuringBind :: P Bind
-pDestructuringBind =
+pDestructuringBind :: Bool -> P Bind
+pDestructuringBind allowExpr =
   inParens $
-    DestructuringBind <$> (pBindPart `sepEndBy` (sym ","))
+    DestructuringBind <$> ((pSink <|> pWithKey <|> pSimple) `sepEndBy` (sym ","))
   where
-    pBindPart = do
-      sink <- option False $ True <$ string ".."
-      if sink
+    pSink = do
+      void $ string ".."
+      if allowExpr
         then do
-          ident <- option Nothing pBindIdentifier -- ..
-          pure $ Sink ident
-        else do
-          ident <- pBindIdentifier
-          case ident of
-            Nothing -> pure (Simple ident)
-            Just key ->
-              (WithKey key <$> (sym ":" *> pBindIdentifier))
-                <|> pure (Simple ident)
+          mbexpr <- option Nothing $ Just <$> pExpr
+          pure $ case mbexpr of
+            Nothing -> Sink Nothing
+            Just Underscore -> Sink Nothing
+            Just (Ident ident) -> Sink $ Just ident
+            Just (expr) -> ExprSink expr
+        else Sink <$> option Nothing pBindIdentifier
+    pWithKey = do
+      key <- try $ pBindIdentifier <* sym ":"
+      case key of
+        Nothing -> fail "expected identifier, found underscore"
+        Just ident -> WithKey ident <$> pBind allowExpr
+    pSimple = Simple <$> pBind allowExpr
 
 -- let-expr ::= 'let' ident params? '=' expr
 pLetExpr :: P Expr
 pLetExpr = do
   pKeyword "let"
-  bind <- pBind
+  bind <- pBind False
   case bind of
     BasicBind mbname -> do
       mbparams <- option Nothing $ Just <$> pParams
@@ -1255,7 +1314,7 @@
 -- for-expr ::= 'for' bind 'in' expr block
 pForExpr :: P Expr
 pForExpr =
-  pKeyword "for" *> (For <$> pBind <*> (pKeyword "in" *> pExpr) <*> pBlock)
+  pKeyword "for" *> (For <$> pBind False <*> (pKeyword "in" *> pExpr) <*> pBlock)
 
 pImportExpr :: P Expr
 pImportExpr = pKeyword "import" *> (Import <$> pExpr <*> pImportItems)
diff --git a/src/Typst/Syntax.hs b/src/Typst/Syntax.hs
--- a/src/Typst/Syntax.hs
+++ b/src/Typst/Syntax.hs
@@ -39,7 +39,6 @@
   | Equation Bool [Markup] -- Bool is True for displayed format
   | Strong [Markup]
   | Emph [Markup]
-  | Bracketed [Markup]
   | RawInline Text
   | RawBlock Text Text
   | Heading Int [Markup]
@@ -80,12 +79,14 @@
 data Bind
   = BasicBind (Maybe Identifier)
   | DestructuringBind [BindPart]
+  | ExprBind Expr
   deriving (Show, Ord, Eq, Data, Typeable)
 
 data BindPart
-  = Simple (Maybe Identifier)
-  | WithKey Identifier (Maybe Identifier)
+  = Simple Bind
+  | WithKey Identifier Bind
   | Sink (Maybe Identifier)
+  | ExprSink Expr
   deriving (Show, Ord, Eq, Data, Typeable)
 
 data Unit = Pt | Mm | Cm | In | Deg | Rad | Em | Fr | Percent
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -14,6 +14,7 @@
 import Text.Show.Pretty (ppShow)
 import Typst.Evaluate (evaluateTypst)
 import Typst.Parse (parseTypst)
+import Typst.Syntax (Markup)
 import Typst.Types (Val (VContent), repr, Operations(..))
 import Data.Time (getCurrentTime)
 import System.Directory (doesFileExist, setCurrentDirectory)
@@ -32,25 +33,27 @@
 
 goldenTests :: IO TestTree
 goldenTests = do
+  let testCommand =
+        "#let test = (x,y) => { if x == y [✅] else [❌(#repr(x) /= #repr(y))] }"
+  let testParse = either (error . show) id $ parseTypst "test-command" testCommand
+  
   setCurrentDirectory "test"
   inputs <- findByExtension [".typ"] "typ"
   pure $
     localOption (Timeout 1000000 "1s") $
-      testGroup "golden tests" (map runTest inputs)
+      testGroup "golden tests" (map (runTest testParse) inputs)
 
-runTest :: FilePath -> TestTree
-runTest input =
+runTest :: [Markup] -> FilePath -> TestTree
+runTest testParse input =
   goldenVsStringDiff
     input
     (\ref new -> ["diff", "-u", ref, new])
     (replaceExtension input ".out")
-    (writeTest input)
+    (writeTest testParse input)
 
-writeTest :: FilePath -> IO BL.ByteString
-writeTest input = do
+writeTest :: [Markup] -> FilePath -> IO BL.ByteString
+writeTest testParse input = do
   let fromText = BL.fromStrict . TE.encodeUtf8 . (<> "\n")
-  let testCommand =
-        "#let test = (x,y) => { if x == y [✅] else [❌(#repr(x) /= #repr(y))] }\n"
   contents <- TIO.readFile input
   if "// Error"
     `T.isInfixOf` contents
@@ -60,11 +63,11 @@
     `T.isInfixOf` contents
     then pure $ fromText "--- skipped ---\n"
     else do
-      let parseResult = parseTypst input (testCommand <> contents)
+      let parseResult = parseTypst input contents
       case parseResult of
         Left e -> pure $ fromText $ T.pack $ show e
         Right parsed -> do
-          evalResult <- evaluateTypst operations input parsed
+          evalResult <- evaluateTypst operations input (testParse <> parsed)
           let parseOutput = "--- parse tree ---\n" <> T.pack (ppShow parsed) <> "\n"
           case evalResult of
             Left e ->
diff --git a/test/typ/bugs/args-sink-00.out b/test/typ/bugs/args-sink-00.out
--- a/test/typ/bugs/args-sink-00.out
+++ b/test/typ/bugs/args-sink-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/bugs/args-sink-00.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
-                                 "typ/bugs/args-sink-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/args-sink-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/args-sink-00.typ"
-    ( line 2 , column 2 )
     (LetFunc
        (Identifier "foo")
        [ SinkParam (Just (Identifier "body")) ]
@@ -56,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/bugs/args-sink-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "foo"))
        [ KeyValArg (Identifier "a") (Literal (String "1"))
@@ -72,8 +32,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [(1, 2, 3, 4, 5, 6)]), 
                  parbreak() })
diff --git a/test/typ/bugs/args-underscore-00.out b/test/typ/bugs/args-underscore-00.out
--- a/test/typ/bugs/args-underscore-00.out
+++ b/test/typ/bugs/args-underscore-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/bugs/args-underscore-00.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
-                                 "typ/bugs/args-underscore-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/args-underscore-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/args-underscore-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -63,7 +23,5 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/bugs/columns-1-00.out b/test/typ/bugs/columns-1-00.out
--- a/test/typ/bugs/columns-1-00.out
+++ b/test/typ/bugs/columns-1-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/bugs/columns-1-00.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
-                                 "typ/bugs/columns-1-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/columns-1-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/columns-1-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 70.0 Pt)) ])
@@ -50,16 +10,18 @@
 , SoftBreak
 , Code
     "typ/bugs/columns-1-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "columns"))
        [ NormalArg (Literal (Int 2))
        , BlockArg
            [ SoftBreak
            , Heading 1 [ Text "A" ]
+           , SoftBreak
            , Text "Text"
            , SoftBreak
            , Heading 1 [ Text "B" ]
+           , SoftBreak
            , Text "Text"
            , ParBreak
            ]
@@ -67,9 +29,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [Hallo
 ]), 
                  columns(body: { text(body: [
diff --git a/test/typ/bugs/expr_underscore_00.out b/test/typ/bugs/expr_underscore_00.out
--- a/test/typ/bugs/expr_underscore_00.out
+++ b/test/typ/bugs/expr_underscore_00.out
@@ -2,67 +2,25 @@
 [ Code
     "typ/bugs/expr_underscore_00.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
-                                 "typ/bugs/expr_underscore_00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/expr_underscore_00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/expr_underscore_00.typ"
-    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "m"))) (Literal (Int 1)))
 , SoftBreak
 , Emph
     [ Code
         "typ/bugs/expr_underscore_00.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (Ident (Identifier "m"))
     , Text "."
     ]
 , SoftBreak
 , Code
     "typ/bugs/expr_underscore_00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Ident (Identifier "m"))
 , Text "."
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  emph(body: { text(body: [1]), 
                               text(body: [.]) }), 
diff --git a/test/typ/bugs/expr_underscore_01.out b/test/typ/bugs/expr_underscore_01.out
--- a/test/typ/bugs/expr_underscore_01.out
+++ b/test/typ/bugs/expr_underscore_01.out
@@ -2,48 +2,8 @@
 [ Code
     "typ/bugs/expr_underscore_01.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
-                                 "typ/bugs/expr_underscore_01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/expr_underscore_01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/expr_underscore_01.typ"
-    ( line 2 , column 2 )
     (Block (CodeBlock [ Underscore ]))
 , ParBreak
 ]
-"typ/bugs/expr_underscore_01.typ" (line 2, column 2):
+"typ/bugs/expr_underscore_01.typ" (line 1, column 2):
 expected expression, found underscore
diff --git a/test/typ/bugs/expr_underscore_02.out b/test/typ/bugs/expr_underscore_02.out
--- a/test/typ/bugs/expr_underscore_02.out
+++ b/test/typ/bugs/expr_underscore_02.out
@@ -3,49 +3,9 @@
     "typ/bugs/expr_underscore_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
-                                 "typ/bugs/expr_underscore_02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/expr_underscore_02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/expr_underscore_02.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "d")))
        (Dict [ Reg ( Underscore , Literal (Int 1) ) ]))
 , ParBreak
 ]
-"typ/bugs/expr_underscore_02.typ" (line 2, column 2):
+"typ/bugs/expr_underscore_02.typ" (line 1, column 2):
 expected expression, found underscore
diff --git a/test/typ/bugs/flow-1-00.out b/test/typ/bugs/flow-1-00.out
--- a/test/typ/bugs/flow-1-00.out
+++ b/test/typ/bugs/flow-1-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/flow-1-00.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
-                                 "typ/bugs/flow-1-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/flow-1-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/flow-1-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 70.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/flow-1-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ BlockArg
@@ -79,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/bugs/flow-1-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ BlockArg
@@ -127,8 +87,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  block(body: text(body: [This file tests a bug where an almost empty page occurs.])), 
                  text(body: [
diff --git a/test/typ/bugs/flow-2-00.out b/test/typ/bugs/flow-2-00.out
--- a/test/typ/bugs/flow-2-00.out
+++ b/test/typ/bugs/flow-2-00.out
@@ -2,59 +2,19 @@
 [ Code
     "typ/bugs/flow-2-00.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
-                                 "typ/bugs/flow-2-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/flow-2-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/flow-2-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/flow-2-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 19.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/flow-2-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ BlockArg
@@ -100,8 +60,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  v(amount: 19.0pt), 
                  text(body: [
diff --git a/test/typ/bugs/flow-3-00.out b/test/typ/bugs/flow-3-00.out
--- a/test/typ/bugs/flow-3-00.out
+++ b/test/typ/bugs/flow-3-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/flow-3-00.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
-                                 "typ/bugs/flow-3-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/flow-3-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/flow-3-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/flow-3-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt))
@@ -62,7 +22,7 @@
                   , SoftBreak
                   , Code
                       "typ/bugs/flow-3-00.typ"
-                      ( line 5 , column 4 )
+                      ( line 4 , column 4 )
                       (FuncCall
                          (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 12.0 Pt)) ])
                   , SoftBreak
@@ -70,7 +30,7 @@
                   , SoftBreak
                   , Code
                       "typ/bugs/flow-3-00.typ"
-                      ( line 7 , column 4 )
+                      ( line 6 , column 4 )
                       (FuncCall
                          (Ident (Identifier "v"))
                          [ NormalArg (Literal (Numeric 10.0 Pt))
@@ -91,8 +51,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  rect(body: columns(body: { text(body: [
 Text
diff --git a/test/typ/bugs/flow-4-00.out b/test/typ/bugs/flow-4-00.out
--- a/test/typ/bugs/flow-4-00.out
+++ b/test/typ/bugs/flow-4-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/flow-4-00.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
-                                 "typ/bugs/flow-4-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/flow-4-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/flow-4-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 105.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/flow-4-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ NormalArg
@@ -59,8 +19,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  block(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut]), 
                  parbreak() })
diff --git a/test/typ/bugs/grid-1-00.out b/test/typ/bugs/grid-1-00.out
--- a/test/typ/bugs/grid-1-00.out
+++ b/test/typ/bugs/grid-1-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/grid-1-00.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
-                                 "typ/bugs/grid-1-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/grid-1-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/grid-1-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 150.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/grid-1-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -81,8 +41,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  table(children: (rect(fill: rgb(100%,25%,21%,100%), 
                                        width: 100%), 
diff --git a/test/typ/bugs/grid-1-01.out b/test/typ/bugs/grid-1-01.out
--- a/test/typ/bugs/grid-1-01.out
+++ b/test/typ/bugs/grid-1-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/bugs/grid-1-01.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
-                                 "typ/bugs/grid-1-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/grid-1-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/grid-1-01.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
@@ -51,7 +11,7 @@
 , BulletListItem
     [ Code
         "typ/bugs/grid-1-01.typ"
-        ( line 3 , column 4 )
+        ( line 2 , column 4 )
         (FuncCall
            (Ident (Identifier "rect"))
            [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
@@ -61,20 +21,18 @@
     , BulletListItem
         [ Code
             "typ/bugs/grid-1-01.typ"
-            ( line 4 , column 6 )
+            ( line 3 , column 6 )
             (FuncCall
                (Ident (Identifier "rect"))
                [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
                , KeyValArg (Identifier "height") (Literal (Numeric 1.0 Em))
                ])
-        , ParBreak
         ]
     ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 rect(height: 1.0em, 
+document(body: { rect(height: 1.0em, 
                       width: 100%), 
                  text(body: [
 ]), 
@@ -82,6 +40,5 @@
                                         width: 100%), 
                                    text(body: [
 ]), 
-                                   list(children: ({ rect(height: 1.0em, 
-                                                          width: 100%), 
-                                                     parbreak() })) })) })
+                                   list(children: (rect(height: 1.0em, 
+                                                        width: 100%))) })) })
diff --git a/test/typ/bugs/grid-2-00.out b/test/typ/bugs/grid-2-00.out
--- a/test/typ/bugs/grid-2-00.out
+++ b/test/typ/bugs/grid-2-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/grid-2-00.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
-                                 "typ/bugs/grid-2-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/grid-2-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/grid-2-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 100.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/grid-2-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
@@ -86,7 +46,7 @@
                  , Space
                  , Code
                      "typ/bugs/grid-2-00.typ"
-                     ( line 9 , column 22 )
+                     ( line 8 , column 22 )
                      (Ident (Identifier "parbreak"))
                  , Space
                  , Text "my"
@@ -132,8 +92,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  grid(children: (rect(fill: rgb(100%,25%,21%,100%), 
                                       width: 100%), 
diff --git a/test/typ/bugs/grid-2-01.out b/test/typ/bugs/grid-2-01.out
--- a/test/typ/bugs/grid-2-01.out
+++ b/test/typ/bugs/grid-2-01.out
@@ -2,72 +2,29 @@
 [ Code
     "typ/bugs/grid-2-01.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
-                                 "typ/bugs/grid-2-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/grid-2-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/grid-2-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/grid-2-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 5)) ])
 , SoftBreak
 , BulletListItem
     [ Code
         "typ/bugs/grid-2-01.typ"
-        ( line 4 , column 4 )
+        ( line 3 , column 4 )
         (FuncCall
            (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 5)) ])
-    , ParBreak
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  text(body: [Lorem ipsum dolor sit amet,]), 
                  text(body: [
 ]), 
-                 list(children: ({ text(body: [Lorem ipsum dolor sit amet,]), 
-                                   parbreak() })) })
+                 list(children: (text(body: [Lorem ipsum dolor sit amet,]))) })
diff --git a/test/typ/bugs/grid-3-00.out b/test/typ/bugs/grid-3-00.out
--- a/test/typ/bugs/grid-3-00.out
+++ b/test/typ/bugs/grid-3-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/grid-3-00.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
-                                 "typ/bugs/grid-3-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/grid-3-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/grid-3-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 70.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/grid-3-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 40.0 Pt)) ])
 , SoftBreak
@@ -59,17 +19,15 @@
 , SoftBreak
 , EnumListItem Nothing [ Text "A" ]
 , SoftBreak
-, EnumListItem Nothing [ Text "B" , ParBreak ]
+, EnumListItem Nothing [ Text "B" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  v(amount: 40.0pt), 
                  text(body: [
 The following:
 ]), 
                  enum(children: (text(body: [A]), 
-                                 { text(body: [B]), 
-                                   parbreak() })) })
+                                 text(body: [B]))) })
diff --git a/test/typ/bugs/math-realize-00.out b/test/typ/bugs/math-realize-00.out
--- a/test/typ/bugs/math-realize-00.out
+++ b/test/typ/bugs/math-realize-00.out
@@ -3,46 +3,6 @@
     "typ/bugs/math-realize-00.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
-                                 "typ/bugs/math-realize-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/math-realize-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/math-realize-00.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "my")))
        (Block
           (Content
@@ -50,14 +10,14 @@
                  False
                  [ Code
                      "typ/bugs/math-realize-00.typ"
-                     ( line 2 , column 12 )
+                     ( line 1 , column 12 )
                      (Ident (Identifier "pi"))
                  ]
              ])))
 , SoftBreak
 , Code
     "typ/bugs/math-realize-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "f1")))
        (FuncCall
@@ -68,7 +28,7 @@
 , SoftBreak
 , Code
     "typ/bugs/math-realize-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "f2")))
        (FuncCall
@@ -80,7 +40,7 @@
 , SoftBreak
 , Code
     "typ/bugs/math-realize-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Show
        (Just
           (FieldAccess
@@ -91,7 +51,7 @@
     True
     [ Code
         "typ/bugs/math-realize-00.typ"
-        ( line 7 , column 3 )
+        ( line 6 , column 3 )
         (Ident (Identifier "pi"))
     , Text "a"
     ]
@@ -100,7 +60,7 @@
     True
     [ Code
         "typ/bugs/math-realize-00.typ"
-        ( line 8 , column 3 )
+        ( line 7 , column 3 )
         (Ident (Identifier "my"))
     , Text "a"
     ]
@@ -111,14 +71,14 @@
     , Text "+"
     , Code
         "typ/bugs/math-realize-00.typ"
-        ( line 9 , column 7 )
+        ( line 8 , column 7 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg [ MFrac (Text "x") (Text "2") ] ])
     , Text "+"
     , Code
         "typ/bugs/math-realize-00.typ"
-        ( line 9 , column 19 )
+        ( line 8 , column 19 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ NormalArg
@@ -137,7 +97,7 @@
     , Text "x"
     , Code
         "typ/bugs/math-realize-00.typ"
-        ( line 10 , column 8 )
+        ( line 9 , column 8 )
         (FuncCall
            (Ident (Identifier "link"))
            [ NormalArg (Literal (String "url"))
@@ -151,11 +111,11 @@
     [ Text "f"
     , Code
         "typ/bugs/math-realize-00.typ"
-        ( line 11 , column 5 )
+        ( line 10 , column 5 )
         (Ident (Identifier "f1"))
     , Code
         "typ/bugs/math-realize-00.typ"
-        ( line 11 , column 8 )
+        ( line 10 , column 8 )
         (Ident (Identifier "f2"))
     ]
 , SoftBreak
@@ -163,13 +123,13 @@
     True
     [ Code
         "typ/bugs/math-realize-00.typ"
-        ( line 12 , column 3 )
+        ( line 11 , column 3 )
         (FuncCall
            (Ident (Identifier "vec"))
            [ BlockArg [ Text "1" ] , BlockArg [ Text "2" ] ])
     , Code
         "typ/bugs/math-realize-00.typ"
-        ( line 12 , column 12 )
+        ( line 11 , column 12 )
         (FieldAccess (Ident (Identifier "op")) (Ident (Identifier "ast")))
     , Text "2"
     ]
@@ -177,8 +137,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/bugs/math-realize-01.out b/test/typ/bugs/math-realize-01.out
--- a/test/typ/bugs/math-realize-01.out
+++ b/test/typ/bugs/math-realize-01.out
@@ -1,50 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/bugs/math-realize-01.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
-                                 "typ/bugs/math-realize-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/math-realize-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ MAttach Nothing (Just (Text "2")) (Text "x")
     , Code
         "typ/bugs/math-realize-01.typ"
-        ( line 2 , column 8 )
+        ( line 1 , column 8 )
         (FuncCall
            (Ident (Identifier "hide"))
            [ BlockArg
@@ -55,16 +15,16 @@
                        (Just ")")
                        [ Code
                            "typ/bugs/math-realize-01.typ"
-                           ( line 2 , column 15 )
+                           ( line 1 , column 15 )
                            (FieldAccess (Ident (Identifier "eq")) (Ident (Identifier "gt")))
                        , Code
                            "typ/bugs/math-realize-01.typ"
-                           ( line 2 , column 18 )
+                           ( line 1 , column 18 )
                            (FieldAccess (Ident (Identifier "alt")) (Ident (Identifier "phi")))
                        ]
                    , Code
                        "typ/bugs/math-realize-01.typ"
-                       ( line 2 , column 27 )
+                       ( line 1 , column 27 )
                        (Ident (Identifier "union"))
                    , MAttach Nothing (Just (Text "2")) (Text "y")
                    , Text "0"
@@ -78,7 +38,7 @@
 , Space
 , Code
     "typ/bugs/math-realize-01.typ"
-    ( line 3 , column 8 )
+    ( line 2 , column 8 )
     (FuncCall
        (Ident (Identifier "hide"))
        [ BlockArg [ Text "there" , Space , Equation False [ Text "x" ] ]
@@ -88,7 +48,7 @@
 , Space
 , Code
     "typ/bugs/math-realize-01.typ"
-    ( line 4 , column 6 )
+    ( line 3 , column 6 )
     (FuncCall
        (Ident (Identifier "hide"))
        [ BlockArg
@@ -100,7 +60,7 @@
                    [ Text "f" , MGroup (Just "(") (Just ")") [ Text "x" ] ]
                , Code
                    "typ/bugs/math-realize-01.typ"
-                   ( line 4 , column 18 )
+                   ( line 3 , column 18 )
                    (FieldAccess
                       (Ident (Identifier "eq")) (Ident (Identifier "colon")))
                , MAttach Nothing (Just (Text "2")) (Text "x")
@@ -110,9 +70,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: { math.attach(b: none, 
                                                    base: text(body: [x]), 
                                                    t: text(body: [2])), 
diff --git a/test/typ/bugs/math-realize-02.out b/test/typ/bugs/math-realize-02.out
--- a/test/typ/bugs/math-realize-02.out
+++ b/test/typ/bugs/math-realize-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/bugs/math-realize-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
-                                 "typ/bugs/math-realize-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/math-realize-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/bugs/math-realize-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "foo")
        [ NormalParam (Identifier "v1") , NormalParam (Identifier "v2") ]
@@ -54,14 +15,14 @@
                         False
                         [ Code
                             "typ/bugs/math-realize-02.typ"
-                            ( line 6 , column 4 )
+                            ( line 5 , column 4 )
                             (Ident (Identifier "v1"))
                         , MAttach
                             Nothing
                             (Just (Text "2"))
                             (Code
                                "typ/bugs/math-realize-02.typ"
-                               ( line 6 , column 7 )
+                               ( line 5 , column 7 )
                                (Ident (Identifier "v2")))
                         ]
                     ])
@@ -69,7 +30,7 @@
 , SoftBreak
 , Code
     "typ/bugs/math-realize-02.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (LetFunc
        (Identifier "bar")
        [ NormalParam (Identifier "v1") , NormalParam (Identifier "v2") ]
@@ -81,14 +42,14 @@
                         True
                         [ Code
                             "typ/bugs/math-realize-02.typ"
-                            ( line 11 , column 5 )
+                            ( line 10 , column 5 )
                             (Ident (Identifier "v1"))
                         , MAttach
                             Nothing
                             (Just (Text "2"))
                             (Code
                                "typ/bugs/math-realize-02.typ"
-                               ( line 11 , column 8 )
+                               ( line 10 , column 8 )
                                (Ident (Identifier "v2")))
                         ]
                     ])
@@ -96,7 +57,7 @@
 , SoftBreak
 , Code
     "typ/bugs/math-realize-02.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (LetFunc
        (Identifier "baz")
        [ SinkParam (Just (Identifier "sink")) ]
@@ -121,7 +82,7 @@
                                         False
                                         [ Code
                                             "typ/bugs/math-realize-02.typ"
-                                            ( line 15 , column 24 )
+                                            ( line 14 , column 24 )
                                             (FuncCall
                                                (Ident (Identifier "hat"))
                                                [ NormalArg (Ident (Identifier "x")) ])
@@ -140,13 +101,13 @@
     [ Text "2"
     , Code
         "typ/bugs/math-realize-02.typ"
-        ( line 18 , column 11 )
+        ( line 17 , column 11 )
         (FuncCall
            (Ident (Identifier "foo"))
            [ BlockArg
                [ Code
                    "typ/bugs/math-realize-02.typ"
-                   ( line 18 , column 15 )
+                   ( line 17 , column 15 )
                    (Ident (Identifier "alpha"))
                ]
            , BlockArg
@@ -157,7 +118,7 @@
                    , Text "+"
                    , Code
                        "typ/bugs/math-realize-02.typ"
-                       ( line 18 , column 25 )
+                       ( line 17 , column 25 )
                        (FuncCall
                           (Ident (Identifier "foo"))
                           [ BlockArg [ Text "a" ] , BlockArg [ Text "b" ] ])
@@ -174,13 +135,13 @@
     [ Text "2"
     , Code
         "typ/bugs/math-realize-02.typ"
-        ( line 20 , column 11 )
+        ( line 19 , column 11 )
         (FuncCall
            (Ident (Identifier "bar"))
            [ BlockArg
                [ Code
                    "typ/bugs/math-realize-02.typ"
-                   ( line 20 , column 15 )
+                   ( line 19 , column 15 )
                    (Ident (Identifier "alpha"))
                ]
            , BlockArg
@@ -191,7 +152,7 @@
                    , Text "+"
                    , Code
                        "typ/bugs/math-realize-02.typ"
-                       ( line 20 , column 25 )
+                       ( line 19 , column 25 )
                        (FuncCall
                           (Ident (Identifier "foo"))
                           [ BlockArg [ Text "a" ] , BlockArg [ Text "b" ] ])
@@ -208,7 +169,7 @@
     [ Text "2"
     , Code
         "typ/bugs/math-realize-02.typ"
-        ( line 22 , column 11 )
+        ( line 21 , column 11 )
         (FuncCall
            (Ident (Identifier "baz"))
            [ BlockArg [ Text "x" ]
@@ -216,7 +177,7 @@
            , BlockArg
                [ Code
                    "typ/bugs/math-realize-02.typ"
-                   ( line 22 , column 19 )
+                   ( line 21 , column 19 )
                    (FuncCall
                       (Ident (Identifier "baz"))
                       [ BlockArg [ Text "u" ] , BlockArg [ Text "v" ] ])
@@ -230,13 +191,13 @@
     [ Text "2"
     , Code
         "typ/bugs/math-realize-02.typ"
-        ( line 24 , column 5 )
+        ( line 23 , column 5 )
         (FuncCall
            (Ident (Identifier "foo"))
            [ BlockArg
                [ Code
                    "typ/bugs/math-realize-02.typ"
-                   ( line 24 , column 9 )
+                   ( line 23 , column 9 )
                    (Ident (Identifier "alpha"))
                ]
            , BlockArg
@@ -247,7 +208,7 @@
                    , Text "+"
                    , Code
                        "typ/bugs/math-realize-02.typ"
-                       ( line 24 , column 19 )
+                       ( line 23 , column 19 )
                        (FuncCall
                           (Ident (Identifier "foo"))
                           [ BlockArg [ Text "a" ] , BlockArg [ Text "b" ] ])
@@ -261,13 +222,13 @@
     [ Text "2"
     , Code
         "typ/bugs/math-realize-02.typ"
-        ( line 25 , column 5 )
+        ( line 24 , column 5 )
         (FuncCall
            (Ident (Identifier "bar"))
            [ BlockArg
                [ Code
                    "typ/bugs/math-realize-02.typ"
-                   ( line 25 , column 9 )
+                   ( line 24 , column 9 )
                    (Ident (Identifier "alpha"))
                ]
            , BlockArg
@@ -278,7 +239,7 @@
                    , Text "+"
                    , Code
                        "typ/bugs/math-realize-02.typ"
-                       ( line 25 , column 19 )
+                       ( line 24 , column 19 )
                        (FuncCall
                           (Ident (Identifier "foo"))
                           [ BlockArg [ Text "a" ] , BlockArg [ Text "b" ] ])
@@ -292,7 +253,7 @@
     [ Text "2"
     , Code
         "typ/bugs/math-realize-02.typ"
-        ( line 26 , column 5 )
+        ( line 25 , column 5 )
         (FuncCall
            (Ident (Identifier "baz"))
            [ BlockArg [ Text "x" ]
@@ -300,7 +261,7 @@
            , BlockArg
                [ Code
                    "typ/bugs/math-realize-02.typ"
-                   ( line 26 , column 13 )
+                   ( line 25 , column 13 )
                    (FuncCall
                       (Ident (Identifier "baz"))
                       [ BlockArg [ Text "u" ] , BlockArg [ Text "v" ] ])
diff --git a/test/typ/bugs/parameter-pattern-00.out b/test/typ/bugs/parameter-pattern-00.out
--- a/test/typ/bugs/parameter-pattern-00.out
+++ b/test/typ/bugs/parameter-pattern-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/bugs/parameter-pattern-00.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
-                                 "typ/bugs/parameter-pattern-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/parameter-pattern-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/parameter-pattern-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -66,7 +26,9 @@
               [ NormalArg
                   (FuncExpr
                      [ DestructuringParam
-                         [ Simple Nothing , Simple (Just (Identifier "x")) ]
+                         [ Simple (BasicBind Nothing)
+                         , Simple (BasicBind (Just (Identifier "x")))
+                         ]
                      ]
                      (Ident (Identifier "x")))
               ])
@@ -80,7 +42,5 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/bugs/place-base-00.out b/test/typ/bugs/place-base-00.out
--- a/test/typ/bugs/place-base-00.out
+++ b/test/typ/bugs/place-base-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/bugs/place-base-00.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
-                                 "typ/bugs/place-base-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/place-base-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/place-base-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 80.0 Pt))
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/bugs/place-base-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ NormalArg (Ident (Identifier "right"))
@@ -62,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/bugs/place-base-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ NormalArg (Ident (Identifier "left"))
@@ -73,7 +33,7 @@
 , SoftBreak
 , Code
     "typ/bugs/place-base-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ NormalArg
@@ -86,8 +46,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  place(alignment: right, 
                        body: text(body: [First]), 
diff --git a/test/typ/bugs/smartquotes-in-outline-00.out b/test/typ/bugs/smartquotes-in-outline-00.out
--- a/test/typ/bugs/smartquotes-in-outline-00.out
+++ b/test/typ/bugs/smartquotes-in-outline-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/smartquotes-in-outline-00.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
-                                 "typ/bugs/smartquotes-in-outline-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/smartquotes-in-outline-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/smartquotes-in-outline-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 15.0 Em)) ])
 , SoftBreak
 , Code
     "typ/bugs/smartquotes-in-outline-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall (Ident (Identifier "outline")) [])
 , ParBreak
 , Heading
@@ -69,11 +29,10 @@
     , Text "test"
     , Quote '"'
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  outline(), 
                  parbreak(), 
diff --git a/test/typ/bugs/square-base-00.out b/test/typ/bugs/square-base-00.out
--- a/test/typ/bugs/square-base-00.out
+++ b/test/typ/bugs/square-base-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/bugs/square-base-00.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
-                                 "typ/bugs/square-base-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/bugs/square-base-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/bugs/square-base-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 80.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/bugs/square-base-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 40.0 Percent))
@@ -63,8 +23,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  square(body: rect(height: 80%, 
                                    width: 60%), 
diff --git a/test/typ/coma-00.out b/test/typ/coma-00.out
--- a/test/typ/coma-00.out
+++ b/test/typ/coma-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/coma-00.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
-                                 "typ/coma-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/coma-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/coma-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 450.0 Pt))
@@ -58,7 +18,7 @@
 , Space
 , Code
     "typ/coma-00.typ"
-    ( line 4 , column 34 )
+    ( line 3 , column 34 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -80,7 +40,7 @@
 , Space
 , Code
     "typ/coma-00.typ"
-    ( line 5 , column 41 )
+    ( line 4 , column 41 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -112,13 +72,13 @@
 , ParBreak
 , Code
     "typ/coma-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Mm)) ])
 , SoftBreak
 , Code
     "typ/coma-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
@@ -126,14 +86,14 @@
            [ SoftBreak
            , Code
                "typ/coma-00.typ"
-               ( line 12 , column 4 )
+               ( line 11 , column 4 )
                (Set
                   (Ident (Identifier "par"))
                   [ KeyValArg (Identifier "leading") (Literal (Numeric 3.0 Mm)) ])
            , SoftBreak
            , Code
                "typ/coma-00.typ"
-               ( line 13 , column 4 )
+               ( line 12 , column 4 )
                (FuncCall
                   (Ident (Identifier "text"))
                   [ NormalArg (Literal (Numeric 1.2 Em))
@@ -201,7 +161,7 @@
 , Space
 , Code
     "typ/coma-00.typ"
-    ( line 18 , column 15 )
+    ( line 17 , column 15 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -335,7 +295,7 @@
 , ParBreak
 , Code
     "typ/coma-00.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
@@ -349,9 +309,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  strong(body: text(body: [Technische Universität Berlin])), 
                  text(body: [ ]), 
                  h(amount: 1.0fr), 
diff --git a/test/typ/compiler/array-00.out b/test/typ/compiler/array-00.out
--- a/test/typ/compiler/array-00.out
+++ b/test/typ/compiler/array-00.out
@@ -1,79 +1,42 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-00.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
-                                 "typ/compiler/array-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/array-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 150.0 Pt)) ])
 , ParBreak
 , Comment
-, Code "typ/compiler/array-00.typ" ( line 7 , column 2 ) (Array [])
+, SoftBreak
+, Code "typ/compiler/array-00.typ" ( line 6 , column 2 ) (Array [])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
-    "typ/compiler/array-00.typ"
-    ( line 10 , column 2 )
-    (Literal (Int 1))
+    "typ/compiler/array-00.typ" ( line 9 , column 2 ) (Literal (Int 1))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/array-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Array [ Reg (Negated (Literal (Int 1))) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/array-00.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (Array
        [ Reg (Literal (Boolean True)) , Reg (Literal (Boolean False)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/array-00.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (Array
        [ Reg (Literal (String "1"))
        , Reg
@@ -83,18 +46,25 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
+                 parbreak(), 
                  text(body: [
 ]), 
-                 parbreak(), 
                  text(body: [()]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [1]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [(-1)]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [(true, false)]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [("1", rgb(0%,0%,0%,100%))]), 
                  parbreak() })
diff --git a/test/typ/compiler/array-01.out b/test/typ/compiler/array-01.out
--- a/test/typ/compiler/array-01.out
+++ b/test/typ/compiler/array-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-01.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
-                                 "typ/compiler/array-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-02.out b/test/typ/compiler/array-02.out
--- a/test/typ/compiler/array-02.out
+++ b/test/typ/compiler/array-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-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
-                                 "typ/compiler/array-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/array-03.out b/test/typ/compiler/array-03.out
--- a/test/typ/compiler/array-03.out
+++ b/test/typ/compiler/array-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-03.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
-                                 "typ/compiler/array-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/array-06.out b/test/typ/compiler/array-06.out
--- a/test/typ/compiler/array-06.out
+++ b/test/typ/compiler/array-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-06.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
-                                 "typ/compiler/array-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -62,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-06.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-09.out b/test/typ/compiler/array-09.out
--- a/test/typ/compiler/array-09.out
+++ b/test/typ/compiler/array-09.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-09.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
-                                 "typ/compiler/array-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-09.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/array-10.out b/test/typ/compiler/array-10.out
--- a/test/typ/compiler/array-10.out
+++ b/test/typ/compiler/array-10.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-10.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
-                                 "typ/compiler/array-10.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-10.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-10.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-10.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-10.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -86,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-10.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-13.out b/test/typ/compiler/array-13.out
--- a/test/typ/compiler/array-13.out
+++ b/test/typ/compiler/array-13.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-13.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
-                                 "typ/compiler/array-13.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-13.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-13.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/array-14.out b/test/typ/compiler/array-14.out
--- a/test/typ/compiler/array-14.out
+++ b/test/typ/compiler/array-14.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-14.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
-                                 "typ/compiler/array-14.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-14.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-14.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/array-16.out b/test/typ/compiler/array-16.out
--- a/test/typ/compiler/array-16.out
+++ b/test/typ/compiler/array-16.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-16.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
-                                 "typ/compiler/array-16.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-16.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-16.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -62,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -83,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -105,7 +66,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -123,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -143,7 +104,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -163,7 +124,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -184,7 +145,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-16.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-19.out b/test/typ/compiler/array-19.out
--- a/test/typ/compiler/array-19.out
+++ b/test/typ/compiler/array-19.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-19.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
-                                 "typ/compiler/array-19.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-19.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-19.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -65,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-19.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -88,7 +49,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-19.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-20.out b/test/typ/compiler/array-20.out
--- a/test/typ/compiler/array-20.out
+++ b/test/typ/compiler/array-20.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-20.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
-                                 "typ/compiler/array-20.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-20.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-20.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -57,7 +18,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-20.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -80,7 +41,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-20.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-21.out b/test/typ/compiler/array-21.out
--- a/test/typ/compiler/array-21.out
+++ b/test/typ/compiler/array-21.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-21.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
-                                 "typ/compiler/array-21.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-21.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-21.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -58,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-21.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-22.out b/test/typ/compiler/array-22.out
--- a/test/typ/compiler/array-22.out
+++ b/test/typ/compiler/array-22.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-22.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
-                                 "typ/compiler/array-22.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-22.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-22.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -56,7 +17,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-22.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-24.out b/test/typ/compiler/array-24.out
--- a/test/typ/compiler/array-24.out
+++ b/test/typ/compiler/array-24.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-24.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
-                                 "typ/compiler/array-24.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-24.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-24.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-24.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -66,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-24.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-26.out b/test/typ/compiler/array-26.out
--- a/test/typ/compiler/array-26.out
+++ b/test/typ/compiler/array-26.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-26.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
-                                 "typ/compiler/array-26.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-26.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-26.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-26.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -66,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-26.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -82,7 +43,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-26.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-28.out b/test/typ/compiler/array-28.out
--- a/test/typ/compiler/array-28.out
+++ b/test/typ/compiler/array-28.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-28.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
-                                 "typ/compiler/array-28.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-28.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-28.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-29.out b/test/typ/compiler/array-29.out
--- a/test/typ/compiler/array-29.out
+++ b/test/typ/compiler/array-29.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-29.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
-                                 "typ/compiler/array-29.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-29.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-29.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-29.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -65,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-29.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -83,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-29.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -103,6 +64,21 @@
        , NormalArg (Literal (String "(a, b, c)"))
        ])
 , ParBreak
+, Comment
+, SoftBreak
+, Code
+    "typ/compiler/array-29.typ"
+    ( line 8 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (FuncCall
+              (FieldAccess
+                 (Ident (Identifier "join")) (Array [ Reg (Literal (Int 1)) ]))
+              [ NormalArg (Literal (Int 2)) ])
+       , NormalArg (Literal (Int 1))
+       ])
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -114,6 +90,10 @@
                  text(body: [
 ]), 
                  text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compiler/array-29.typ b/test/typ/compiler/array-29.typ
--- a/test/typ/compiler/array-29.typ
+++ b/test/typ/compiler/array-29.typ
@@ -4,3 +4,5 @@
 #test(("a", "b", "c").join(), "abc")
 #test("(" + ("a", "b", "c").join(", ") + ")", "(a, b, c)")
 
+// #58
+#test((1,).join(2), 1)
diff --git a/test/typ/compiler/array-32.out b/test/typ/compiler/array-32.out
--- a/test/typ/compiler/array-32.out
+++ b/test/typ/compiler/array-32.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-32.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
-                                 "typ/compiler/array-32.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-32.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/array-32.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "join"))
@@ -59,14 +21,33 @@
        ])
 , Text "."
 , ParBreak
+, Comment
+, SoftBreak
+, Code
+    "typ/compiler/array-32.typ"
+    ( line 6 , column 2 )
+    (FuncCall
+       (FieldAccess
+          (Ident (Identifier "join"))
+          (Array [ Reg (Block (Content [ Text "One" ])) ]))
+       [ NormalArg (Block (Content [ Text "," , Space ])) ])
+, Text "."
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
+                 text(body: [
+]), 
                  text(body: [One]), 
                  text(body: [, ]), 
                  text(body: [Two]), 
                  text(body: [ and ]), 
                  text(body: [Three]), 
+                 text(body: [.]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [One]), 
                  text(body: [.]), 
                  parbreak() })
diff --git a/test/typ/compiler/array-32.typ b/test/typ/compiler/array-32.typ
--- a/test/typ/compiler/array-32.typ
+++ b/test/typ/compiler/array-32.typ
@@ -2,3 +2,6 @@
 // Ref: true
 #([One], [Two], [Three]).join([, ], last: [ and ]).
 
+// #58
+#([One],).join([, ]).
+
diff --git a/test/typ/compiler/array-33.out b/test/typ/compiler/array-33.out
--- a/test/typ/compiler/array-33.out
+++ b/test/typ/compiler/array-33.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-33.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
-                                 "typ/compiler/array-33.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-33.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-33.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -69,7 +30,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -91,7 +52,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -116,7 +77,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -145,7 +106,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -177,7 +138,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -212,7 +173,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -251,7 +212,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-33.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/array-34.out b/test/typ/compiler/array-34.out
--- a/test/typ/compiler/array-34.out
+++ b/test/typ/compiler/array-34.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/array-34.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
-                                 "typ/compiler/array-34.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/array-34.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/array-34.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-34.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -67,7 +28,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-34.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -82,7 +43,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-34.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -102,7 +63,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-34.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -127,7 +88,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-34.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -154,7 +115,7 @@
 , SoftBreak
 , Code
     "typ/compiler/array-34.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/bench-00.out b/test/typ/compiler/bench-00.out
--- a/test/typ/compiler/bench-00.out
+++ b/test/typ/compiler/bench-00.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/bench-00.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
-                                 "typ/compiler/bench-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/bench-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 450.0 Pt))
@@ -52,18 +13,22 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Let
        (BasicBind (Just (Identifier "city"))) (Literal (String "Berlin")))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Let
        (BasicBind (Just (Identifier "university")))
        (Block
@@ -75,14 +40,14 @@
                  , Space
                  , Code
                      "typ/compiler/bench-00.typ"
-                     ( line 13 , column 45 )
+                     ( line 12 , column 45 )
                      (Ident (Identifier "city"))
                  ]
              ])))
 , SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (Let
        (BasicBind (Just (Identifier "faculty")))
        (Block
@@ -101,26 +66,29 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ BlockArg
            [ SoftBreak
            , Comment
-           , Space
+           , SoftBreak
            , Code
                "typ/compiler/bench-00.typ"
-               ( line 21 , column 4 )
+               ( line 20 , column 4 )
                (Ident (Identifier "university"))
            , Space
            , HardBreak
            , Code
                "typ/compiler/bench-00.typ"
-               ( line 22 , column 4 )
+               ( line 21 , column 4 )
                (Ident (Identifier "faculty"))
            , Space
            , HardBreak
@@ -150,7 +118,7 @@
 , SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 27 , column 2 )
+    ( line 26 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "right"))
@@ -170,24 +138,27 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 30 , column 2 )
+    ( line 29 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 6.0 Mm)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 34 , column 2 )
+    ( line 33 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
        , BlockArg
            [ SoftBreak
            , Comment
-           , Space
+           , SoftBreak
            , Heading
                4
                [ Text "3"
@@ -203,10 +174,11 @@
                , Space
                , Code
                    "typ/compiler/bench-00.typ"
-                   ( line 36 , column 58 )
+                   ( line 35 , column 58 )
                    (FuncCall
                       (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 4.0 Mm)) ])
                ]
+           , SoftBreak
            , Strong
                [ Text "Abgabe"
                , Text ":"
@@ -235,7 +207,7 @@
            , Space
            , Code
                "typ/compiler/bench-00.typ"
-               ( line 37 , column 51 )
+               ( line 36 , column 51 )
                (FuncCall
                   (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 4.0 Mm)) ])
            , SoftBreak
@@ -259,7 +231,7 @@
 , Space
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 41 , column 15 )
+    ( line 40 , column 15 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "right"))
@@ -396,24 +368,38 @@
 , ParBreak
 , Code
     "typ/compiler/bench-00.typ"
-    ( line 48 , column 2 )
+    ( line 47 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 6.0 Mm)) ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  box(body: { text(body: [
 ]), 
-                             text(body: [ ]), 
+                             text(body: [
+]), 
                              strong(body: { text(body: [Technische Universität ]), 
                                             text(body: [Berlin]) }), 
                              text(body: [ ]), 
@@ -435,12 +421,19 @@
                                          linebreak(), 
                                          text(body: [Woche 3]) })), 
                  parbreak(), 
+                 text(body: [
+]), 
                  v(amount: 6.0mm), 
                  parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  align(alignment: center, 
                        body: { text(body: [
 ]), 
-                               text(body: [ ]), 
+                               text(body: [
+]), 
                                heading(body: { text(body: [3. Übungsblatt Computerorientierte Mathematik II ]), 
                                                v(amount: 4.0mm) }, 
                                        level: 4), 
diff --git a/test/typ/compiler/block-00.out b/test/typ/compiler/block-00.out
--- a/test/typ/compiler/block-00.out
+++ b/test/typ/compiler/block-00.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/block-00.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
-                                 "typ/compiler/block-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/block-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/block-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (CodeBlock
           [ Let
@@ -61,15 +22,16 @@
                  (Content
                     [ Code
                         "typ/compiler/block-00.typ"
-                        ( line 8 , column 20 )
+                        ( line 7 , column 20 )
                         (Ident (Identifier "s"))
                     ]))
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/block-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Block
        (CodeBlock
           [ Block (Content [ Text "How" ])
@@ -86,14 +48,15 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [Hello, ]), 
                  text(body: [my fri]), 
                  text(body: [end.]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [How]), 
                  text(body: [ are]), 
                  text(body: [ ]), 
diff --git a/test/typ/compiler/block-01.out b/test/typ/compiler/block-01.out
--- a/test/typ/compiler/block-01.out
+++ b/test/typ/compiler/block-01.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/block-01.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
-                                 "typ/compiler/block-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/block-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/block-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Block (CodeBlock [])) , NormalArg (Literal None) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/block-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -61,9 +23,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/block-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Block (CodeBlock [ Literal (String "hello") ]))
@@ -71,9 +34,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/block-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -86,9 +50,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/block-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -102,9 +67,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/block-01.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -123,13 +89,23 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/block-06.out b/test/typ/compiler/block-06.out
--- a/test/typ/compiler/block-06.out
+++ b/test/typ/compiler/block-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/block-06.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
-                                 "typ/compiler/block-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/block-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/block-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let (BasicBind (Just (Identifier "a"))) (Literal (String "a1"))
diff --git a/test/typ/compiler/break-continue-00.out b/test/typ/compiler/break-continue-00.out
--- a/test/typ/compiler/break-continue-00.out
+++ b/test/typ/compiler/break-continue-00.out
@@ -1,60 +1,20 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-00.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
-                                 "typ/compiler/break-continue-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/break-continue-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let (BasicBind (Just (Identifier "var"))) (Literal (Int 0)))
 , SoftBreak
 , Code
     "typ/compiler/break-continue-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "error"))) (Literal (Boolean False)))
 , ParBreak
 , Code
     "typ/compiler/break-continue-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -77,7 +37,7 @@
 , ParBreak
 , Code
     "typ/compiler/break-continue-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "var"))
@@ -86,7 +46,7 @@
 , SoftBreak
 , Code
     "typ/compiler/break-continue-00.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "error"))
@@ -95,10 +55,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
diff --git a/test/typ/compiler/break-continue-01.out b/test/typ/compiler/break-continue-01.out
--- a/test/typ/compiler/break-continue-01.out
+++ b/test/typ/compiler/break-continue-01.out
@@ -1,54 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-01.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
-                                 "typ/compiler/break-continue-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/break-continue-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0)))
 , SoftBreak
 , Code
     "typ/compiler/break-continue-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (While
@@ -69,7 +29,7 @@
 , ParBreak
 , Code
     "typ/compiler/break-continue-01.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -78,10 +38,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
diff --git a/test/typ/compiler/break-continue-02.out b/test/typ/compiler/break-continue-02.out
--- a/test/typ/compiler/break-continue-02.out
+++ b/test/typ/compiler/break-continue-02.out
@@ -1,59 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-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
-                                 "typ/compiler/break-continue-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/break-continue-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0)))
 , SoftBreak
 , Code
     "typ/compiler/break-continue-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal (Int 0)))
 , ParBreak
 , Code
     "typ/compiler/break-continue-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (While
        (LessThan (Ident (Identifier "x")) (Literal (Int 8)))
        (Block
@@ -79,9 +39,10 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/break-continue-02.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -90,13 +51,12 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/break-continue-03.out b/test/typ/compiler/break-continue-03.out
--- a/test/typ/compiler/break-continue-03.out
+++ b/test/typ/compiler/break-continue-03.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-03.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
-                                 "typ/compiler/break-continue-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/break-continue-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (For
@@ -71,7 +31,7 @@
 , ParBreak
 , Code
     "typ/compiler/break-continue-03.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -80,10 +40,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/break-continue-05.out b/test/typ/compiler/break-continue-05.out
--- a/test/typ/compiler/break-continue-05.out
+++ b/test/typ/compiler/break-continue-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-05.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
-                                 "typ/compiler/break-continue-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/break-continue-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "identity")
        [ NormalParam (Identifier "x") ]
@@ -50,7 +11,7 @@
 , SoftBreak
 , Code
     "typ/compiler/break-continue-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "out")))
        (For
@@ -68,7 +29,7 @@
 , ParBreak
 , Code
     "typ/compiler/break-continue-05.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "out"))
diff --git a/test/typ/compiler/break-continue-08.out b/test/typ/compiler/break-continue-08.out
--- a/test/typ/compiler/break-continue-08.out
+++ b/test/typ/compiler/break-continue-08.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-08.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
-                                 "typ/compiler/break-continue-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/break-continue-08.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (For
        (BasicBind Nothing)
        (FuncCall
@@ -57,7 +19,7 @@
                     , Space
                     , Code
                         "typ/compiler/break-continue-08.typ"
-                        ( line 6 , column 11 )
+                        ( line 5 , column 11 )
                         (Block (CodeBlock [ Block (Content [ Text "\127758" ]) , Break ]))
                     ])
              ])))
@@ -65,6 +27,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [Hello ]), 
                  text(body: [World ]), 
diff --git a/test/typ/compiler/break-continue-09.out b/test/typ/compiler/break-continue-09.out
--- a/test/typ/compiler/break-continue-09.out
+++ b/test/typ/compiler/break-continue-09.out
@@ -1,50 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-09.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
-                                 "typ/compiler/break-continue-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/break-continue-09.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (For
        (BasicBind (Just (Identifier "color")))
        (Array
@@ -58,14 +21,14 @@
              [ SoftBreak
              , Code
                  "typ/compiler/break-continue-09.typ"
-                 ( line 6 , column 4 )
+                 ( line 5 , column 4 )
                  (Set
                     (Ident (Identifier "text"))
                     [ KeyValArg (Identifier "font") (Literal (String "Roboto")) ])
              , SoftBreak
              , Code
                  "typ/compiler/break-continue-09.typ"
-                 ( line 7 , column 4 )
+                 ( line 6 , column 4 )
                  (Show
                     Nothing
                     (FuncExpr
@@ -78,7 +41,7 @@
              , SoftBreak
              , Code
                  "typ/compiler/break-continue-09.typ"
-                 ( line 8 , column 4 )
+                 ( line 7 , column 4 )
                  (FuncCall
                     (Ident (Identifier "smallcaps"))
                     [ NormalArg
@@ -95,7 +58,7 @@
                                     , SoftBreak
                                     , Code
                                         "typ/compiler/break-continue-09.typ"
-                                        ( line 12 , column 6 )
+                                        ( line 11 , column 6 )
                                         Break
                                     , ParBreak
                                     ])
@@ -108,6 +71,10 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/break-continue-10.out b/test/typ/compiler/break-continue-10.out
--- a/test/typ/compiler/break-continue-10.out
+++ b/test/typ/compiler/break-continue-10.out
@@ -1,50 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-10.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
-                                 "typ/compiler/break-continue-10.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-10.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/break-continue-10.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -61,6 +24,10 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [Hello]), 
                  parbreak() })
diff --git a/test/typ/compiler/break-continue-11.out b/test/typ/compiler/break-continue-11.out
--- a/test/typ/compiler/break-continue-11.out
+++ b/test/typ/compiler/break-continue-11.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/break-continue-11.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
-                                 "typ/compiler/break-continue-11.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/break-continue-11.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/break-continue-11.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -68,8 +29,7 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  table(children: (text(body: [A]), 
                                   { text(body: [B]), 
                                     text(body: [B]), 
diff --git a/test/typ/compiler/call-00.out b/test/typ/compiler/call-00.out
--- a/test/typ/compiler/call-00.out
+++ b/test/typ/compiler/call-00.out
@@ -1,68 +1,30 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/call-00.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
-                                 "typ/compiler/call-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/call-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/call-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (LetFunc (Identifier "f") [] (Block (CodeBlock [])))
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Block
        (Content
           [ Code
               "typ/compiler/call-00.typ"
-              ( line 6 , column 4 )
+              ( line 5 , column 4 )
               (FuncCall (Ident (Identifier "f")) [])
           , Strong [ Text "Bold" ]
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "x") , NormalParam (Identifier "body") ]
@@ -74,7 +36,7 @@
                    (Content
                       [ Code
                           "typ/compiler/call-00.typ"
-                          ( line 9 , column 28 )
+                          ( line 8 , column 28 )
                           (Ident (Identifier "x"))
                       ]))
                 (Ident (Identifier "body")))
@@ -82,13 +44,13 @@
                 (Content
                    [ Code
                        "typ/compiler/call-00.typ"
-                       ( line 9 , column 42 )
+                       ( line 8 , column 42 )
                        (Ident (Identifier "y"))
                    ])))))
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (FuncCall
           (Ident (Identifier "f"))
@@ -96,9 +58,10 @@
        [ NormalArg (Literal (Int 3)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Ident (Identifier "test"))
 , Space
 , Text "("
@@ -106,7 +69,7 @@
 , ParBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "body") ]
@@ -114,24 +77,24 @@
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall (Ident (Identifier "f")) [ BlockArg [ Text "A" ] ])
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall (Ident (Identifier "f")) [ BlockArg [ Text "A" ] ])
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "f"))
        [ NormalArg (Block (Content [ Text "A" ])) ])
 , ParBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (LetFunc
        (Identifier "g")
        [ NormalParam (Identifier "a") , NormalParam (Identifier "b") ]
@@ -139,14 +102,14 @@
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "g"))
        [ BlockArg [ Text "A" ] , BlockArg [ Text "B" ] ])
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "g"))
        [ NormalArg (Block (Content [ Text "A" ]))
@@ -155,15 +118,14 @@
 , SoftBreak
 , Code
     "typ/compiler/call-00.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (FuncCall
        (Ident (Identifier "g"))
        [ BlockArg [ Text "A" ] , BlockArg [ Text "B" ] ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [
@@ -172,10 +134,14 @@
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
                  text(body: [1]), 
                  text(body: [2]), 
                  text(body: [3]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [ (it)]), 
                  parbreak(), 
                  text(body: [
diff --git a/test/typ/compiler/call-01.out b/test/typ/compiler/call-01.out
--- a/test/typ/compiler/call-01.out
+++ b/test/typ/compiler/call-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/call-01.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
-                                 "typ/compiler/call-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/call-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/call-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Plus (Literal (Int 1)) (Literal (Int 1)))
@@ -50,16 +11,17 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/call-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "alias")))
        (Ident (Identifier "type")))
 , SoftBreak
 , Code
     "typ/compiler/call-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -70,9 +32,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/call-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Block
        (CodeBlock
           [ FuncCall
@@ -107,8 +70,12 @@
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/closure-00.out b/test/typ/compiler/closure-00.out
--- a/test/typ/compiler/closure-00.out
+++ b/test/typ/compiler/closure-00.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-00.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
-                                 "typ/compiler/closure-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/closure-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal (String "x")))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/closure-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncExpr
        [ NormalParam (Identifier "x") ] (Ident (Identifier "y")))
 , ParBreak
@@ -58,7 +20,8 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
+                 parbreak(), 
+                 parbreak(), 
                  text(body: [
 ]), 
-                 parbreak(), 
                  parbreak() })
diff --git a/test/typ/compiler/closure-01.out b/test/typ/compiler/closure-01.out
--- a/test/typ/compiler/closure-01.out
+++ b/test/typ/compiler/closure-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-01.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
-                                 "typ/compiler/closure-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/closure-02.out b/test/typ/compiler/closure-02.out
--- a/test/typ/compiler/closure-02.out
+++ b/test/typ/compiler/closure-02.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-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
-                                 "typ/compiler/closure-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/closure-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Block
        (CodeBlock
           [ Let
@@ -86,6 +48,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/closure-03.out b/test/typ/compiler/closure-03.out
--- a/test/typ/compiler/closure-03.out
+++ b/test/typ/compiler/closure-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-03.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
-                                 "typ/compiler/closure-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let (BasicBind (Just (Identifier "mark"))) (Literal (String "!"))
diff --git a/test/typ/compiler/closure-04.out b/test/typ/compiler/closure-04.out
--- a/test/typ/compiler/closure-04.out
+++ b/test/typ/compiler/closure-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-04.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
-                                 "typ/compiler/closure-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 1))
diff --git a/test/typ/compiler/closure-05.out b/test/typ/compiler/closure-05.out
--- a/test/typ/compiler/closure-05.out
+++ b/test/typ/compiler/closure-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-05.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
-                                 "typ/compiler/closure-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/closure-06.out b/test/typ/compiler/closure-06.out
--- a/test/typ/compiler/closure-06.out
+++ b/test/typ/compiler/closure-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-06.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
-                                 "typ/compiler/closure-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/closure-07.out b/test/typ/compiler/closure-07.out
--- a/test/typ/compiler/closure-07.out
+++ b/test/typ/compiler/closure-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-07.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
-                                 "typ/compiler/closure-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let (BasicBind (Just (Identifier "g"))) (Literal (String "hi"))
diff --git a/test/typ/compiler/closure-08.out b/test/typ/compiler/closure-08.out
--- a/test/typ/compiler/closure-08.out
+++ b/test/typ/compiler/closure-08.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-08.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
-                                 "typ/compiler/closure-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-08.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 5))
diff --git a/test/typ/compiler/closure-21.out b/test/typ/compiler/closure-21.out
--- a/test/typ/compiler/closure-21.out
+++ b/test/typ/compiler/closure-21.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/closure-21.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
-                                 "typ/compiler/closure-21.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-21.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/closure-21.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -65,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -79,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -93,7 +53,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -110,7 +70,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -127,7 +87,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -144,7 +104,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -166,7 +126,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -188,7 +148,7 @@
 , SoftBreak
 , Code
     "typ/compiler/closure-21.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -210,9 +170,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compiler/closure-22.out b/test/typ/compiler/closure-22.out
--- a/test/typ/compiler/closure-22.out
+++ b/test/typ/compiler/closure-22.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/closure-22.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
-                                 "typ/compiler/closure-22.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/closure-22.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/closure-22.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (FuncExpr [ SkipParam , SkipParam ] (Array []))
        [ NormalArg (Literal (Int 1)) ])
 , ParBreak
 ]
-"typ/compiler/closure-22.typ" (line 3, column 2):
+"typ/compiler/closure-22.typ" (line 2, column 2):
 missing argument: pattern parameter
diff --git a/test/typ/compiler/color-00.out b/test/typ/compiler/color-00.out
--- a/test/typ/compiler/color-00.out
+++ b/test/typ/compiler/color-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/color-00.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
-                                 "typ/compiler/color-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/color-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/color-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "c")))
        (FuncCall
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/color-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
@@ -95,7 +56,7 @@
 , ParBreak
 , Code
     "typ/compiler/color-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (For
        (BasicBind (Just (Identifier "x")))
        (FuncCall
@@ -123,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/compiler/color-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (For
        (BasicBind (Just (Identifier "x")))
        (FuncCall
diff --git a/test/typ/compiler/color-01.out b/test/typ/compiler/color-01.out
--- a/test/typ/compiler/color-01.out
+++ b/test/typ/compiler/color-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/color-01.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
-                                 "typ/compiler/color-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/color-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/color-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -62,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/compiler/color-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +43,7 @@
 , SoftBreak
 , Code
     "typ/compiler/color-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -101,6 +63,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [✅]), 
                  text(body: [
diff --git a/test/typ/compiler/comment-00.out b/test/typ/compiler/comment-00.out
--- a/test/typ/compiler/comment-00.out
+++ b/test/typ/compiler/comment-00.out
@@ -1,58 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/comment-00.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
-                                 "typ/compiler/comment-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/comment-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Comment
+, SoftBreak
 , Text "B"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "C"
 , Comment
 , Text "D"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/comment-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -62,27 +26,29 @@
        ])
 , ParBreak
 , Comment
-, Comment
 , SoftBreak
 , Comment
-, Comment
 , ParBreak
-, Text "E"
-, ParBreak
+, Comment
+, SoftBreak
+, Comment
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
-                 text(body: [B]), 
+A]), 
+                 text(body: [
+B]), 
                  parbreak(), 
-                 text(body: [C]), 
+                 text(body: [
+C]), 
                  text(body: [D]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
-                 text(body: [E]), 
-                 parbreak() })
+                 text(body: [
+]) })
diff --git a/test/typ/compiler/construct-00.out b/test/typ/compiler/construct-00.out
--- a/test/typ/compiler/construct-00.out
+++ b/test/typ/compiler/construct-00.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/construct-00.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
-                                 "typ/compiler/construct-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/construct-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/construct-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "leading") (Literal (Numeric 2.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/compiler/construct-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "list"))
        [ KeyValArg (Identifier "body-indent") (Literal (Numeric 20.0 Pt))
@@ -64,6 +26,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/construct-01.out b/test/typ/compiler/construct-01.out
--- a/test/typ/compiler/construct-01.out
+++ b/test/typ/compiler/construct-01.out
@@ -1,57 +1,20 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/construct-01.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
-                                 "typ/compiler/construct-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/construct-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/construct-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "list"))
        [ KeyValArg (Identifier "marker") (Block (Content [ Text ">" ])) ])
 , SoftBreak
 , Code
     "typ/compiler/construct-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "list"))
        [ KeyValArg (Identifier "marker") (Block (Content [ EnDash ]))
@@ -59,7 +22,7 @@
            [ SoftBreak
            , Code
                "typ/compiler/construct-01.typ"
-               ( line 7 , column 4 )
+               ( line 6 , column 4 )
                (FuncCall
                   (Ident (Identifier "rect"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 2.0 Cm))
@@ -75,6 +38,10 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/construct-02.out b/test/typ/compiler/construct-02.out
--- a/test/typ/compiler/construct-02.out
+++ b/test/typ/compiler/construct-02.out
@@ -1,60 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/construct-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
-                                 "typ/compiler/construct-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/construct-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/construct-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Block
        (Content
           [ Code
               "typ/compiler/construct-02.typ"
-              ( line 4 , column 4 )
+              ( line 3 , column 4 )
               (Set
                  (Ident (Identifier "rect"))
                  [ KeyValArg (Identifier "fill") (Ident (Identifier "yellow")) ])
           , Code
               "typ/compiler/construct-02.typ"
-              ( line 4 , column 28 )
+              ( line 3 , column 28 )
               (FuncCall
                  (Ident (Identifier "text"))
                  [ NormalArg (Literal (Numeric 1.0 Em))
@@ -70,6 +32,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: rect(body: rect(fill: rgb(100%,86%,0%,100%)), 
                                  fill: rgb(100%,86%,0%,100%), 
diff --git a/test/typ/compiler/construct-03.out b/test/typ/compiler/construct-03.out
--- a/test/typ/compiler/construct-03.out
+++ b/test/typ/compiler/construct-03.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/construct-03.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
-                                 "typ/compiler/construct-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/construct-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Space
 , Code
     "typ/compiler/construct-03.typ"
-    ( line 3 , column 4 )
+    ( line 2 , column 4 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -61,8 +22,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A ]), 
+A ]), 
                  box(body: rect(body: rect(), 
                                 fill: rgb(100%,86%,0%,100%), 
                                 inset: 5.0pt)), 
diff --git a/test/typ/compiler/construct-04.out b/test/typ/compiler/construct-04.out
--- a/test/typ/compiler/construct-04.out
+++ b/test/typ/compiler/construct-04.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/construct-04.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
-                                 "typ/compiler/construct-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/construct-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/construct-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "enum")))
        (Set
@@ -52,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/construct-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "enum"))
        [ KeyValArg (Identifier "numbering") (Literal (String "(a)"))
@@ -64,6 +26,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/destructuring-00.out b/test/typ/compiler/destructuring-00.out
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/destructuring-00.out
@@ -0,0 +1,269 @@
+--- parse tree ---
+[ Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 1 , column 2 )
+    (Let
+       (DestructuringBind
+          [ Simple (BasicBind Nothing)
+          , Simple
+              (DestructuringBind
+                 [ Simple (BasicBind (Just (Identifier "x")))
+                 , Simple (BasicBind (Just (Identifier "y")))
+                 , Simple (BasicBind Nothing)
+                 ])
+          ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg
+              (Array
+                 [ Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 , Reg (Literal (Int 4))
+                 ])
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 2 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Array
+              [ Reg (Ident (Identifier "x")) , Reg (Ident (Identifier "y")) ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 3)) ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 4 , column 2 )
+    (Let
+       (DestructuringBind
+          [ WithKey
+              (Identifier "x")
+              (DestructuringBind
+                 [ Simple (BasicBind (Just (Identifier "v")))
+                 , Simple (BasicBind Nothing)
+                 , Simple (BasicBind (Just (Identifier "w")))
+                 ])
+          , Simple (BasicBind (Just (Identifier "p")))
+          ])
+       (Dict
+          [ Reg ( Ident (Identifier "p") , Literal (Int 1) )
+          , Reg
+              ( Ident (Identifier "x")
+              , Array
+                  [ Reg (Literal (Int 5))
+                  , Reg (Literal (Int 6))
+                  , Reg (Literal (Int 7))
+                  ]
+              )
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 5 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Array
+              [ Reg (Ident (Identifier "v"))
+              , Reg (Ident (Identifier "w"))
+              , Reg (Ident (Identifier "p"))
+              ])
+       , NormalArg
+           (Array
+              [ Reg (Literal (Int 5))
+              , Reg (Literal (Int 7))
+              , Reg (Literal (Int 1))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 7 , column 2 )
+    (Let
+       (DestructuringBind
+          [ WithKey
+              (Identifier "x")
+              (DestructuringBind
+                 [ Simple (BasicBind (Just (Identifier "n")))
+                 , WithKey
+                     (Identifier "o")
+                     (DestructuringBind
+                        [ Simple (BasicBind Nothing)
+                        , Simple (BasicBind (Just (Identifier "h")))
+                        ])
+                 , Simple (BasicBind (Just (Identifier "m")))
+                 ])
+          , Simple (BasicBind (Just (Identifier "r")))
+          ])
+       (Dict
+          [ Reg ( Ident (Identifier "r") , Literal (Int 1) )
+          , Reg
+              ( Ident (Identifier "x")
+              , Dict
+                  [ Reg ( Ident (Identifier "m") , Literal (Int 5) )
+                  , Reg ( Ident (Identifier "n") , Literal (Int 6) )
+                  , Reg
+                      ( Ident (Identifier "o")
+                      , Array [ Reg (Literal (Int 7)) , Reg (Literal (Int 8)) ]
+                      )
+                  ]
+              )
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 8 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Array
+              [ Reg (Ident (Identifier "n"))
+              , Reg (Ident (Identifier "h"))
+              , Reg (Ident (Identifier "m"))
+              , Reg (Ident (Identifier "r"))
+              ])
+       , NormalArg
+           (Array
+              [ Reg (Literal (Int 6))
+              , Reg (Literal (Int 8))
+              , Reg (Literal (Int 5))
+              , Reg (Literal (Int 1))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 10 , column 2 )
+    (Let
+       (DestructuringBind
+          [ Simple (BasicBind Nothing)
+          , Simple
+              (DestructuringBind [ Simple (BasicBind (Just (Identifier "x"))) ])
+          ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg (Array [ Reg (Literal (Int 12)) ])
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 11 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "x"))
+       , NormalArg (Literal (Int 12))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 13 , column 2 )
+    (Let
+       (BasicBind (Just (Identifier "f")))
+       (FuncExpr
+          [ SkipParam
+          , DestructuringParam
+              [ Simple (BasicBind (Just (Identifier "x")))
+              , Simple
+                  (DestructuringBind
+                     [ Simple (BasicBind Nothing)
+                     , Simple (BasicBind (Just (Identifier "y")))
+                     ])
+              , Sink Nothing
+              ]
+          ]
+          (Array
+             [ Reg (Ident (Identifier "x")) , Reg (Ident (Identifier "y")) ])))
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 14 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (FuncCall
+              (Ident (Identifier "f"))
+              [ NormalArg (Literal (Int 21))
+              , NormalArg
+                  (Array
+                     [ Reg (Literal (Int 22))
+                     , Reg (Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 23)) ])
+                     , Reg (Literal (Int 24))
+                     ])
+              ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 22)) , Reg (Literal (Int 23)) ])
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 15 , column 2 )
+    (Let
+       (BasicBind (Just (Identifier "f")))
+       (FuncExpr
+          [ SkipParam
+          , DestructuringParam
+              [ Simple (BasicBind (Just (Identifier "x")))
+              , WithKey
+                  (Identifier "y")
+                  (DestructuringBind
+                     [ Simple (BasicBind Nothing)
+                     , Simple (BasicBind (Just (Identifier "y")))
+                     ])
+              , Sink Nothing
+              ]
+          ]
+          (Array
+             [ Reg (Ident (Identifier "x")) , Reg (Ident (Identifier "y")) ])))
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-00.typ"
+    ( line 16 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (FuncCall
+              (Ident (Identifier "f"))
+              [ NormalArg (Literal (Int 1))
+              , NormalArg
+                  (Dict
+                     [ Reg ( Ident (Identifier "x") , Literal (Int 2) )
+                     , Reg
+                         ( Ident (Identifier "y")
+                         , Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 3)) ]
+                         )
+                     ])
+              ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 3)) ])
+       ])
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak() })
diff --git a/test/typ/compiler/destructuring-00.typ b/test/typ/compiler/destructuring-00.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/destructuring-00.typ
@@ -0,0 +1,16 @@
+#let (_, (x, y, _)) = (1, (2, 3, 4))
+#test((x, y), (2, 3))
+
+#let (x: (v, _, w), p) = (p: 1, x: (5, 6, 7))
+#test((v, w, p), (5, 7, 1))
+
+#let (x: (n, o: (_, h), m), r) = (r: 1, x: (m: 5, n: 6, o: (7, 8)))
+#test((n, h, m, r), (6, 8, 5, 1))
+
+#let (_, (x,)) = (1, (12,))
+#test(x, 12)
+
+#let f = (_, (x, (_, y), ..)) => (x, y)
+#test(f(21, (22, (0, 23), 24)), (22, 23))
+#let f = (_, (x, y: (_, y), ..)) => (x, y)
+#test(f(1, (x: 2, y: (0, 3))), (2, 3))
diff --git a/test/typ/compiler/destructuring-01.out b/test/typ/compiler/destructuring-01.out
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/destructuring-01.out
@@ -0,0 +1,16 @@
+--- parse tree ---
+[ Comment
+, SoftBreak
+, Code
+    "typ/compiler/destructuring-01.typ"
+    ( line 2 , column 2 )
+    (Let
+       (DestructuringBind
+          [ Simple (BasicBind Nothing)
+          , Simple (BasicBind (Just (Identifier "x")))
+          ])
+       (Dict [ Reg ( Ident (Identifier "x") , Literal (Int 1) ) ]))
+, ParBreak
+]
+"typ/compiler/destructuring-01.typ" (line 2, column 2):
+cannot destructure unnamed pattern from dictionary
diff --git a/test/typ/compiler/destructuring-01.typ b/test/typ/compiler/destructuring-01.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/destructuring-01.typ
@@ -0,0 +1,2 @@
+// Should error: cannot destructure unnamed pattern from dictionary
+#let (_, x) = (x: 1)
diff --git a/test/typ/compiler/destructuring-02.out b/test/typ/compiler/destructuring-02.out
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/destructuring-02.out
@@ -0,0 +1,4 @@
+"typ/compiler/destructuring-02.typ" (line 2, column 10):
+unexpected "x"
+expecting "*/", "//" or "/*"
+expected identifier, found underscore
diff --git a/test/typ/compiler/destructuring-02.typ b/test/typ/compiler/destructuring-02.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/destructuring-02.typ
@@ -0,0 +1,2 @@
+// Should error: expected identifier, found underscore
+#let (_: x) = (k: 1)
diff --git a/test/typ/compiler/dict-00.out b/test/typ/compiler/dict-00.out
--- a/test/typ/compiler/dict-00.out
+++ b/test/typ/compiler/dict-00.out
@@ -1,53 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/dict-00.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
-                                 "typ/compiler/dict-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/dict-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
-, Code "typ/compiler/dict-00.typ" ( line 5 , column 2 ) (Dict [])
+, Code "typ/compiler/dict-00.typ" ( line 4 , column 2 ) (Dict [])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/dict-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Let
        (BasicBind (Just (Identifier "dict")))
        (Dict
@@ -57,12 +19,12 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Ident (Identifier "dict"))
 , ParBreak
 , Code
     "typ/compiler/dict-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -73,7 +35,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -85,12 +47,13 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [()]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  text(body: [(normal: 1, spacy key: 2)]), 
diff --git a/test/typ/compiler/dict-01.out b/test/typ/compiler/dict-01.out
--- a/test/typ/compiler/dict-01.out
+++ b/test/typ/compiler/dict-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/dict-01.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
-                                 "typ/compiler/dict-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/dict-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/dict-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/dict-03.out b/test/typ/compiler/dict-03.out
--- a/test/typ/compiler/dict-03.out
+++ b/test/typ/compiler/dict-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/dict-03.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
-                                 "typ/compiler/dict-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/dict-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/dict-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -61,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/dict-05.out b/test/typ/compiler/dict-05.out
--- a/test/typ/compiler/dict-05.out
+++ b/test/typ/compiler/dict-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/dict-05.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
-                                 "typ/compiler/dict-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/dict-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "dict")))
        (Dict
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -63,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -76,7 +37,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -94,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -130,7 +91,7 @@
 , ParBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "remove")) (Ident (Identifier "dict")))
@@ -138,7 +99,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -148,7 +109,7 @@
 , SoftBreak
 , Code
     "typ/compiler/dict-05.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "dict"))
diff --git a/test/typ/compiler/field-00.out b/test/typ/compiler/field-00.out
--- a/test/typ/compiler/field-00.out
+++ b/test/typ/compiler/field-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/field-00.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
-                                 "typ/compiler/field-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/field-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/field-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "dict")))
        (Dict
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compiler/field-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -63,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/compiler/field-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/field-01.out b/test/typ/compiler/field-01.out
--- a/test/typ/compiler/field-01.out
+++ b/test/typ/compiler/field-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/field-01.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
-                                 "typ/compiler/field-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/field-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/field-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (FuncExpr
@@ -66,7 +27,8 @@
 , SoftBreak
 , BulletListItem [ Text "B" ]
 , SoftBreak
-, BulletListItem [ Text "C" , ParBreak ]
+, BulletListItem [ Text "C" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
diff --git a/test/typ/compiler/field-02.out b/test/typ/compiler/field-02.out
--- a/test/typ/compiler/field-02.out
+++ b/test/typ/compiler/field-02.out
@@ -1,60 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/field-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
-                                 "typ/compiler/field-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/field-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/field-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FieldAccess
        (Ident (Identifier "item")) (Ident (Identifier "enum")))
 , SoftBreak
 , Code
     "typ/compiler/field-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FieldAccess
        (Ident (Identifier "eq")) (Ident (Identifier "assert")))
 , SoftBreak
 , Code
     "typ/compiler/field-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FieldAccess
        (Ident (Identifier "ne")) (Ident (Identifier "assert")))
 , ParBreak
diff --git a/test/typ/compiler/float-literal-00.out b/test/typ/compiler/float-literal-00.out
--- a/test/typ/compiler/float-literal-00.out
+++ b/test/typ/compiler/float-literal-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/float-literal-00.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
-                                 "typ/compiler/float-literal-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/float-literal-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/float-literal-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -72,7 +32,5 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/float-literal-01.out b/test/typ/compiler/float-literal-01.out
--- a/test/typ/compiler/float-literal-01.out
+++ b/test/typ/compiler/float-literal-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/float-literal-01.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
-                                 "typ/compiler/float-literal-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/float-literal-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/float-literal-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FieldAccess (Ident (Identifier "e")) (Literal (Int 1)))
 , ParBreak
 ]
-"typ/compiler/float-literal-01.typ" (line 3, column 2):
+"typ/compiler/float-literal-01.typ" (line 2, column 2):
 Integer does not have a method "e" or FieldAccess requires a dictionary
diff --git a/test/typ/compiler/for-00.out b/test/typ/compiler/for-00.out
--- a/test/typ/compiler/for-00.out
+++ b/test/typ/compiler/for-00.out
@@ -1,64 +1,27 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/for-00.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
-                                 "typ/compiler/for-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/for-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/for-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (For
        (BasicBind (Just (Identifier "x")))
        (Array [])
        (Block (Content [ Text "Nope" ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (For
        (DestructuringBind
-          [ Simple (Just (Identifier "k"))
-          , Simple (Just (Identifier "v"))
+          [ Simple (BasicBind (Just (Identifier "k")))
+          , Simple (BasicBind (Just (Identifier "v")))
           ])
        (Dict
           [ Reg ( Ident (Identifier "Name") , Literal (String "Typst") )
@@ -69,23 +32,25 @@
              [ SoftBreak
              , Code
                  "typ/compiler/for-00.typ"
-                 ( line 10 , column 4 )
+                 ( line 9 , column 4 )
                  (Ident (Identifier "k"))
              , Text ":"
              , Space
              , Code
                  "typ/compiler/for-00.typ"
-                 ( line 10 , column 8 )
+                 ( line 9 , column 8 )
                  (Ident (Identifier "v"))
              , Text "."
              , ParBreak
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (Block
        (CodeBlock
           [ Literal (String "[")
@@ -108,7 +73,7 @@
                         (Content
                            [ Code
                                "typ/compiler/for-00.typ"
-                               ( line 19 , column 7 )
+                               ( line 18 , column 7 )
                                (Ident (Identifier "v"))
                            ])
                     , If
@@ -136,10 +101,12 @@
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 30 , column 2 )
+    ( line 29 , column 2 )
     (For
        (BasicBind (Just (Identifier "v")))
        (Array
@@ -155,7 +122,7 @@
           (Content
              [ Code
                  "typ/compiler/for-00.typ"
-                 ( line 30 , column 35 )
+                 ( line 29 , column 35 )
                  (If
                     [ ( And
                           (GreaterThanOrEqual (Ident (Identifier "v")) (Literal (Int 2)))
@@ -170,9 +137,10 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 33 , column 2 )
+    ( line 32 , column 2 )
     (LetFunc
        (Identifier "f1")
        [ SinkParam (Just (Identifier "args")) ]
@@ -187,7 +155,7 @@
 , SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 34 , column 2 )
+    ( line 33 , column 2 )
     (LetFunc
        (Identifier "f2")
        [ SinkParam (Just (Identifier "args")) ]
@@ -226,7 +194,7 @@
 , SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 35 , column 2 )
+    ( line 34 , column 2 )
     (LetFunc
        (Identifier "f")
        [ SinkParam (Just (Identifier "args")) ]
@@ -244,7 +212,7 @@
 , SoftBreak
 , Code
     "typ/compiler/for-00.typ"
-    ( line 36 , column 2 )
+    ( line 35 , column 2 )
     (FuncCall
        (Ident (Identifier "f"))
        [ NormalArg (Literal (Int 1))
@@ -253,13 +221,16 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  text(body: [Name]), 
                  text(body: [: ]), 
                  text(body: [Typst]), 
@@ -273,6 +244,10 @@
                  text(body: [.]), 
                  parbreak(), 
                  parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  text(body: [[]), 
                  text(body: [1]), 
                  text(body: [st]), 
@@ -287,11 +262,17 @@
                  text(body: [th]), 
                  text(body: []]), 
                  parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  text(body: [2]), 
                  text(body: [3]), 
                  text(body: [4]), 
                  text(body: [5]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  text(body: [
diff --git a/test/typ/compiler/for-01.out b/test/typ/compiler/for-01.out
--- a/test/typ/compiler/for-01.out
+++ b/test/typ/compiler/for-01.out
@@ -2,52 +2,13 @@
 [ Code
     "typ/compiler/for-01.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
-                                 "typ/compiler/for-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/for-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/for-01.typ"
-    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "out"))) (Array []))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (For
        (BasicBind (Just (Identifier "v")))
        (Array
@@ -65,13 +26,14 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (For
        (DestructuringBind
-          [ Simple (Just (Identifier "i"))
-          , Simple (Just (Identifier "v"))
+          [ Simple (BasicBind (Just (Identifier "i")))
+          , Simple (BasicBind (Just (Identifier "v")))
           ])
        (FuncCall
           (FieldAccess
@@ -95,9 +57,10 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (For
        (BasicBind (Just (Identifier "v")))
        (Dict
@@ -114,13 +77,14 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (For
        (DestructuringBind
-          [ Simple (Just (Identifier "k"))
-          , Simple (Just (Identifier "v"))
+          [ Simple (BasicBind (Just (Identifier "k")))
+          , Simple (BasicBind (Just (Identifier "v")))
           ])
        (Dict
           [ Reg ( Ident (Identifier "a") , Literal (Int 6) )
@@ -142,7 +106,7 @@
 , ParBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "out"))
@@ -163,15 +127,16 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 28 , column 2 )
+    ( line 27 , column 2 )
     (Let
        (BasicBind (Just (Identifier "first"))) (Literal (Boolean True)))
 , SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 29 , column 2 )
+    ( line 28 , column 2 )
     (Let
        (BasicBind (Just (Identifier "joined")))
        (For
@@ -190,7 +155,7 @@
 , ParBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 35 , column 2 )
+    ( line 34 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "joined"))
@@ -200,9 +165,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 38 , column 2 )
+    ( line 37 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -215,7 +181,7 @@
 , SoftBreak
 , Code
     "typ/compiler/for-01.typ"
-    ( line 39 , column 2 )
+    ( line 38 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -232,20 +198,28 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
+document(body: { parbreak(), 
+                 text(body: [
 ]), 
                  parbreak(), 
-                 parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [✅]), 
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [❌(]), 
                  text(body: ["a, b, c, 👩, ‍, 👩, ‍, 👦, ‍, 👦"]), 
@@ -253,6 +227,8 @@
                  text(body: ["a, b, c, 👩‍👩‍👦‍👦"]), 
                  text(body: [)]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/highlight-00.out b/test/typ/compiler/highlight-00.out
--- a/test/typ/compiler/highlight-00.out
+++ b/test/typ/compiler/highlight-00.out
@@ -2,60 +2,18 @@
 [ Code
     "typ/compiler/highlight-00.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
-                                 "typ/compiler/highlight-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/highlight-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/highlight-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , ParBreak
 , RawBlock
     "typ"
-    "#set hello()\n#set hello()\n#set hello.world()\n#set hello.my.world()\n#let foo(x) = x * 2\n#show heading: func\n#show module.func: func\n#show module.func: it => {}\n#foo(ident: ident)\n#hello\n#hello()\n#box[]\n#hello.world\n#hello.world()\n#hello().world()\n#hello.my.world\n#hello.my.world()\n#hello.my().world\n#hello.my().world()\n#{ hello }\n#{ hello() }\n#{ hello.world() }\n$ hello $\n$ hello() $\n$ box[] $\n$ hello.world $\n$ hello.world() $\n$ hello.my.world() $\n$ f_zeta(x), f_zeta(x)/1 $\n$ emph(hello.my.world()) $\n$ emph(hello.my().world) $\n$ emph(hello.my().world()) $\n$ #hello $\n$ #hello() $\n$ #hello.world $\n$ #hello.world() $\n$ #box[] $\n#if foo []\n"
+    "#set hello()\n#set hello()\n#set hello.world()\n#set hello.my.world()\n#let foo(x) = x * 2\n#show heading: func\n#show module.func: func\n#show module.func: it => {}\n#foo(ident: ident)\n#hello\n#hello()\n#box[]\n#hello.world\n#hello.world()\n#hello().world()\n#hello.my.world\n#hello.my.world()\n#hello.my().world\n#hello.my().world()\n#{ hello }\n#{ hello() }\n#{ hello.world() }\n$ hello $\n$ hello() $\n$ box[] $\n$ hello.world $\n$ hello.world() $\n$ hello.my.world() $\n$ f_zeta(x), f_zeta(x)/1 $\n$ emph(hello.my.world()) $\n$ emph(hello.my().world) $\n$ emph(hello.my().world()) $\n$ #hello $\n$ #hello() $\n$ #hello.world $\n$ #hello.world() $\n$ #box[] $\n#if foo []"
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  raw(block: true, 
                      lang: "typ", 
-                     text: "#set hello()\n#set hello()\n#set hello.world()\n#set hello.my.world()\n#let foo(x) = x * 2\n#show heading: func\n#show module.func: func\n#show module.func: it => {}\n#foo(ident: ident)\n#hello\n#hello()\n#box[]\n#hello.world\n#hello.world()\n#hello().world()\n#hello.my.world\n#hello.my.world()\n#hello.my().world\n#hello.my().world()\n#{ hello }\n#{ hello() }\n#{ hello.world() }\n$ hello $\n$ hello() $\n$ box[] $\n$ hello.world $\n$ hello.world() $\n$ hello.my.world() $\n$ f_zeta(x), f_zeta(x)/1 $\n$ emph(hello.my.world()) $\n$ emph(hello.my().world) $\n$ emph(hello.my().world()) $\n$ #hello $\n$ #hello() $\n$ #hello.world $\n$ #hello.world() $\n$ #box[] $\n#if foo []\n"), 
+                     text: "#set hello()\n#set hello()\n#set hello.world()\n#set hello.my.world()\n#let foo(x) = x * 2\n#show heading: func\n#show module.func: func\n#show module.func: it => {}\n#foo(ident: ident)\n#hello\n#hello()\n#box[]\n#hello.world\n#hello.world()\n#hello().world()\n#hello.my.world\n#hello.my.world()\n#hello.my().world\n#hello.my().world()\n#{ hello }\n#{ hello() }\n#{ hello.world() }\n$ hello $\n$ hello() $\n$ box[] $\n$ hello.world $\n$ hello.world() $\n$ hello.my.world() $\n$ f_zeta(x), f_zeta(x)/1 $\n$ emph(hello.my.world()) $\n$ emph(hello.my().world) $\n$ emph(hello.my().world()) $\n$ #hello $\n$ #hello() $\n$ #hello.world $\n$ #hello.world() $\n$ #box[] $\n#if foo []"), 
                  parbreak() })
diff --git a/test/typ/compiler/if-00.out b/test/typ/compiler/if-00.out
--- a/test/typ/compiler/if-00.out
+++ b/test/typ/compiler/if-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/if-00.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
-                                 "typ/compiler/if-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/if-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/if-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (If
        [ ( LessThan (Literal (Int 1)) (Literal (Int 2))
          , Block (Content [ SoftBreak , Text "One" , Text "." , ParBreak ])
@@ -51,7 +12,7 @@
 , ParBreak
 , Code
     "typ/compiler/if-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (If
        [ ( Equals (Literal (Boolean True)) (Literal (Boolean False))
          , Block
diff --git a/test/typ/compiler/if-01.out b/test/typ/compiler/if-01.out
--- a/test/typ/compiler/if-01.out
+++ b/test/typ/compiler/if-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/if-01.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
-                                 "typ/compiler/if-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/if-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/if-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (If
        [ ( Block (CodeBlock [ Literal (Boolean True) ])
          , Block (Content [ SoftBreak , Text "One" , Text "." , ParBreak ])
@@ -50,9 +11,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/if-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (If
        [ ( Not (Equals (Block (Content [])) (Literal None))
          , Block (Content [ SoftBreak , Text "Two" , Text "." , ParBreak ])
@@ -60,9 +22,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/if-01.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (If
        [ ( Equals
              (Plus (Literal (Int 1)) (Literal (Int 1))) (Literal (Int 1))
@@ -74,9 +37,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/if-01.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (If
        [ ( Literal (Boolean False)
          , Block (Content [ SoftBreak , Text "Bad" , Text "." , ParBreak ])
@@ -92,9 +56,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/if-01.typ"
-    ( line 31 , column 2 )
+    ( line 30 , column 2 )
     (Block
        (CodeBlock
           [ If
@@ -117,12 +82,12 @@
 , ParBreak
 , Code
     "typ/compiler/if-01.typ"
-    ( line 36 , column 2 )
+    ( line 35 , column 2 )
     (Let (BasicBind (Just (Identifier "i"))) (Literal (Int 3)))
 , SoftBreak
 , Code
     "typ/compiler/if-01.typ"
-    ( line 37 , column 2 )
+    ( line 36 , column 2 )
     (If
        [ ( LessThan (Ident (Identifier "i")) (Literal (Int 2))
          , Block (Content [ SoftBreak , Text "Five" , Text "." , ParBreak ])
@@ -145,13 +110,21 @@
                  parbreak(), 
                  parbreak(), 
                  text(body: [
+]), 
+                 text(body: [
 Two.]), 
                  parbreak(), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [Three.]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [Four.]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [Fi]), 
                  text(body: [ve.]), 
                  parbreak(), 
diff --git a/test/typ/compiler/if-02.out b/test/typ/compiler/if-02.out
--- a/test/typ/compiler/if-02.out
+++ b/test/typ/compiler/if-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/if-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
-                                 "typ/compiler/if-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/if-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/if-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (LetFunc
        (Identifier "nth")
        [ NormalParam (Identifier "n") ]
@@ -70,7 +31,7 @@
 , ParBreak
 , Code
     "typ/compiler/if-02.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compiler/if-02.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -92,7 +53,7 @@
 , SoftBreak
 , Code
     "typ/compiler/if-02.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -103,7 +64,7 @@
 , SoftBreak
 , Code
     "typ/compiler/if-02.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -114,7 +75,7 @@
 , SoftBreak
 , Code
     "typ/compiler/if-02.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -127,8 +88,7 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  parbreak(), 
                  text(body: [✅]), 
                  text(body: [
diff --git a/test/typ/compiler/if-03.out b/test/typ/compiler/if-03.out
--- a/test/typ/compiler/if-03.out
+++ b/test/typ/compiler/if-03.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/if-03.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
-                                 "typ/compiler/if-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/if-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/if-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (CodeBlock
           [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 1))
@@ -93,8 +54,7 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  text(body: [✅]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
diff --git a/test/typ/compiler/import-00.out b/test/typ/compiler/import-00.out
--- a/test/typ/compiler/import-00.out
+++ b/test/typ/compiler/import-00.out
@@ -1,59 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/import-00.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
-                                 "typ/compiler/import-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/import-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/import-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "value")))
        (Block (Content [ Text "foo" ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/import-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Import
        (Literal (String "module.typ"))
        (SomeIdentifiers
@@ -63,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compiler/import-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "fn"))
        [ BlockArg
@@ -72,14 +35,16 @@
 , SoftBreak
 , Code
     "typ/compiler/import-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Ident (Identifier "value"))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/import-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (Import
        (Literal (String "module.typ"))
        (SomeIdentifiers
@@ -90,11 +55,14 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
+                 parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
                  rect(body: text(body: [Like and Subscribe!]), 
                       fill: rgb(18%,80%,25%,100%), 
                       inset: 5.0pt), 
@@ -102,5 +70,9 @@
 ]), 
                  text(body: [hi]), 
                  parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  text(body: [bye]), 
                  parbreak() })
diff --git a/test/typ/compiler/import-01.out b/test/typ/compiler/import-01.out
--- a/test/typ/compiler/import-01.out
+++ b/test/typ/compiler/import-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/import-01.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
-                                 "typ/compiler/import-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/import-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/import-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Import
        (Literal (String "module.typ"))
        (SomeIdentifiers [ ( Identifier "item" , Nothing ) ]))
 , SoftBreak
 , Code
     "typ/compiler/import-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -60,6 +21,7 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "{"
 , SoftBreak
 , Text "import"
@@ -82,15 +44,17 @@
 , Text "}"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/import-01.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Import (Literal (String "module.typ")) AllIdentifiers)
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/import-01.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "d"))
@@ -105,11 +69,16 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
-                 text(body: [{
+                 text(body: [
+{
 import “module.typ”: b
 test(b, 1)
 }]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak() })
diff --git a/test/typ/compiler/import-02.out b/test/typ/compiler/import-02.out
--- a/test/typ/compiler/import-02.out
+++ b/test/typ/compiler/import-02.out
@@ -1,57 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/import-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
-                                 "typ/compiler/import-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/import-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/import-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Import
        (Ident (Identifier "enum"))
        (SomeIdentifiers [ ( Identifier "item" , Nothing ) ]))
 , SoftBreak
 , Code
     "typ/compiler/import-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Import
        (FuncCall
           (FieldAccess
@@ -61,7 +22,7 @@
 , ParBreak
 , Code
     "typ/compiler/import-02.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "enum"))
        [ NormalArg
@@ -76,14 +37,14 @@
 , SoftBreak
 , Code
     "typ/compiler/import-02.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "eq"))
        [ NormalArg (Literal (Int 10)) , NormalArg (Literal (Int 10)) ])
 , SoftBreak
 , Code
     "typ/compiler/import-02.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "ne"))
        [ NormalArg (Literal (Int 5)) , NormalArg (Literal (Int 6)) ])
@@ -92,8 +53,7 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
diff --git a/test/typ/compiler/import-03.out b/test/typ/compiler/import-03.out
--- a/test/typ/compiler/import-03.out
+++ b/test/typ/compiler/import-03.out
@@ -1,53 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/import-03.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
-                                 "typ/compiler/import-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/import-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/import-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Import (Literal (String "module.typ")) (NoIdentifiers Nothing))
 , SoftBreak
 , Code
     "typ/compiler/import-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -58,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/compiler/import-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -71,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/compiler/import-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/import-05.out b/test/typ/compiler/import-05.out
--- a/test/typ/compiler/import-05.out
+++ b/test/typ/compiler/import-05.out
@@ -1,54 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/import-05.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
-                                 "typ/compiler/import-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/import-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/import-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Import (Literal (String "module.typ")) AllIdentifiers)
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/import-05.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Import
        (Literal (String "module.typ"))
        (SomeIdentifiers
@@ -59,4 +21,6 @@
 document(body: { text(body: [
 ]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak() })
diff --git a/test/typ/compiler/import-06.out b/test/typ/compiler/import-06.out
--- a/test/typ/compiler/import-06.out
+++ b/test/typ/compiler/import-06.out
@@ -1,53 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/import-06.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
-                                 "typ/compiler/import-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/import-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/import-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Import (Ident (Identifier "enum")) (NoIdentifiers Nothing))
 , SoftBreak
 , Code
     "typ/compiler/import-06.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "d")))
        (Dict
@@ -55,21 +16,21 @@
 , SoftBreak
 , Code
     "typ/compiler/import-06.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Import
        (FieldAccess (Ident (Identifier "e")) (Ident (Identifier "d")))
        (NoIdentifiers Nothing))
 , SoftBreak
 , Code
     "typ/compiler/import-06.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Import
        (FieldAccess (Ident (Identifier "e")) (Ident (Identifier "d")))
        (SomeIdentifiers [ ( Identifier "item" , Nothing ) ]))
 , ParBreak
 , Code
     "typ/compiler/import-06.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "item"))
        [ NormalArg (Literal (Int 2)) , BlockArg [ Text "a" ] ])
diff --git a/test/typ/compiler/include-00.out b/test/typ/compiler/include-00.out
--- a/test/typ/compiler/include-00.out
+++ b/test/typ/compiler/include-00.out
@@ -2,61 +2,24 @@
 [ Code
     "typ/compiler/include-00.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
-                                 "typ/compiler/include-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/include-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/include-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 200.0 Pt)) ])
 , ParBreak
 , Heading 1 [ Text "Document" ]
+, ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/include-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Include (Literal (String "modules/chap1.typ")))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/include-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Let
        (BasicBind (Just (Identifier "chap2")))
        (Include
@@ -72,19 +35,18 @@
 , SoftBreak
 , Code
     "typ/compiler/include-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Ident (Identifier "chap2"))
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  heading(body: text(body: [Document]), 
                          level: 1), 
                  text(body: [
 ]), 
                  parbreak(), 
+                 parbreak(), 
                  heading(body: text(body: [Chapter 1]), 
                          level: 2), 
                  text(body: [Klaus]), 
@@ -96,13 +58,14 @@
 considerable time in non-descript environments.]), 
                  parbreak(), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [– ]), 
                  emph(body: text(body: [Intermission])), 
                  text(body: [ –
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  parbreak(), 
                  heading(body: text(body: [Chapter 2]), 
                          level: 2), 
diff --git a/test/typ/compiler/label-00.out b/test/typ/compiler/label-00.out
--- a/test/typ/compiler/label-00.out
+++ b/test/typ/compiler/label-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/label-00.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
-                                 "typ/compiler/label-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/label-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/label-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Set
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compiler/label-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -61,8 +22,9 @@
        (Ident (Identifier "underline")))
 , ParBreak
 , Heading 1 [ Text "Introduction" ]
+, Space
 , Code
-    "typ/compiler/label-00.typ" ( line 6 , column 16 ) (Label "intro")
+    "typ/compiler/label-00.typ" ( line 5 , column 16 ) (Label "intro")
 , SoftBreak
 , Text "The"
 , Space
@@ -70,6 +32,7 @@
 , Text "."
 , ParBreak
 , Heading 1 [ Text "Conclusion" ]
+, SoftBreak
 , Text "The"
 , Space
 , Text "end"
@@ -84,6 +47,7 @@
                  parbreak(), 
                  heading(body: text(body: [Introduction]), 
                          level: 1), 
+                 text(body: [ ]), 
                  <intro>, 
                  text(body: [
 The beginning.]), 
diff --git a/test/typ/compiler/label-01.out b/test/typ/compiler/label-01.out
--- a/test/typ/compiler/label-01.out
+++ b/test/typ/compiler/label-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/label-01.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
-                                 "typ/compiler/label-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/label-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/label-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -55,28 +16,28 @@
 , ParBreak
 , Code
     "typ/compiler/label-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "a")))
        (Block (Content [ Strong [ Text "A" ] ])))
 , SoftBreak
 , Code
     "typ/compiler/label-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "b")))
        (Block (Content [ Strong [ Text "B" ] ])))
 , SoftBreak
 , Code
     "typ/compiler/label-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Ident (Identifier "a"))
 , Space
 , Code
-    "typ/compiler/label-01.typ" ( line 7 , column 4 ) (Label "v")
+    "typ/compiler/label-01.typ" ( line 6 , column 4 ) (Label "v")
 , Code
     "typ/compiler/label-01.typ"
-    ( line 7 , column 9 )
+    ( line 6 , column 9 )
     (Ident (Identifier "b"))
 , ParBreak
 ]
diff --git a/test/typ/compiler/label-03.out b/test/typ/compiler/label-03.out
--- a/test/typ/compiler/label-03.out
+++ b/test/typ/compiler/label-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/label-03.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
-                                 "typ/compiler/label-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/label-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/label-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Label "red"))
        (Set
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compiler/label-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Label "blue"))
        (Set
@@ -63,12 +24,12 @@
 , Strong [ Text "B" ]
 , Space
 , Code
-    "typ/compiler/label-03.typ" ( line 6 , column 9 ) (Label "red")
+    "typ/compiler/label-03.typ" ( line 5 , column 9 ) (Label "red")
 , Strong [ Text "C" ]
 , Space
 , Code
     "typ/compiler/label-03.typ"
-    ( line 6 , column 20 )
+    ( line 5 , column 20 )
     (FuncCall
        (Ident (Identifier "label"))
        [ NormalArg (Plus (Literal (String "bl")) (Literal (String "ue")))
diff --git a/test/typ/compiler/label-04.out b/test/typ/compiler/label-04.out
--- a/test/typ/compiler/label-04.out
+++ b/test/typ/compiler/label-04.out
@@ -1,59 +1,20 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/label-04.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
-                                 "typ/compiler/label-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/label-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/label-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show (Just (Label "hide")) (Literal None))
 , ParBreak
 , Emph [ Text "Hidden" ]
 , SoftBreak
 , Code
-    "typ/compiler/label-04.typ" ( line 6 , column 1 ) (Label "hide")
+    "typ/compiler/label-04.typ" ( line 5 , column 1 ) (Label "hide")
 , ParBreak
 , Emph [ Text "Hidden" ]
 , ParBreak
 , Code
-    "typ/compiler/label-04.typ" ( line 10 , column 1 ) (Label "hide")
+    "typ/compiler/label-04.typ" ( line 9 , column 1 ) (Label "hide")
 , SoftBreak
 , Emph [ Text "Visible" ]
 , ParBreak
diff --git a/test/typ/compiler/label-05.out b/test/typ/compiler/label-05.out
--- a/test/typ/compiler/label-05.out
+++ b/test/typ/compiler/label-05.out
@@ -1,59 +1,20 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/label-05.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
-                                 "typ/compiler/label-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/label-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/label-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show (Just (Label "strike")) (Ident (Identifier "strike")))
 , SoftBreak
 , Strong [ Text "This" , Space , Text "is" ]
 , Space
 , Code
     "typ/compiler/label-05.typ"
-    ( line 4 , column 12 )
+    ( line 3 , column 12 )
     (Block
        (Content
           [ Code
-              "typ/compiler/label-05.typ" ( line 4 , column 13 ) (Label "strike")
+              "typ/compiler/label-05.typ" ( line 3 , column 13 ) (Label "strike")
           ]))
 , Space
 , Strong [ Text "protected" , Text "." ]
@@ -62,7 +23,7 @@
     [ Text "This" , Space , Text "is" , Space , Text "not" , Text "." ]
 , Space
 , Code
-    "typ/compiler/label-05.typ" ( line 5 , column 16 ) (Label "strike")
+    "typ/compiler/label-05.typ" ( line 4 , column 16 ) (Label "strike")
 , ParBreak
 ]
 --- evaluated ---
diff --git a/test/typ/compiler/label-06.out b/test/typ/compiler/label-06.out
--- a/test/typ/compiler/label-06.out
+++ b/test/typ/compiler/label-06.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/label-06.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
-                                 "typ/compiler/label-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/label-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "1"
 , Space
 , Text "<"
@@ -50,7 +11,7 @@
 , Space
 , Code
     "typ/compiler/label-06.typ"
-    ( line 3 , column 11 )
+    ( line 2 , column 11 )
     (If
        [ ( LessThan (Literal (Int 1)) (Literal (Int 2))
          , Block (Content [ Text "not" ])
@@ -65,8 +26,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [1 < 2 is ]), 
+1 < 2 is ]), 
                  text(body: [not]), 
                  text(body: [ a label.]), 
                  parbreak() })
diff --git a/test/typ/compiler/let-00.out b/test/typ/compiler/let-00.out
--- a/test/typ/compiler/let-00.out
+++ b/test/typ/compiler/let-00.out
@@ -1,66 +1,28 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-00.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
-                                 "typ/compiler/let-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/let-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal None))
 , SoftBreak
 , Code
     "typ/compiler/let-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x")) , NormalArg (Literal None) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/let-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Let (BasicBind (Just (Identifier "z"))) (Literal (Int 1)))
 , SoftBreak
 , Code
     "typ/compiler/let-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "z"))
@@ -68,16 +30,17 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/let-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Let
        (BasicBind (Just (Identifier "fill")))
        (Ident (Identifier "green")))
 , SoftBreak
 , Code
     "typ/compiler/let-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "body") ]
@@ -91,7 +54,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall (Ident (Identifier "f")) [ BlockArg [ Text "Hi!" ] ])
 , ParBreak
 ]
@@ -104,8 +67,12 @@
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  text(body: [
diff --git a/test/typ/compiler/let-01.out b/test/typ/compiler/let-01.out
--- a/test/typ/compiler/let-01.out
+++ b/test/typ/compiler/let-01.out
@@ -1,73 +1,36 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-01.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
-                                 "typ/compiler/let-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/let-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let (BasicBind (Just (Identifier "v1"))) (Literal (Int 1)))
 , SoftBreak
 , Text "One"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/let-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Let (BasicBind (Just (Identifier "v2"))) (Literal (Int 2)))
 , Space
 , Text "Two"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/let-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Let (BasicBind (Just (Identifier "v3"))) (Literal (Int 3)))
 , SoftBreak
 , Text "Three"
 , ParBreak
 , Code
     "typ/compiler/let-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "v1"))
@@ -76,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-01.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "v2"))
@@ -85,7 +48,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-01.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "v3"))
@@ -94,15 +57,18 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [
 One]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [ Two]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 Three]), 
                  parbreak(), 
diff --git a/test/typ/compiler/let-02.out b/test/typ/compiler/let-02.out
--- a/test/typ/compiler/let-02.out
+++ b/test/typ/compiler/let-02.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-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
-                                 "typ/compiler/let-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "a")))
        (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
@@ -51,5 +13,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  parbreak() })
diff --git a/test/typ/compiler/let-03.out b/test/typ/compiler/let-03.out
--- a/test/typ/compiler/let-03.out
+++ b/test/typ/compiler/let-03.out
@@ -1,59 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-03.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
-                                 "typ/compiler/let-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a"))
-          , Simple (Just (Identifier "b"))
+          [ Simple (BasicBind (Just (Identifier "a")))
+          , Simple (BasicBind (Just (Identifier "b")))
           ])
        (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "typ/compiler/let-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -62,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -72,6 +34,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-04.out b/test/typ/compiler/let-04.out
--- a/test/typ/compiler/let-04.out
+++ b/test/typ/compiler/let-04.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-04.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
-                                 "typ/compiler/let-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/let-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
-       (DestructuringBind [ Simple (Just (Identifier "a")) ])
+       (DestructuringBind [ Simple (BasicBind (Just (Identifier "a"))) ])
        (Array [ Reg (Literal (Int 1)) ]))
 , SoftBreak
 , Code
     "typ/compiler/let-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
diff --git a/test/typ/compiler/let-05.out b/test/typ/compiler/let-05.out
--- a/test/typ/compiler/let-05.out
+++ b/test/typ/compiler/let-05.out
@@ -1,55 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-05.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
-                                 "typ/compiler/let-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a"))
-          , Simple Nothing
-          , Simple (Just (Identifier "c"))
-          , Simple Nothing
+          [ Simple (BasicBind (Just (Identifier "a")))
+          , Simple (BasicBind Nothing)
+          , Simple (BasicBind (Just (Identifier "c")))
+          , Simple (BasicBind Nothing)
           ])
        (Array
           [ Reg (Literal (Int 1))
@@ -60,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-05.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -69,7 +31,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-05.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c"))
@@ -79,6 +41,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-06.out b/test/typ/compiler/let-06.out
--- a/test/typ/compiler/let-06.out
+++ b/test/typ/compiler/let-06.out
@@ -1,53 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-06.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
-                                 "typ/compiler/let-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-06.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a"))
-          , Simple (Just (Identifier "b"))
+          [ Simple (BasicBind (Just (Identifier "a")))
+          , Simple (BasicBind (Just (Identifier "b")))
           , Sink (Just (Identifier "c"))
           ])
        (Array
@@ -61,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-06.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -70,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-06.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -79,7 +41,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-06.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c"))
@@ -95,6 +57,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-07.out b/test/typ/compiler/let-07.out
--- a/test/typ/compiler/let-07.out
+++ b/test/typ/compiler/let-07.out
@@ -1,54 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-07.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
-                                 "typ/compiler/let-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-07.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a"))
+          [ Simple (BasicBind (Just (Identifier "a")))
           , Sink (Just (Identifier "b"))
-          , Simple (Just (Identifier "c"))
+          , Simple (BasicBind (Just (Identifier "c")))
           ])
        (Array
           [ Reg (Literal (Int 1))
@@ -61,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-07.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -70,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-07.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -85,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-07.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c"))
@@ -95,6 +57,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-08.out b/test/typ/compiler/let-08.out
--- a/test/typ/compiler/let-08.out
+++ b/test/typ/compiler/let-08.out
@@ -1,67 +1,29 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-08.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
-                                 "typ/compiler/let-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-08.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
           [ Sink (Just (Identifier "a"))
-          , Simple (Just (Identifier "b"))
-          , Simple (Just (Identifier "c"))
+          , Simple (BasicBind (Just (Identifier "b")))
+          , Simple (BasicBind (Just (Identifier "c")))
           ])
        (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "typ/compiler/let-08.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a")) , NormalArg (Array []) ])
 , SoftBreak
 , Code
     "typ/compiler/let-08.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -70,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-08.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c"))
@@ -80,6 +42,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-09.out b/test/typ/compiler/let-09.out
--- a/test/typ/compiler/let-09.out
+++ b/test/typ/compiler/let-09.out
@@ -1,60 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-09.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
-                                 "typ/compiler/let-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-09.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a"))
+          [ Simple (BasicBind (Just (Identifier "a")))
           , Sink (Just (Identifier "b"))
-          , Simple (Just (Identifier "c"))
+          , Simple (BasicBind (Just (Identifier "c")))
           ])
        (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "typ/compiler/let-09.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -63,14 +25,14 @@
 , SoftBreak
 , Code
     "typ/compiler/let-09.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b")) , NormalArg (Array []) ])
 , SoftBreak
 , Code
     "typ/compiler/let-09.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c"))
@@ -80,6 +42,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-10.out b/test/typ/compiler/let-10.out
--- a/test/typ/compiler/let-10.out
+++ b/test/typ/compiler/let-10.out
@@ -1,60 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-10.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
-                                 "typ/compiler/let-10.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-10.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-10.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a"))
-          , Simple (Just (Identifier "b"))
+          [ Simple (BasicBind (Just (Identifier "a")))
+          , Simple (BasicBind (Just (Identifier "b")))
           , Sink (Just (Identifier "c"))
           ])
        (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "typ/compiler/let-10.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -63,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-10.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -72,7 +34,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-10.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c")) , NormalArg (Array []) ])
@@ -80,6 +42,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-11.out b/test/typ/compiler/let-11.out
--- a/test/typ/compiler/let-11.out
+++ b/test/typ/compiler/let-11.out
@@ -1,55 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-11.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
-                                 "typ/compiler/let-11.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-11.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-11.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind [ Sink (Just (Identifier "a")) ]) (Array []))
 , SoftBreak
 , Code
     "typ/compiler/let-11.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a")) , NormalArg (Array []) ])
@@ -57,6 +19,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-16.out b/test/typ/compiler/let-16.out
--- a/test/typ/compiler/let-16.out
+++ b/test/typ/compiler/let-16.out
@@ -1,54 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-16.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
-                                 "typ/compiler/let-16.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-16.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-16.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ WithKey (Identifier "a") (Just (Identifier "a"))
-          , Simple (Just (Identifier "b"))
-          , WithKey (Identifier "x") (Just (Identifier "c"))
+          [ WithKey (Identifier "a") (BasicBind (Just (Identifier "a")))
+          , Simple (BasicBind (Just (Identifier "b")))
+          , WithKey (Identifier "x") (BasicBind (Just (Identifier "c")))
           ])
        (Dict
           [ Reg ( Ident (Identifier "a") , Literal (Int 1) )
@@ -58,7 +20,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-16.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -67,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-16.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -76,7 +38,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-16.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "c"))
@@ -86,6 +48,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-17.out b/test/typ/compiler/let-17.out
--- a/test/typ/compiler/let-17.out
+++ b/test/typ/compiler/let-17.out
@@ -1,52 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-17.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
-                                 "typ/compiler/let-17.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-17.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-17.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ WithKey (Identifier "a") Nothing
+          [ WithKey (Identifier "a") (BasicBind Nothing)
           , Sink (Just (Identifier "b"))
           ])
        (Dict
@@ -57,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-17.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -71,6 +33,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-18.out b/test/typ/compiler/let-18.out
--- a/test/typ/compiler/let-18.out
+++ b/test/typ/compiler/let-18.out
@@ -1,54 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-18.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
-                                 "typ/compiler/let-18.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-18.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-18.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ WithKey (Identifier "a") Nothing
+          [ WithKey (Identifier "a") (BasicBind Nothing)
           , Sink (Just (Identifier "b"))
-          , WithKey (Identifier "c") Nothing
+          , WithKey (Identifier "c") (BasicBind Nothing)
           ])
        (Dict
           [ Reg ( Ident (Identifier "a") , Literal (Int 1) )
@@ -58,7 +20,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-18.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
@@ -69,6 +31,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-19.out b/test/typ/compiler/let-19.out
--- a/test/typ/compiler/let-19.out
+++ b/test/typ/compiler/let-19.out
@@ -1,59 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-19.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
-                                 "typ/compiler/let-19.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-19.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-19.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ WithKey (Identifier "a") Nothing
+          [ WithKey (Identifier "a") (BasicBind Nothing)
           , Sink (Just (Identifier "b"))
           ])
        (Dict [ Reg ( Ident (Identifier "a") , Literal (Int 1) ) ]))
 , SoftBreak
 , Code
     "typ/compiler/let-19.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b")) , NormalArg (Dict []) ])
@@ -61,6 +23,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-20.out b/test/typ/compiler/let-20.out
--- a/test/typ/compiler/let-20.out
+++ b/test/typ/compiler/let-20.out
@@ -1,55 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-20.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
-                                 "typ/compiler/let-20.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-20.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-20.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind [ Sink (Just (Identifier "a")) ]) (Dict []))
 , SoftBreak
 , Code
     "typ/compiler/let-20.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a")) , NormalArg (Dict []) ])
@@ -57,6 +19,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/let-21.out b/test/typ/compiler/let-21.out
--- a/test/typ/compiler/let-21.out
+++ b/test/typ/compiler/let-21.out
@@ -1,52 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/let-21.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
-                                 "typ/compiler/let-21.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/let-21.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/let-21.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (DestructuringBind
-          [ Simple (Just (Identifier "a")) , Sink Nothing ])
+          [ Simple (BasicBind (Just (Identifier "a"))) , Sink Nothing ])
        (Dict
           [ Reg ( Ident (Identifier "a") , Literal (Int 1) )
           , Reg ( Ident (Identifier "b") , Literal (Int 2) )
@@ -54,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/let-21.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "a"))
@@ -64,6 +26,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/methods-00.out b/test/typ/compiler/methods-00.out
--- a/test/typ/compiler/methods-00.out
+++ b/test/typ/compiler/methods-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/methods-00.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
-                                 "typ/compiler/methods-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/methods-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/methods-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/methods-01.out b/test/typ/compiler/methods-01.out
--- a/test/typ/compiler/methods-01.out
+++ b/test/typ/compiler/methods-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/methods-01.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
-                                 "typ/compiler/methods-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/methods-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/methods-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/methods-02.out b/test/typ/compiler/methods-02.out
--- a/test/typ/compiler/methods-02.out
+++ b/test/typ/compiler/methods-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/methods-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
-                                 "typ/compiler/methods-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/methods-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/methods-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/module.out b/test/typ/compiler/module.out
--- a/test/typ/compiler/module.out
+++ b/test/typ/compiler/module.out
@@ -1,77 +1,38 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/module.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
-                                 "typ/compiler/module.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/module.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let (BasicBind (Just (Identifier "a"))) (Literal None))
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let (BasicBind (Just (Identifier "b"))) (Literal (Int 1)))
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Let (BasicBind (Just (Identifier "c"))) (Literal (Int 2)))
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Let (BasicBind (Just (Identifier "d"))) (Literal (Int 3)))
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Let
        (BasicBind (Just (Identifier "value")))
        (Block (Content [ Text "hi" ])))
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (LetFunc
        (Identifier "item")
        [ NormalParam (Identifier "a") , NormalParam (Identifier "b") ]
@@ -79,7 +40,7 @@
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (LetFunc
        (Identifier "push")
        [ NormalParam (Identifier "a") ]
@@ -87,7 +48,7 @@
 , SoftBreak
 , Code
     "typ/compiler/module.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Let
        (BasicBind (Just (Identifier "fn")))
        (FuncCall
@@ -108,8 +69,7 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  text(body: [
 ]), 
                  text(body: [
diff --git a/test/typ/compiler/modules/chap1.out b/test/typ/compiler/modules/chap1.out
--- a/test/typ/compiler/modules/chap1.out
+++ b/test/typ/compiler/modules/chap1.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/modules/chap1.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
-                                 "typ/compiler/modules/chap1.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/modules/chap1.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/modules/chap1.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "name"))) (Literal (String "Klaus")))
 , ParBreak
 , Heading 2 [ Text "Chapter" , Space , Text "1" ]
+, SoftBreak
 , Code
     "typ/compiler/modules/chap1.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Ident (Identifier "name"))
 , Space
 , Text "stood"
@@ -86,7 +47,7 @@
 , Space
 , Code
     "typ/compiler/modules/chap1.typ"
-    ( line 8 , column 12 )
+    ( line 7 , column 12 )
     (Ident (Identifier "name"))
 , Space
 , Text "just"
@@ -156,10 +117,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  heading(body: text(body: [Chapter 1]), 
                          level: 2), 
diff --git a/test/typ/compiler/modules/chap2.out b/test/typ/compiler/modules/chap2.out
--- a/test/typ/compiler/modules/chap2.out
+++ b/test/typ/compiler/modules/chap2.out
@@ -1,53 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/modules/chap2.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
-                                 "typ/compiler/modules/chap2.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/modules/chap2.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/modules/chap2.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "name"))) (Literal (String "Klaus")))
 , ParBreak
 , Heading 2 [ Text "Chapter" , Space , Text "2" ]
+, SoftBreak
 , Text "Their"
 , Space
 , Text "motivations,"
@@ -69,7 +30,7 @@
 , Space
 , Code
     "typ/compiler/modules/chap2.typ"
-    ( line 7 , column 65 )
+    ( line 6 , column 65 )
     (Ident (Identifier "name"))
 , Space
 , Text "had"
@@ -99,7 +60,7 @@
 , Space
 , Code
     "typ/compiler/modules/chap2.typ"
-    ( line 8 , column 76 )
+    ( line 7 , column 76 )
     (Ident (Identifier "name"))
 , SoftBreak
 , Text "approached"
@@ -161,7 +122,7 @@
 , Space
 , Code
     "typ/compiler/modules/chap2.typ"
-    ( line 10 , column 57 )
+    ( line 9 , column 57 )
     (Ident (Identifier "name"))
 , Quote '\''
 , Space
@@ -216,10 +177,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  heading(body: text(body: [Chapter 2]), 
                          level: 2), 
diff --git a/test/typ/compiler/ops-00.out b/test/typ/compiler/ops-00.out
--- a/test/typ/compiler/ops-00.out
+++ b/test/typ/compiler/ops-00.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-00.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
-                                 "typ/compiler/ops-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Plus
        (Block (Content [ Strong [ Text "Hello" ] , Space ]))
        (Block (Content [ Text "world!" ])))
@@ -51,6 +13,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  strong(body: text(body: [Hello])), 
                  text(body: [ ]), 
diff --git a/test/typ/compiler/ops-01.out b/test/typ/compiler/ops-01.out
--- a/test/typ/compiler/ops-01.out
+++ b/test/typ/compiler/ops-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-01.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
-                                 "typ/compiler/ops-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (For
        (BasicBind (Just (Identifier "v")))
        (Array
@@ -84,7 +45,7 @@
 , ParBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Negated (Plus (Literal (Int 4)) (Literal (Int 2))))
@@ -92,9 +53,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Plus (Literal (Int 2)) (Literal (Int 4)))
@@ -103,7 +65,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Plus (Literal (String "a")) (Literal (String "b")))
@@ -112,7 +74,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -128,7 +90,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -144,7 +106,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -156,7 +118,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -174,7 +136,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-01.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -194,8 +156,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
@@ -229,6 +190,8 @@
                  parbreak(), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/ops-03.out b/test/typ/compiler/ops-03.out
--- a/test/typ/compiler/ops-03.out
+++ b/test/typ/compiler/ops-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-03.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
-                                 "typ/compiler/ops-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Minus (Literal (Int 1)) (Literal (Int 4)))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -61,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -70,9 +31,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Times (Literal (Int 2)) (Literal (Int 4)))
@@ -80,9 +42,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -92,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Divided (Literal (Int 7)) (Literal (Int 2)))
@@ -100,9 +63,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -115,7 +79,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -142,9 +106,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -159,9 +124,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (Let
        (BasicBind (Just (Identifier "nums")))
        (Array
@@ -183,7 +149,7 @@
 , ParBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 33 , column 2 )
+    ( line 32 , column 2 )
     (For
        (BasicBind (Just (Identifier "v")))
        (Ident (Identifier "nums"))
@@ -269,12 +235,16 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 56 , column 2 )
+    ( line 55 , column 2 )
     (Let
        (BasicBind (Just (Identifier "dims")))
        (Array
@@ -292,7 +262,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 57 , column 2 )
+    ( line 56 , column 2 )
     (For
        (BasicBind (Just (Identifier "a")))
        (Ident (Identifier "dims"))
@@ -367,9 +337,10 @@
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-03.typ"
-    ( line 70 , column 2 )
+    ( line 69 , column 2 )
     (For
        (BasicBind (Just (Identifier "a")))
        (Array
@@ -431,20 +402,30 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [✅]), 
                  text(body: [✅]), 
@@ -570,6 +551,14 @@
                  parbreak(), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
@@ -643,6 +632,8 @@
                  text(body: [✅]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
                  text(body: [✅]), 
diff --git a/test/typ/compiler/ops-04.out b/test/typ/compiler/ops-04.out
--- a/test/typ/compiler/ops-04.out
+++ b/test/typ/compiler/ops-04.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-04.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
-                                 "typ/compiler/ops-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Literal (Int 16)) , NormalArg (Literal (Int 16)) ])
 , SoftBreak
 , Code
     "typ/compiler/ops-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Literal (Int 13)) , NormalArg (Literal (Int 13)) ])
 , SoftBreak
 , Code
     "typ/compiler/ops-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Plus (Literal (Int 10)) (Literal (Int 10)))
diff --git a/test/typ/compiler/ops-07.out b/test/typ/compiler/ops-07.out
--- a/test/typ/compiler/ops-07.out
+++ b/test/typ/compiler/ops-07.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-07.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
-                                 "typ/compiler/ops-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Not (Literal (Boolean True)))
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Not (Literal (Boolean False)))
@@ -61,9 +22,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -73,7 +35,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -83,7 +45,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -93,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (And (Literal (Boolean True)) (Literal (Boolean True)))
@@ -101,9 +63,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -113,7 +76,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Or (Literal (Boolean False)) (Literal (Boolean True)))
@@ -122,7 +85,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Or (Literal (Boolean True)) (Literal (Boolean False)))
@@ -131,7 +94,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Or (Literal (Boolean True)) (Literal (Boolean True)))
@@ -139,9 +102,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -151,7 +115,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-07.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -161,8 +125,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
@@ -170,6 +133,8 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
@@ -181,6 +146,8 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
@@ -192,6 +159,8 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/ops-08.out b/test/typ/compiler/ops-08.out
--- a/test/typ/compiler/ops-08.out
+++ b/test/typ/compiler/ops-08.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-08.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
-                                 "typ/compiler/ops-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Equals (Literal (Int 1)) (Literal (String "hi")))
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Equals (Literal (Int 1)) (Literal (Float 1.0)))
@@ -62,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -74,7 +35,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -86,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -98,7 +59,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -110,7 +71,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Equals (Array []) (Array [ Reg (Literal (Int 1)) ]))
@@ -119,7 +80,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -137,7 +98,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -149,7 +110,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -170,7 +131,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -179,9 +140,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -191,7 +153,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -202,15 +164,16 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (Let
        (BasicBind (Just (Identifier "t"))) (Block (Content [ Text "a" ])))
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -220,7 +183,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Equals (Block (Content [])) (Block (Content [])))
@@ -229,7 +192,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -240,7 +203,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -252,7 +215,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-08.typ"
-    ( line 27 , column 2 )
+    ( line 26 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -264,8 +227,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
@@ -300,6 +262,8 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [❌(]), 
                  text(body: [false]), 
                  text(body: [ /= ]), 
@@ -309,6 +273,8 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compiler/ops-09.out b/test/typ/compiler/ops-09.out
--- a/test/typ/compiler/ops-09.out
+++ b/test/typ/compiler/ops-09.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-09.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
-                                 "typ/compiler/ops-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (LessThan (Literal (Int 5)) (Literal (Int 10)))
@@ -64,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (GreaterThan (Literal (Int 5)) (Literal (Int 5)))
@@ -73,7 +33,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (LessThanOrEqual (Literal (Int 5)) (Literal (Int 5)))
@@ -82,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (LessThanOrEqual (Literal (Int 5)) (Literal (Int 4)))
@@ -91,7 +51,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -101,7 +61,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -112,7 +72,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -124,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -136,7 +96,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-09.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -146,10 +106,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/ops-10.out b/test/typ/compiler/ops-10.out
--- a/test/typ/compiler/ops-10.out
+++ b/test/typ/compiler/ops-10.out
@@ -1,59 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-10.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
-                                 "typ/compiler/ops-10.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-10.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal (Int 0)))
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Assign (Ident (Identifier "x")) (Literal (Int 10)))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 5 , column 18 )
+    ( line 4 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -62,14 +22,14 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Assign
        (Ident (Identifier "x"))
        (Minus (Ident (Identifier "x")) (Literal (Int 5))))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 6 , column 18 )
+    ( line 5 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -78,14 +38,14 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Assign
        (Ident (Identifier "x"))
        (Plus (Ident (Identifier "x")) (Literal (Int 1))))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 7 , column 18 )
+    ( line 6 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -94,14 +54,14 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Assign
        (Ident (Identifier "x"))
        (Times (Ident (Identifier "x")) (Ident (Identifier "x"))))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 8 , column 18 )
+    ( line 7 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -110,14 +70,14 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Assign
        (Ident (Identifier "x"))
        (Divided (Ident (Identifier "x")) (Literal (Float 2.0))))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 9 , column 18 )
+    ( line 8 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -126,12 +86,12 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Assign (Ident (Identifier "x")) (Literal (String "some")))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 10 , column 18 )
+    ( line 9 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -140,14 +100,14 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Assign
        (Ident (Identifier "x"))
        (Plus (Ident (Identifier "x")) (Literal (String "thing"))))
 , Space
 , Code
     "typ/compiler/ops-10.typ"
-    ( line 11 , column 18 )
+    ( line 10 , column 18 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -156,10 +116,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [ ]), 
diff --git a/test/typ/compiler/ops-11.out b/test/typ/compiler/ops-11.out
--- a/test/typ/compiler/ops-11.out
+++ b/test/typ/compiler/ops-11.out
@@ -1,3 +1,409 @@
-"typ/compiler/ops-11.typ" (line 19, column 5):
-unexpected ":"
-expecting "//", "/*", operator or ")"
+--- parse tree ---
+[ Comment
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 3 , column 2 )
+    (Let (BasicBind (Just (Identifier "a"))) (Literal None))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 4 , column 2 )
+    (Let (BasicBind (Just (Identifier "b"))) (Literal None))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 5 , column 2 )
+    (Let (BasicBind (Just (Identifier "c"))) (Literal None))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 6 , column 2 )
+    (Assign
+       (Array [ Reg (Ident (Identifier "a")) ])
+       (Array [ Reg (Literal (Int 1)) ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 7 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg (Literal (Int 1))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 9 , column 2 )
+    (Assign
+       (Array
+          [ Reg Underscore
+          , Reg (Ident (Identifier "a"))
+          , Reg (Ident (Identifier "b"))
+          , Reg Underscore
+          ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          , Reg (Literal (Int 4))
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 10 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg (Literal (Int 2))
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 11 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg (Literal (Int 3))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 13 , column 2 )
+    (Assign
+       (Array
+          [ Reg (Ident (Identifier "a"))
+          , Reg (Ident (Identifier "b"))
+          , Spr (Ident (Identifier "c"))
+          ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          , Reg (Literal (Int 4))
+          , Reg (Literal (Int 5))
+          , Reg (Literal (Int 6))
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 14 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg (Literal (Int 1))
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 15 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg (Literal (Int 2))
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 16 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "c"))
+       , NormalArg
+           (Array
+              [ Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
+              , Reg (Literal (Int 5))
+              , Reg (Literal (Int 6))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 18 , column 2 )
+    (Assign
+       (Binding
+          (DestructuringBind
+             [ WithKey (Identifier "a") (BasicBind (Just (Identifier "a")))
+             , Simple (BasicBind (Just (Identifier "b")))
+             , WithKey (Identifier "x") (BasicBind (Just (Identifier "c")))
+             ]))
+       (Dict
+          [ Reg ( Ident (Identifier "a") , Literal (Int 1) )
+          , Reg ( Ident (Identifier "b") , Literal (Int 2) )
+          , Reg ( Ident (Identifier "x") , Literal (Int 3) )
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 19 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg (Literal (Int 1))
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 20 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg (Literal (Int 2))
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 21 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "c"))
+       , NormalArg (Literal (Int 3))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 23 , column 2 )
+    (Let
+       (BasicBind (Just (Identifier "a")))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 24 , column 2 )
+    (Assign
+       (Binding
+          (DestructuringBind
+             [ WithKey
+                 (Identifier "a")
+                 (ExprBind
+                    (FuncCall
+                       (FieldAccess (Ident (Identifier "at")) (Ident (Identifier "a")))
+                       [ NormalArg (Literal (Int 0)) ]))
+             , Simple (BasicBind (Just (Identifier "b")))
+             ]))
+       (Dict
+          [ Reg ( Ident (Identifier "a") , Literal (Int 3) )
+          , Reg ( Ident (Identifier "b") , Literal (Int 4) )
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 25 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg
+           (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 2)) ])
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 26 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg (Literal (Int 4))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 28 , column 2 )
+    (Let
+       (BasicBind (Just (Identifier "a")))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 29 , column 2 )
+    (Assign
+       (Array
+          [ Reg
+              (FuncCall
+                 (FieldAccess (Ident (Identifier "at")) (Ident (Identifier "a")))
+                 [ NormalArg (Literal (Int 0)) ])
+          , Reg (Ident (Identifier "b"))
+          ])
+       (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 30 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg
+           (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 2)) ])
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 31 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg (Literal (Int 4))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 33 , column 2 )
+    (Assign
+       (Array
+          [ Reg (Ident (Identifier "a")) , Spr (Ident (Identifier "b")) ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          , Reg (Literal (Int 4))
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 34 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg (Literal (Int 1))
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 35 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg
+           (Array
+              [ Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 37 , column 2 )
+    (Let
+       (BasicBind (Just (Identifier "a")))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 38 , column 2 )
+    (Assign
+       (Array
+          [ Reg (Ident (Identifier "b"))
+          , Spr
+              (FuncCall
+                 (FieldAccess (Ident (Identifier "at")) (Ident (Identifier "a")))
+                 [ NormalArg (Literal (Int 0)) ])
+          ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          , Reg (Literal (Int 4))
+          ]))
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 39 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "a"))
+       , NormalArg
+           (Array
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Int 2))
+                     , Reg (Literal (Int 3))
+                     , Reg (Literal (Int 4))
+                     ])
+              , Reg (Literal (Int 2))
+              ])
+       ])
+, SoftBreak
+, Code
+    "typ/compiler/ops-11.typ"
+    ( line 40 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (Ident (Identifier "b"))
+       , NormalArg (Literal (Int 1))
+       ])
+, ParBreak
+]
+--- evaluated ---
+document(body: { parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [
+]), 
+                 text(body: [✅]), 
+                 parbreak() })
diff --git a/test/typ/compiler/ops-13.out b/test/typ/compiler/ops-13.out
--- a/test/typ/compiler/ops-13.out
+++ b/test/typ/compiler/ops-13.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-13.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
-                                 "typ/compiler/ops-13.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-13.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -79,7 +40,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -90,7 +51,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -103,7 +64,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -116,7 +77,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (InCollection (Literal (String "")) (Array []))
@@ -125,7 +86,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -138,7 +99,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -151,7 +112,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -163,7 +124,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-13.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/ops-15.out b/test/typ/compiler/ops-15.out
--- a/test/typ/compiler/ops-15.out
+++ b/test/typ/compiler/ops-15.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-15.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
-                                 "typ/compiler/ops-15.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-15.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (LetFunc
        (Identifier "add")
        [ NormalParam (Identifier "x") , NormalParam (Identifier "y") ]
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -67,7 +28,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -86,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -101,7 +62,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -119,9 +80,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (LetFunc
        (Identifier "inc")
        [ NormalParam (Identifier "x")
@@ -131,7 +93,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -142,7 +104,7 @@
 , ParBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (Let
        (BasicBind (Just (Identifier "inc2")))
        (FuncCall
@@ -152,7 +114,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -163,7 +125,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-15.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -177,8 +139,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [
@@ -194,6 +155,8 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compiler/ops-16.out b/test/typ/compiler/ops-16.out
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/ops-16.out
@@ -0,0 +1,459 @@
+--- parse tree ---
+[ Comment
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 3 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "a"))) (Literal (Int 1))
+                 , Let (BasicBind (Just (Identifier "b"))) (Literal (Int 2))
+                 , Assign
+                     (Array
+                        [ Reg (Ident (Identifier "a")) , Reg (Ident (Identifier "b")) ])
+                     (Array
+                        [ Reg (Ident (Identifier "b")) , Reg (Ident (Identifier "a")) ])
+                 , Array
+                     [ Reg (Ident (Identifier "a")) , Reg (Ident (Identifier "b")) ]
+                 ]))
+       , NormalArg
+           (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 1)) ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 12 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "a"))) (Literal (Int 1))
+                 , Let (BasicBind (Just (Identifier "b"))) (Literal (Int 2))
+                 , Assign
+                     (Array [ Reg (Ident (Identifier "a")) , Reg Underscore ])
+                     (Array
+                        [ Reg (Ident (Identifier "b")) , Reg (Ident (Identifier "a")) ])
+                 , Array
+                     [ Reg (Ident (Identifier "a")) , Reg (Ident (Identifier "b")) ]
+                 ]))
+       , NormalArg
+           (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 2)) ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 21 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "a"))) (Literal (Int 0))
+                 , Let (BasicBind (Just (Identifier "b"))) (Literal (Int 0))
+                 , Assign
+                     (Array
+                        [ Reg Underscore
+                        , Reg (Array [ Reg Underscore , Reg (Ident (Identifier "a")) ])
+                        , Reg (Ident (Identifier "b"))
+                        ])
+                     (Array
+                        [ Reg (Literal (Int 1))
+                        , Reg (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 3)) ])
+                        , Reg (Literal (Int 4))
+                        ])
+                 , Array
+                     [ Reg (Ident (Identifier "a")) , Reg (Ident (Identifier "b")) ]
+                 ]))
+       , NormalArg
+           (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 32 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 0))
+                 , Let (BasicBind (Just (Identifier "y"))) (Literal (Int 0))
+                 , Let (BasicBind (Just (Identifier "z"))) (Literal (Int 0))
+                 , Assign
+                     (Dict
+                        [ Reg
+                            ( Ident (Identifier "x")
+                            , Array
+                                [ Reg (Ident (Identifier "y"))
+                                , Reg
+                                    (Binding
+                                       (DestructuringBind
+                                          [ Simple (BasicBind (Just (Identifier "x")))
+                                          , WithKey
+                                              (Identifier "z")
+                                              (DestructuringBind
+                                                 [ Simple (BasicBind Nothing)
+                                                 , Simple (BasicBind (Just (Identifier "z")))
+                                                 ])
+                                          ]))
+                                ]
+                            )
+                        ])
+                     (Dict
+                        [ Reg ( Ident (Identifier "z") , Literal (Int 1) )
+                        , Reg
+                            ( Ident (Identifier "x")
+                            , Array
+                                [ Reg (Literal (Int 10))
+                                , Reg
+                                    (Dict
+                                       [ Reg ( Ident (Identifier "x") , Literal (Int 100) )
+                                       , Reg ( Ident (Identifier "y") , Literal (Int 200) )
+                                       , Reg
+                                           ( Ident (Identifier "z")
+                                           , Array
+                                               [ Reg (Literal (Int 1000))
+                                               , Reg (Literal (Int 2000))
+                                               ]
+                                           )
+                                       ])
+                                ]
+                            )
+                        ])
+                 , Array
+                     [ Reg (Ident (Identifier "x"))
+                     , Reg (Ident (Identifier "y"))
+                     , Reg (Ident (Identifier "z"))
+                     ]
+                 ]))
+       , NormalArg
+           (Array
+              [ Reg (Literal (Int 100))
+              , Reg (Literal (Int 10))
+              , Reg (Literal (Int 2000))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 43 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let
+                     (BasicBind (Just (Identifier "a")))
+                     (Array
+                        [ Reg (Literal (Int 1))
+                        , Reg (Literal (Int 2))
+                        , Reg (Literal (Int 3))
+                        ])
+                 , Assign
+                     (Dict
+                        [ Reg
+                            ( Ident (Identifier "x")
+                            , Array
+                                [ Reg
+                                    (FuncCall
+                                       (FieldAccess
+                                          (Ident (Identifier "first")) (Ident (Identifier "a")))
+                                       [])
+                                , Reg
+                                    (Dict
+                                       [ Reg
+                                           ( Ident (Identifier "x")
+                                           , FuncCall
+                                               (FieldAccess
+                                                  (Ident (Identifier "at"))
+                                                  (Ident (Identifier "a")))
+                                               [ NormalArg (Literal (Int 1)) ]
+                                           )
+                                       , Reg
+                                           ( Ident (Identifier "z")
+                                           , Array
+                                               [ Reg Underscore
+                                               , Reg
+                                                   (FuncCall
+                                                      (FieldAccess
+                                                         (Ident (Identifier "last"))
+                                                         (Ident (Identifier "a")))
+                                                      [])
+                                               ]
+                                           )
+                                       ])
+                                ]
+                            )
+                        ])
+                     (Dict
+                        [ Reg ( Ident (Identifier "z") , Literal (Int 1) )
+                        , Reg
+                            ( Ident (Identifier "x")
+                            , Array
+                                [ Reg (Literal (Int 10))
+                                , Reg
+                                    (Dict
+                                       [ Reg ( Ident (Identifier "x") , Literal (Int 100) )
+                                       , Reg ( Ident (Identifier "y") , Literal (Int 200) )
+                                       , Reg
+                                           ( Ident (Identifier "z")
+                                           , Array
+                                               [ Reg (Literal (Int 1000))
+                                               , Reg (Literal (Int 2000))
+                                               ]
+                                           )
+                                       ])
+                                ]
+                            )
+                        ])
+                 , Ident (Identifier "a")
+                 ]))
+       , NormalArg
+           (Array
+              [ Reg (Literal (Int 10))
+              , Reg (Literal (Int 100))
+              , Reg (Literal (Int 2000))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 52 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let
+                     (BasicBind (Just (Identifier "d")))
+                     (Dict
+                        [ Reg ( Ident (Identifier "x") , Literal (Int 1) )
+                        , Reg ( Ident (Identifier "y") , Literal (Int 2) )
+                        , Reg ( Ident (Identifier "z") , Literal (Int 3) )
+                        ])
+                 , Assign
+                     (Dict
+                        [ Reg
+                            ( Ident (Identifier "x")
+                            , Array
+                                [ Reg
+                                    (FieldAccess (Ident (Identifier "x")) (Ident (Identifier "d")))
+                                , Reg
+                                    (Dict
+                                       [ Reg
+                                           ( Ident (Identifier "x")
+                                           , FieldAccess
+                                               (Ident (Identifier "y")) (Ident (Identifier "d"))
+                                           )
+                                       , Reg
+                                           ( Ident (Identifier "z")
+                                           , Array
+                                               [ Reg Underscore
+                                               , Reg
+                                                   (FieldAccess
+                                                      (Ident (Identifier "z"))
+                                                      (Ident (Identifier "d")))
+                                               ]
+                                           )
+                                       ])
+                                ]
+                            )
+                        ])
+                     (Dict
+                        [ Reg ( Ident (Identifier "z") , Literal (Int 1) )
+                        , Reg
+                            ( Ident (Identifier "x")
+                            , Array
+                                [ Reg (Literal (Int 10))
+                                , Reg
+                                    (Dict
+                                       [ Reg ( Ident (Identifier "x") , Literal (Int 100) )
+                                       , Reg ( Ident (Identifier "y") , Literal (Int 200) )
+                                       , Reg
+                                           ( Ident (Identifier "z")
+                                           , Array
+                                               [ Reg (Literal (Int 1000))
+                                               , Reg (Literal (Int 2000))
+                                               ]
+                                           )
+                                       ])
+                                ]
+                            )
+                        ])
+                 , Ident (Identifier "d")
+                 ]))
+       , NormalArg
+           (Dict
+              [ Reg ( Ident (Identifier "x") , Literal (Int 10) )
+              , Reg ( Ident (Identifier "y") , Literal (Int 100) )
+              , Reg ( Ident (Identifier "z") , Literal (Int 2000) )
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 61 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let
+                     (BasicBind (Just (Identifier "d")))
+                     (Dict
+                        [ Reg ( Ident (Identifier "x") , Literal (Int 1) )
+                        , Reg
+                            ( Ident (Identifier "y")
+                            , Array
+                                [ Reg (Negated (Literal (Int 1)))
+                                , Reg (Negated (Literal (Int 2)))
+                                ]
+                            )
+                        ])
+                 , Let (BasicBind (Just (Identifier "i"))) (Literal (Int 1))
+                 , Assign
+                     (Array
+                        [ Spr
+                            (FieldAccess (Ident (Identifier "x")) (Ident (Identifier "d")))
+                        , Reg
+                            (Array
+                               [ Reg Underscore
+                               , Reg
+                                   (Array
+                                      [ Reg Underscore
+                                      , Reg
+                                          (FuncCall
+                                             (FieldAccess
+                                                (Ident (Identifier "at"))
+                                                (FieldAccess
+                                                   (Ident (Identifier "y"))
+                                                   (Ident (Identifier "d"))))
+                                             [ NormalArg (Ident (Identifier "i")) ])
+                                      ])
+                               , Reg Underscore
+                               ])
+                        ])
+                     (Array
+                        [ Reg (Literal (Int 0))
+                        , Reg (Literal (Int 1))
+                        , Reg
+                            (Array
+                               [ Reg (Literal (Int 2))
+                               , Reg (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ])
+                               , Reg (Literal (Int 5))
+                               ])
+                        ])
+                 , Ident (Identifier "d")
+                 ]))
+       , NormalArg
+           (Dict
+              [ Reg
+                  ( Ident (Identifier "x")
+                  , Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 1)) ]
+                  )
+              , Reg
+                  ( Ident (Identifier "y")
+                  , Array [ Reg (Negated (Literal (Int 1))) , Reg (Literal (Int 4)) ]
+                  )
+              ])
+       ])
+, ParBreak
+, Comment
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 72 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 0))
+                 , Assign
+                     (Array
+                        [ Reg (Ident (Identifier "x")) , Reg (Ident (Identifier "x")) ])
+                     (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
+                 , Ident (Identifier "x")
+                 ]))
+       , NormalArg (Literal (Int 2))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 78 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 0))
+                 , Assign
+                     (Binding
+                        (DestructuringBind
+                           [ Sink Nothing
+                           , Simple (BasicBind (Just (Identifier "x")))
+                           , Simple (BasicBind (Just (Identifier "x")))
+                           ]))
+                     (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
+                 , Ident (Identifier "x")
+                 ]))
+       , NormalArg (Literal (Int 2))
+       ])
+, ParBreak
+, Code
+    "typ/compiler/ops-16.typ"
+    ( line 84 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg
+           (Block
+              (CodeBlock
+                 [ Let (BasicBind (Just (Identifier "x"))) (Literal (Int 0))
+                 , Assign
+                     (Array
+                        [ Reg (Ident (Identifier "x"))
+                        , Spr (Ident (Identifier "x"))
+                        , Reg (Ident (Identifier "x"))
+                        ])
+                     (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
+                 , Ident (Identifier "x")
+                 ]))
+       , NormalArg (Literal (Int 2))
+       ])
+, ParBreak
+]
+--- evaluated ---
+document(body: { parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [❌(]), 
+                 text(body: [1]), 
+                 text(body: [ /= ]), 
+                 text(body: [2]), 
+                 text(body: [)]), 
+                 parbreak(), 
+                 text(body: [❌(]), 
+                 text(body: [()]), 
+                 text(body: [ /= ]), 
+                 text(body: [2]), 
+                 text(body: [)]), 
+                 parbreak() })
diff --git a/test/typ/compiler/ops-16.typ b/test/typ/compiler/ops-16.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/compiler/ops-16.typ
@@ -0,0 +1,89 @@
+// assignments with nested destructuring bind
+
+#test({
+    let a = 1
+    let b = 2
+    (a, b) = (b, a)
+    (a, b)
+  },
+  (2, 1)
+)
+
+#test({
+    let a = 1
+    let b = 2
+    (a, _) = (b, a)
+    (a, b)
+  },
+  (2, 2)
+)
+
+#test({
+  let a = 0
+  let b = 0
+
+  (_, (_, a), b) = (1, (2, 3), 4)
+
+  (a, b)
+},
+(3, 4)
+)
+
+#test({
+    let x = 0
+    let y = 0
+    let z = 0
+    (x: (y, (x, z: (_, z)))) = (z: 1, x: (10, (x: 100, y: 200, z: (1000, 2000))))
+
+    (x, y, z)
+  },
+  (100, 10, 2000)
+)
+
+#test({
+    let a = (1, 2, 3)
+    (x: (a.first(), (x: a.at(1), z: (_, a.last())))) = (z: 1, x: (10, (x: 100, y: 200, z: (1000, 2000))))
+
+    a
+  },
+  (10, 100, 2000)
+)
+
+#test({
+    let d = (x: 1, y: 2, z: 3)
+    (x: (d.x, (x: d.y, z: (_, d.z)))) = (z: 1, x: (10, (x: 100, y: 200, z: (1000, 2000))))
+
+    d
+  },
+  (x: 10, y: 100, z: 2000)
+)
+
+#test({
+  let d = (x: 1, y: (-1, -2))
+  let i = 1
+
+  (..d.x, (_, (_, d.y.at(i)),_)) = (0, 1, (2, (3, 4), 5))
+  
+  d
+},(x: (0, 1), y: (-1, 4)))
+
+// assignment order: left to right
+
+#test({
+  let x = 0
+  (x, x) = (1, 2)
+  x
+}, 2)
+
+#test({
+  let x = 0
+  (.., x, x) = (1, 2)
+  x
+}, 2)
+
+#test({
+  let x = 0
+  (x, ..x, x) = (1, 2)
+  x
+}, 2)
+
diff --git a/test/typ/compiler/ops-assoc-00.out b/test/typ/compiler/ops-assoc-00.out
--- a/test/typ/compiler/ops-assoc-00.out
+++ b/test/typ/compiler/ops-assoc-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-assoc-00.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
-                                 "typ/compiler/ops-assoc-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-assoc-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-assoc-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -56,7 +17,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-assoc-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -70,7 +31,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-assoc-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/ops-assoc-01.out b/test/typ/compiler/ops-assoc-01.out
--- a/test/typ/compiler/ops-assoc-01.out
+++ b/test/typ/compiler/ops-assoc-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-assoc-01.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
-                                 "typ/compiler/ops-assoc-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-assoc-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "{"
 , SoftBreak
 , Text "let"
@@ -90,8 +51,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [{
+{
 let x = 1
 let y = 2
 x = y = “ok”
diff --git a/test/typ/compiler/ops-invalid-29.out b/test/typ/compiler/ops-invalid-29.out
--- a/test/typ/compiler/ops-invalid-29.out
+++ b/test/typ/compiler/ops-invalid-29.out
@@ -1,59 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-invalid-29.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
-                                 "typ/compiler/ops-invalid-29.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-invalid-29.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-invalid-29.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let (BasicBind (Just (Identifier "rect"))) (Literal (String "")))
 , SoftBreak
 , Code
     "typ/compiler/ops-invalid-29.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Assign (Ident (Identifier "rect")) (Literal (String "hi")))
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/ops-prec-00.out b/test/typ/compiler/ops-prec-00.out
--- a/test/typ/compiler/ops-prec-00.out
+++ b/test/typ/compiler/ops-prec-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-prec-00.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
-                                 "typ/compiler/ops-prec-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-prec-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-prec-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,9 +14,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-prec-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -65,9 +27,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/ops-prec-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -79,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compiler/ops-prec-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -93,8 +56,12 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/ops-prec-03.out b/test/typ/compiler/ops-prec-03.out
--- a/test/typ/compiler/ops-prec-03.out
+++ b/test/typ/compiler/ops-prec-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/ops-prec-03.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
-                                 "typ/compiler/ops-prec-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/ops-prec-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/ops-prec-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/recursion-00.out b/test/typ/compiler/recursion-00.out
--- a/test/typ/compiler/recursion-00.out
+++ b/test/typ/compiler/recursion-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/recursion-00.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
-                                 "typ/compiler/recursion-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/recursion-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/recursion-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "fib")
        [ NormalParam (Identifier "n") ]
@@ -69,7 +30,7 @@
 , ParBreak
 , Code
     "typ/compiler/recursion-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/recursion-02.out b/test/typ/compiler/recursion-02.out
--- a/test/typ/compiler/recursion-02.out
+++ b/test/typ/compiler/recursion-02.out
@@ -1,58 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/recursion-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
-                                 "typ/compiler/recursion-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/recursion-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/recursion-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "f"))) (Literal (Int 10)))
 , SoftBreak
 , Code
     "typ/compiler/recursion-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (LetFunc (Identifier "f") [] (Ident (Identifier "f")))
 , SoftBreak
 , Code
     "typ/compiler/recursion-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/recursion-03.out b/test/typ/compiler/recursion-03.out
--- a/test/typ/compiler/recursion-03.out
+++ b/test/typ/compiler/recursion-03.out
@@ -1,60 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/recursion-03.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
-                                 "typ/compiler/recursion-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/recursion-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/recursion-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "f"))) (Literal (Int 10)))
 , SoftBreak
 , Code
     "typ/compiler/recursion-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "f")))
        (FuncExpr [] (Ident (Identifier "f"))))
 , SoftBreak
 , Code
     "typ/compiler/recursion-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/recursion-05.out b/test/typ/compiler/recursion-05.out
--- a/test/typ/compiler/recursion-05.out
+++ b/test/typ/compiler/recursion-05.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/recursion-05.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
-                                 "typ/compiler/recursion-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/recursion-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/recursion-05.typ"
-    ( line 2 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "x") ]
@@ -49,7 +9,7 @@
 , SoftBreak
 , Code
     "typ/compiler/recursion-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "x") ]
@@ -66,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compiler/recursion-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -77,8 +37,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/repr-00.out b/test/typ/compiler/repr-00.out
--- a/test/typ/compiler/repr-00.out
+++ b/test/typ/compiler/repr-00.out
@@ -1,51 +1,12 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/repr-00.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
-                                 "typ/compiler/repr-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/repr-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
-    "typ/compiler/repr-00.typ" ( line 3 , column 2 ) (Literal Auto)
+    "typ/compiler/repr-00.typ" ( line 2 , column 2 ) (Literal Auto)
 , Space
 , HardBreak
 , Code
-    "typ/compiler/repr-00.typ" ( line 4 , column 2 ) (Literal None)
+    "typ/compiler/repr-00.typ" ( line 3 , column 2 ) (Literal None)
 , Space
 , Text "("
 , Text "empty)"
@@ -53,13 +14,13 @@
 , HardBreak
 , Code
     "typ/compiler/repr-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Literal (Boolean True))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Literal (Boolean False))
 , ParBreak
 ]
diff --git a/test/typ/compiler/repr-01.out b/test/typ/compiler/repr-01.out
--- a/test/typ/compiler/repr-01.out
+++ b/test/typ/compiler/repr-01.out
@@ -1,117 +1,78 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/repr-01.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
-                                 "typ/compiler/repr-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/repr-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
-    "typ/compiler/repr-01.typ" ( line 3 , column 2 ) (Literal (Int 1))
+    "typ/compiler/repr-01.typ" ( line 2 , column 2 ) (Literal (Int 1))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Literal (Float 1.0e-4))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Literal (Float 3.15))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Literal (Float 1.0e-10))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Literal (Numeric 50.368 Percent))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Literal (Numeric 1.2345e-6 Pt))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Literal (Numeric 4.5 Cm))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Literal (Numeric 120.0 Pt))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Literal (Numeric 2.5 Rad))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Literal (Numeric 45.0 Deg))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Literal (Numeric 1.7 Em))
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (Plus (Literal (Numeric 1.0 Cm)) (Literal (Numeric 0.0 Em)))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (Plus (Literal (Numeric 2.0 Em)) (Literal (Numeric 10.0 Pt)))
 , Space
 , HardBreak
 , Code
     "typ/compiler/repr-01.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (Literal (Numeric 2.3 Fr))
 , ParBreak
 ]
diff --git a/test/typ/compiler/repr-02.out b/test/typ/compiler/repr-02.out
--- a/test/typ/compiler/repr-02.out
+++ b/test/typ/compiler/repr-02.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/repr-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
-                                 "typ/compiler/repr-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/repr-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 0.8 Em)) ])
 , SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "rgb"))
        [ NormalArg (Literal (String "f7a205")) ])
@@ -57,7 +18,7 @@
 , HardBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Plus
        (Literal (Numeric 2.0 Pt))
        (FuncCall
@@ -65,9 +26,10 @@
           [ NormalArg (Literal (String "f7a205")) ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "raw"))
        [ NormalArg
@@ -78,15 +40,16 @@
 , SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "repr"))
        [ NormalArg (Literal (String "a\n[]\"\128640string")) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "raw"))
        [ KeyValArg (Identifier "lang") (Literal (String "typc"))
@@ -96,11 +59,12 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Nothing"
 , SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "x") ]
@@ -108,17 +72,17 @@
 , SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (Ident (Identifier "f"))
 , SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (Ident (Identifier "rect"))
 , SoftBreak
 , Code
     "typ/compiler/repr-02.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncExpr [] (Literal None))
 , ParBreak
 ]
@@ -135,6 +99,8 @@
  color: rgb(96%,63%,1%,100%))], 
                       size: 0.8em), 
                  parbreak(), 
+                 text(body: [
+], size: 0.8em), 
                  raw(lang: "typc", 
                      text: "\"hi\""), 
                  text(body: [
@@ -142,10 +108,13 @@
                  text(body: ["a\n[]\"🚀string"], 
                       size: 0.8em), 
                  parbreak(), 
+                 text(body: [
+], size: 0.8em), 
                  raw(lang: "typc", 
                      text: "strong(body: text(body: [Hey], \n                  size: 0.8em))"), 
                  parbreak(), 
-                 text(body: [Nothing
+                 text(body: [
+Nothing
 ], 
                       size: 0.8em), 
                  text(body: [
diff --git a/test/typ/compiler/return-00.out b/test/typ/compiler/return-00.out
--- a/test/typ/compiler/return-00.out
+++ b/test/typ/compiler/return-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/return-00.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
-                                 "typ/compiler/return-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/return-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/return-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "x") ]
@@ -53,7 +14,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/return-01.out b/test/typ/compiler/return-01.out
--- a/test/typ/compiler/return-01.out
+++ b/test/typ/compiler/return-01.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/return-01.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
-                                 "typ/compiler/return-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/return-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/return-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "x") ]
@@ -67,7 +27,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-01.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -77,7 +37,7 @@
 , SoftBreak
 , Code
     "typ/compiler/return-01.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -87,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compiler/return-01.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -97,10 +57,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  text(body: [✅]), 
                  text(body: [
diff --git a/test/typ/compiler/return-02.out b/test/typ/compiler/return-02.out
--- a/test/typ/compiler/return-02.out
+++ b/test/typ/compiler/return-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/return-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
-                                 "typ/compiler/return-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/return-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/return-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (LetFunc
        (Identifier "f")
        [ NormalParam (Identifier "text")
@@ -60,7 +21,7 @@
                           [ Text "."
                           , Code
                               "typ/compiler/return-02.typ"
-                              ( line 7 , column 26 )
+                              ( line 6 , column 26 )
                               (Return Nothing)
                           ])
                    )
@@ -74,7 +35,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-02.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "f"))
        [ KeyValArg
@@ -85,7 +46,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-02.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "f"))
        [ BlockArg
@@ -93,6 +54,6 @@
        ])
 , ParBreak
 ]
-"typ/compiler/return-02.typ" (line 13, column 2):
+"typ/compiler/return-02.typ" (line 12, column 2):
 unexpected end of input
 text is not an element function
diff --git a/test/typ/compiler/return-04.out b/test/typ/compiler/return-04.out
--- a/test/typ/compiler/return-04.out
+++ b/test/typ/compiler/return-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/return-04.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
-                                 "typ/compiler/return-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/return-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/return-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "sum")
        [ SinkParam (Just (Identifier "args")) ]
@@ -66,7 +27,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-04.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (LetFunc
        (Identifier "f")
        []
@@ -84,7 +45,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-04.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (FuncCall (Ident (Identifier "f")) [])
diff --git a/test/typ/compiler/return-05.out b/test/typ/compiler/return-05.out
--- a/test/typ/compiler/return-05.out
+++ b/test/typ/compiler/return-05.out
@@ -1,53 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/return-05.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
-                                 "typ/compiler/return-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/return-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/return-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal (Int 3)))
 , SoftBreak
 , Code
     "typ/compiler/return-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (LetFunc
        (Identifier "f")
        []
@@ -60,7 +21,7 @@
              , SoftBreak
              , Code
                  "typ/compiler/return-05.typ"
-                 ( line 6 , column 4 )
+                 ( line 5 , column 4 )
                  (Return (Just (Literal (String "nope"))))
              , SoftBreak
              , Text "World"
@@ -69,7 +30,7 @@
 , ParBreak
 , Code
     "typ/compiler/return-05.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (FuncCall (Ident (Identifier "f")) [])
diff --git a/test/typ/compiler/set-00.out b/test/typ/compiler/set-00.out
--- a/test/typ/compiler/set-00.out
+++ b/test/typ/compiler/set-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/set-00.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
-                                 "typ/compiler/set-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/set-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (Block (Content [ Text "World" ])))
@@ -52,7 +13,7 @@
 , Strong
     [ Code
         "typ/compiler/set-00.typ"
-        ( line 4 , column 9 )
+        ( line 3 , column 9 )
         (Ident (Identifier "x"))
     ]
 , ParBreak
diff --git a/test/typ/compiler/set-01.out b/test/typ/compiler/set-01.out
--- a/test/typ/compiler/set-01.out
+++ b/test/typ/compiler/set-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/set-01.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
-                                 "typ/compiler/set-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/set-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "fruit")))
        (Block
@@ -54,7 +15,7 @@
              , SoftBreak
              , Code
                  "typ/compiler/set-01.typ"
-                 ( line 6 , column 4 )
+                 ( line 5 , column 4 )
                  (FuncCall
                     (Ident (Identifier "list"))
                     [ KeyValArg (Identifier "body-indent") (Literal (Numeric 20.0 Pt))
@@ -67,30 +28,25 @@
 , SoftBreak
 , Code
     "typ/compiler/set-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Block
        (Content
           [ Code
               "typ/compiler/set-01.typ"
-              ( line 10 , column 4 )
+              ( line 9 , column 4 )
               (Set
                  (Ident (Identifier "list"))
                  [ KeyValArg (Identifier "indent") (Literal (Numeric 10.0 Pt)) ])
           , SoftBreak
           , Code
               "typ/compiler/set-01.typ"
-              ( line 11 , column 3 )
+              ( line 10 , column 3 )
               (Ident (Identifier "fruit"))
           ]))
 , SoftBreak
 , BulletListItem
-    [ Text "No"
-    , Space
-    , Text "more"
-    , Space
-    , Text "fruit"
-    , ParBreak
-    ]
+    [ Text "No" , Space , Text "more" , Space , Text "fruit" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -108,6 +64,5 @@
                  parbreak(), 
                  text(body: [
 ]), 
-                 list(children: ({ text(body: [No more fruit]), 
-                                   parbreak() }), 
+                 list(children: (text(body: [No more fruit])), 
                       indent: 10.0pt) })
diff --git a/test/typ/compiler/set-02.out b/test/typ/compiler/set-02.out
--- a/test/typ/compiler/set-02.out
+++ b/test/typ/compiler/set-02.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/set-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
-                                 "typ/compiler/set-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compiler/set-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 4.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/compiler/set-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "style") (Literal (String "italic"))
@@ -59,7 +21,7 @@
 , SoftBreak
 , Code
     "typ/compiler/set-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (Block
@@ -72,7 +34,7 @@
              , Space
              , Code
                  "typ/compiler/set-02.typ"
-                 ( line 6 , column 24 )
+                 ( line 5 , column 24 )
                  (FuncCall (Ident (Identifier "parbreak")) [])
              , Space
              , Text "lay"
@@ -82,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/compiler/set-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -92,6 +54,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/set-03.out b/test/typ/compiler/set-03.out
--- a/test/typ/compiler/set-03.out
+++ b/test/typ/compiler/set-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/set-03.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
-                                 "typ/compiler/set-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/set-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ If
diff --git a/test/typ/compiler/set-04.out b/test/typ/compiler/set-04.out
--- a/test/typ/compiler/set-04.out
+++ b/test/typ/compiler/set-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/set-04.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
-                                 "typ/compiler/set-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/set-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "choice")))
        (Array
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/set-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg
@@ -88,7 +49,8 @@
 , SoftBreak
 , EnumListItem Nothing [ Text "Rhino" ]
 , SoftBreak
-, EnumListItem Nothing [ Text "Tiger" , ParBreak ]
+, EnumListItem Nothing [ Text "Tiger" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -98,6 +60,5 @@
                  parbreak(), 
                  enum(children: (text(body: [Monkey]), 
                                  text(body: [Rhino]), 
-                                 { text(body: [Tiger]), 
-                                   parbreak() }), 
+                                 text(body: [Tiger])), 
                       numbering: ) })
diff --git a/test/typ/compiler/set-05.out b/test/typ/compiler/set-05.out
--- a/test/typ/compiler/set-05.out
+++ b/test/typ/compiler/set-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/set-05.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
-                                 "typ/compiler/set-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/set-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "ref")))
        (FuncExpr
diff --git a/test/typ/compiler/set-08.out b/test/typ/compiler/set-08.out
--- a/test/typ/compiler/set-08.out
+++ b/test/typ/compiler/set-08.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/set-08.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
-                                 "typ/compiler/set-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/set-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/set-08.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg
@@ -54,7 +14,5 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 foo]), 
                  parbreak() })
diff --git a/test/typ/compiler/shorthand-00.out b/test/typ/compiler/shorthand-00.out
--- a/test/typ/compiler/shorthand-00.out
+++ b/test/typ/compiler/shorthand-00.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/shorthand-00.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
-                                 "typ/compiler/shorthand-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/shorthand-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "The"
+[ Text "The"
 , Space
 , Text "non"
 , Text "-"
@@ -54,6 +14,5 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-The non-breaking space does work.]), 
+document(body: { text(body: [The non-breaking space does work.]), 
                  parbreak() })
diff --git a/test/typ/compiler/shorthand-01.out b/test/typ/compiler/shorthand-01.out
--- a/test/typ/compiler/shorthand-01.out
+++ b/test/typ/compiler/shorthand-01.out
@@ -1,50 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/shorthand-01.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
-                                 "typ/compiler/shorthand-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/shorthand-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/shorthand-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -63,6 +26,10 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 a b ], 
diff --git a/test/typ/compiler/shorthand-02.out b/test/typ/compiler/shorthand-02.out
--- a/test/typ/compiler/shorthand-02.out
+++ b/test/typ/compiler/shorthand-02.out
@@ -1,60 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/shorthand-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
-                                 "typ/compiler/shorthand-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/shorthand-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, BulletListItem
+[ BulletListItem
     [ Text "En" , Space , Text "dash" , Text ":" , Space , EnDash ]
 , SoftBreak
 , BulletListItem
-    [ Text "Em"
-    , Space
-    , Text "dash"
-    , Text ":"
-    , Space
-    , EmDash
-    , ParBreak
-    ]
+    [ Text "Em" , Space , Text "dash" , Text ":" , Space , EmDash ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 list(children: (text(body: [En dash: –]), 
-                                 { text(body: [Em dash: —]), 
-                                   parbreak() })) })
+document(body: list(children: (text(body: [En dash: –]), 
+                               text(body: [Em dash: —]))))
diff --git a/test/typ/compiler/shorthand-03.out b/test/typ/compiler/shorthand-03.out
--- a/test/typ/compiler/shorthand-03.out
+++ b/test/typ/compiler/shorthand-03.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/shorthand-03.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
-                                 "typ/compiler/shorthand-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/shorthand-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/shorthand-03.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "Roboto")) ])
@@ -53,14 +13,12 @@
 , Space
 , Code
     "typ/compiler/shorthand-03.typ"
-    ( line 3 , column 10 )
+    ( line 2 , column 10 )
     (Literal (String "A..."))
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 A… vs ], 
                       font: "Roboto"), 
                  text(body: [A...], 
diff --git a/test/typ/compiler/show-bare-00.out b/test/typ/compiler/show-bare-00.out
--- a/test/typ/compiler/show-bare-00.out
+++ b/test/typ/compiler/show-bare-00.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/compiler/show-bare-00.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
-                                 "typ/compiler/show-bare-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-bare-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/show-bare-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 130.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/compiler/show-bare-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 0.7 Em)) ])
 , ParBreak
 , Code
     "typ/compiler/show-bare-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
@@ -63,7 +23,7 @@
            [ SoftBreak
            , Code
                "typ/compiler/show-bare-00.typ"
-               ( line 6 , column 4 )
+               ( line 5 , column 4 )
                (FuncCall
                   (Ident (Identifier "text"))
                   [ NormalArg (Literal (Numeric 1.3 Em))
@@ -84,7 +44,7 @@
 , ParBreak
 , Code
     "typ/compiler/show-bare-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Show
        Nothing
        (FuncCall
@@ -167,8 +127,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  align(alignment: center, 
diff --git a/test/typ/compiler/show-bare-01.out b/test/typ/compiler/show-bare-01.out
--- a/test/typ/compiler/show-bare-01.out
+++ b/test/typ/compiler/show-bare-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-bare-01.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
-                                 "typ/compiler/show-bare-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-bare-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Space
 , Code
     "typ/compiler/show-bare-01.typ"
-    ( line 3 , column 4 )
+    ( line 2 , column 4 )
     (Block
        (Content
           [ Emph
@@ -52,7 +13,7 @@
               , Space
               , Code
                   "typ/compiler/show-bare-01.typ"
-                  ( line 3 , column 9 )
+                  ( line 2 , column 9 )
                   (Show
                      Nothing
                      (FuncExpr
@@ -62,7 +23,7 @@
                               [ Strong
                                   [ Code
                                       "typ/compiler/show-bare-01.typ"
-                                      ( line 3 , column 23 )
+                                      ( line 2 , column 23 )
                                       (Ident (Identifier "c"))
                                   ]
                               ]))))
@@ -76,8 +37,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A ]), 
+A ]), 
                  emph(body: { text(body: [B ]), 
                               strong(body: text(body: [ C])) }), 
                  text(body: [ D]), 
diff --git a/test/typ/compiler/show-bare-02.out b/test/typ/compiler/show-bare-02.out
--- a/test/typ/compiler/show-bare-02.out
+++ b/test/typ/compiler/show-bare-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-bare-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
-                                 "typ/compiler/show-bare-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-bare-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-bare-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern"))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-bare-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        Nothing
        (FuncCall
diff --git a/test/typ/compiler/show-bare-03.out b/test/typ/compiler/show-bare-03.out
--- a/test/typ/compiler/show-bare-03.out
+++ b/test/typ/compiler/show-bare-03.out
@@ -2,52 +2,10 @@
 [ Code
     "typ/compiler/show-bare-03.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
-                                 "typ/compiler/show-bare-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-bare-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/show-bare-03.typ"
-    ( line 2 , column 2 )
     (Show Nothing (Block (Content [ Text "Shown" ])))
 , SoftBreak
 , Text "Ignored"
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [Shown]) })
+document(body: text(body: [Shown]))
diff --git a/test/typ/compiler/show-node-00.out b/test/typ/compiler/show-node-00.out
--- a/test/typ/compiler/show-node-00.out
+++ b/test/typ/compiler/show-node-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-node-00.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
-                                 "typ/compiler/show-node-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-node-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (FuncExpr
@@ -76,8 +37,9 @@
 , SoftBreak
 , BulletListItem [ Text "D" ]
 , SoftBreak
-, BulletListItem [ Text "E" , ParBreak ]
+, BulletListItem [ Text "E" ]
+, ParBreak
 ]
-"typ/compiler/show-node-00.typ" (line 3, column 2):
+"typ/compiler/show-node-00.typ" (line 2, column 2):
 unexpected end of input
 Content does not have a method "body" or FieldAccess requires a dictionary
diff --git a/test/typ/compiler/show-node-01.out b/test/typ/compiler/show-node-01.out
--- a/test/typ/compiler/show-node-01.out
+++ b/test/typ/compiler/show-node-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-node-01.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
-                                 "typ/compiler/show-node-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-node-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Block (Content [ Text "B" ])))
 , SoftBreak
 , Code
     "typ/compiler/show-node-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Set
@@ -62,7 +23,7 @@
 , Space
 , Code
     "typ/compiler/show-node-01.typ"
-    ( line 5 , column 4 )
+    ( line 4 , column 4 )
     (Block (Content [ Heading 1 [ Text "Heading" ] ]))
 , Space
 , Text "C"
diff --git a/test/typ/compiler/show-node-02.out b/test/typ/compiler/show-node-02.out
--- a/test/typ/compiler/show-node-02.out
+++ b/test/typ/compiler/show-node-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-node-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
-                                 "typ/compiler/show-node-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-node-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show (Just (Ident (Identifier "heading"))) (Literal None))
 , ParBreak
 , Text "Where"
@@ -63,6 +24,7 @@
     , Space
     , Text "here!"
     ]
+, SoftBreak
 , Text "my"
 , Space
 , Text "heading?"
diff --git a/test/typ/compiler/show-node-03.out b/test/typ/compiler/show-node-03.out
--- a/test/typ/compiler/show-node-03.out
+++ b/test/typ/compiler/show-node-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-node-03.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
-                                 "typ/compiler/show-node-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-node-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (FuncExpr
@@ -106,12 +67,14 @@
              ])))
 , ParBreak
 , Heading 1 [ Text "Task" , Space , Text "1" ]
+, SoftBreak
 , Text "Some"
 , Space
 , Text "text"
 , Text "."
 , ParBreak
 , Heading 2 [ Text "Subtask" ]
+, SoftBreak
 , Text "Some"
 , Space
 , Text "more"
@@ -120,6 +83,7 @@
 , Text "."
 , ParBreak
 , Heading 1 [ Text "Task" , Space , Text "2" ]
+, SoftBreak
 , Text "Another"
 , Space
 , Text "text"
diff --git a/test/typ/compiler/show-node-04.out b/test/typ/compiler/show-node-04.out
--- a/test/typ/compiler/show-node-04.out
+++ b/test/typ/compiler/show-node-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-node-04.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
-                                 "typ/compiler/show-node-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-node-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (FuncExpr
@@ -59,6 +20,7 @@
                 ]))))
 , ParBreak
 , Heading 1 [ Text "Heading" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
diff --git a/test/typ/compiler/show-node-06.out b/test/typ/compiler/show-node-06.out
--- a/test/typ/compiler/show-node-06.out
+++ b/test/typ/compiler/show-node-06.out
@@ -2,55 +2,14 @@
 [ Code
     "typ/compiler/show-node-06.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
-                                 "typ/compiler/show-node-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/show-node-06.typ"
-    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Block (Content [ Text "1234" ])))
 , SoftBreak
 , Heading 1 [ Text "Heading" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [1234]) })
diff --git a/test/typ/compiler/show-node-08.out b/test/typ/compiler/show-node-08.out
--- a/test/typ/compiler/show-node-08.out
+++ b/test/typ/compiler/show-node-08.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/show-node-08.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
-                                 "typ/compiler/show-node-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-node-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/show-node-08.typ"
-    ( line 2 , column 2 )
     (Show (Just (Ident (Identifier "text"))) (Literal None))
 , SoftBreak
 , Text "Hey"
@@ -49,7 +9,5 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 Hey]), 
                  parbreak() })
diff --git a/test/typ/compiler/show-recursive-00.out b/test/typ/compiler/show-recursive-00.out
--- a/test/typ/compiler/show-recursive-00.out
+++ b/test/typ/compiler/show-recursive-00.out
@@ -1,54 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-recursive-00.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
-                                 "typ/compiler/show-recursive-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-recursive-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-recursive-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (FuncExpr
           [ NormalParam (Identifier "it") ] (Ident (Identifier "it"))))
 , SoftBreak
 , Heading 1 [ Text "Heading" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
diff --git a/test/typ/compiler/show-recursive-01.out b/test/typ/compiler/show-recursive-01.out
--- a/test/typ/compiler/show-recursive-01.out
+++ b/test/typ/compiler/show-recursive-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-recursive-01.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
-                                 "typ/compiler/show-recursive-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-recursive-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-recursive-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (FuncCall
@@ -54,12 +15,12 @@
 , SoftBreak
 , Code
     "typ/compiler/show-recursive-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show (Just (Ident (Identifier "heading"))) (Block (Content [])))
 , SoftBreak
 , Code
     "typ/compiler/show-recursive-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Show (Just (Ident (Identifier "enum"))) (Block (Content [])))
 , SoftBreak
 , BulletListItem [ Text "Actual" ]
@@ -69,6 +30,7 @@
 , BulletListItem [ Text "List" ]
 , SoftBreak
 , Heading 1 [ Text "Nope" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
diff --git a/test/typ/compiler/show-recursive-02.out b/test/typ/compiler/show-recursive-02.out
--- a/test/typ/compiler/show-recursive-02.out
+++ b/test/typ/compiler/show-recursive-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-recursive-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
-                                 "typ/compiler/show-recursive-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-recursive-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-recursive-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "starwars")
        [ NormalParam (Identifier "body") ]
@@ -86,12 +47,11 @@
              , Ident (Identifier "body")
              ])))
 , ParBreak
-, BulletListItem
-    [ Text "Normal" , Space , Text "list" , SoftBreak ]
-, SoftBreak
+, BulletListItem [ Text "Normal" , Space , Text "list" ]
+, ParBreak
 , Code
     "typ/compiler/show-recursive-02.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "starwars"))
        [ BlockArg
@@ -100,33 +60,31 @@
            , SoftBreak
            , BulletListItem [ Text "Wars" ]
            , SoftBreak
-           , BulletListItem [ Text "List" , ParBreak ]
+           , BulletListItem [ Text "List" ]
+           , ParBreak
            ]
        ])
 , ParBreak
-, BulletListItem [ Text "Normal" , Space , Text "list" , ParBreak ]
+, BulletListItem [ Text "Normal" , Space , Text "list" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
                  parbreak(), 
-                 list(children: (text(body: [Normal list
-]))), 
+                 list(children: (text(body: [Normal list]))), 
                  text(body: [
 ]), 
                  block(body: stack(children: (text(body: list(children: (text(body: [Star]), 
                                                                          text(body: [Wars]), 
-                                                                         { text(body: [List]), 
-                                                                           parbreak() })), 
+                                                                         text(body: [List]))), 
                                                    color: rgb(100%,25%,21%,100%)), 
                                               1.0fr, 
                                               scale(body: text(body: list(children: (text(body: [Star]), 
                                                                                      text(body: [Wars]), 
-                                                                                     { text(body: [List]), 
-                                                                                       parbreak() })), 
+                                                                                     text(body: [List]))), 
                                                                color: rgb(0%,45%,85%,100%)), 
                                                     x: -100%)), 
                                    dir: ltr)), 
                  parbreak(), 
-                 list(children: ({ text(body: [Normal list]), 
-                                   parbreak() })) })
+                 list(children: (text(body: [Normal list]))) })
diff --git a/test/typ/compiler/show-recursive-03.out b/test/typ/compiler/show-recursive-03.out
--- a/test/typ/compiler/show-recursive-03.out
+++ b/test/typ/compiler/show-recursive-03.out
@@ -1,58 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-recursive-03.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
-                                 "typ/compiler/show-recursive-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-recursive-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/show-recursive-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/compiler/show-recursive-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (FuncCall
@@ -62,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-recursive-03.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (FuncCall
@@ -72,7 +36,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-recursive-03.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Show
        (Just (Ident (Identifier "list"))) (Ident (Identifier "block")))
 , ParBreak
@@ -84,7 +48,8 @@
     , BulletListItem [ Text "List" ]
     ]
 , SoftBreak
-, BulletListItem [ Text "Recursive!" , ParBreak ]
+, BulletListItem [ Text "Recursive!" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -95,10 +60,15 @@
 ]), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
                  parbreak(), 
                  block(body: list(children: ({ text(body: [List
 ]), 
                                                block(body: list(children: (text(body: [Nested]), 
                                                                            text(body: [List])))) }, 
-                                             { text(body: [Recursive!]), 
-                                               parbreak() }))) })
+                                             text(body: [Recursive!])))) })
diff --git a/test/typ/compiler/show-selector-00.out b/test/typ/compiler/show-selector-00.out
--- a/test/typ/compiler/show-selector-00.out
+++ b/test/typ/compiler/show-selector-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-selector-00.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
-                                 "typ/compiler/show-selector-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-selector-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-selector-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -70,9 +31,10 @@
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/show-selector-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -104,7 +66,7 @@
 , ParBreak
 , Code
     "typ/compiler/show-selector-00.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg
@@ -115,7 +77,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-selector-00.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -137,7 +99,7 @@
 , Text "justification"
 , Text "."
 , ParBreak
-, RawBlock "rs" "code!(\"it\");\n"
+, RawBlock "rs" "code!(\"it\");"
 , ParBreak
 , Text "You"
 , Space
@@ -165,6 +127,8 @@
 document(body: { text(body: [
 ]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [
 ]), 
@@ -182,7 +146,7 @@
                  parbreak(), 
                  block(body: raw(block: true, 
                                  lang: "rs", 
-                                 text: "code!(\"it\");\n"), 
+                                 text: "code!(\"it\");"), 
                        fill: luma(23000%), 
                        inset: 11.0pt, 
                        outset: -3.0pt, 
diff --git a/test/typ/compiler/show-selector-01.out b/test/typ/compiler/show-selector-01.out
--- a/test/typ/compiler/show-selector-01.out
+++ b/test/typ/compiler/show-selector-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compiler/show-selector-01.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
-                                 "typ/compiler/show-selector-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-selector-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compiler/show-selector-01.typ"
-    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -54,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-selector-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -67,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-selector-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Set
@@ -75,13 +35,14 @@
           [ NormalArg (Ident (Identifier "green")) ]))
 , SoftBreak
 , Heading 1 [ Text "Red" ]
+, SoftBreak
 , Heading 2 [ Text "Blue" ]
+, SoftBreak
 , Heading 3 [ Text "Green" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/show-text-00.out b/test/typ/compiler/show-text-00.out
--- a/test/typ/compiler/show-text-00.out
+++ b/test/typ/compiler/show-text-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-00.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
-                                 "typ/compiler/show-text-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "Roboto")) ])
 , SoftBreak
 , Code
     "typ/compiler/show-text-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Literal (String "Der Spiegel")))
        (Ident (Identifier "smallcaps")))
diff --git a/test/typ/compiler/show-text-01.out b/test/typ/compiler/show-text-01.out
--- a/test/typ/compiler/show-text-01.out
+++ b/test/typ/compiler/show-text-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-01.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
-                                 "typ/compiler/show-text-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Literal (String "TeX")))
        (Block
@@ -50,13 +11,13 @@
              [ Text "T"
              , Code
                  "typ/compiler/show-text-01.typ"
-                 ( line 3 , column 17 )
+                 ( line 2 , column 17 )
                  (FuncCall
                     (Ident (Identifier "h"))
                     [ NormalArg (Negated (Literal (Numeric 0.145 Em))) ])
              , Code
                  "typ/compiler/show-text-01.typ"
-                 ( line 3 , column 29 )
+                 ( line 2 , column 29 )
                  (FuncCall
                     (Ident (Identifier "box"))
                     [ NormalArg
@@ -68,7 +29,7 @@
                     ])
              , Code
                  "typ/compiler/show-text-01.typ"
-                 ( line 3 , column 55 )
+                 ( line 2 , column 55 )
                  (FuncCall
                     (Ident (Identifier "h"))
                     [ NormalArg (Negated (Literal (Numeric 0.135 Em))) ])
@@ -77,7 +38,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-text-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -95,7 +56,7 @@
                     , BlockArg
                         [ Code
                             "typ/compiler/show-text-01.typ"
-                            ( line 4 , column 79 )
+                            ( line 3 , column 79 )
                             (Ident (Identifier "name"))
                         ]
                     ])
diff --git a/test/typ/compiler/show-text-02.out b/test/typ/compiler/show-text-02.out
--- a/test/typ/compiler/show-text-02.out
+++ b/test/typ/compiler/show-text-02.out
@@ -1,54 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-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
-                                 "typ/compiler/show-text-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Literal (String "A"))) (Block (Content [ Text "BB" ])))
 , SoftBreak
 , Code
     "typ/compiler/show-text-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Literal (String "B"))) (Block (Content [ Text "CC" ])))
 , SoftBreak
diff --git a/test/typ/compiler/show-text-03.out b/test/typ/compiler/show-text-03.out
--- a/test/typ/compiler/show-text-03.out
+++ b/test/typ/compiler/show-text-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-03.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
-                                 "typ/compiler/show-text-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
diff --git a/test/typ/compiler/show-text-04.out b/test/typ/compiler/show-text-04.out
--- a/test/typ/compiler/show-text-04.out
+++ b/test/typ/compiler/show-text-04.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-04.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
-                                 "typ/compiler/show-text-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/compiler/show-text-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -69,7 +30,7 @@
 , SoftBreak
 , Code
     "typ/compiler/show-text-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 5)) ])
 , ParBreak
diff --git a/test/typ/compiler/show-text-05.out b/test/typ/compiler/show-text-05.out
--- a/test/typ/compiler/show-text-05.out
+++ b/test/typ/compiler/show-text-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-05.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
-                                 "typ/compiler/show-text-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -54,7 +15,7 @@
              (Content
                 [ Code
                     "typ/compiler/show-text-05.typ"
-                    ( line 3 , column 34 )
+                    ( line 2 , column 34 )
                     (Ident (Identifier "it"))
                 , Space
                 , Text "("
diff --git a/test/typ/compiler/show-text-06.out b/test/typ/compiler/show-text-06.out
--- a/test/typ/compiler/show-text-06.out
+++ b/test/typ/compiler/show-text-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-06.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
-                                 "typ/compiler/show-text-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/show-text-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Literal (String "hello")))
        (FuncExpr
diff --git a/test/typ/compiler/show-text-08.out b/test/typ/compiler/show-text-08.out
--- a/test/typ/compiler/show-text-08.out
+++ b/test/typ/compiler/show-text-08.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/show-text-08.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
-                                 "typ/compiler/show-text-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/show-text-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/show-text-08.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Literal (String "GRAPH")))
        (FuncCall
@@ -61,10 +21,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  text(body: [The ]), 
                  image(source: "/assets/files/graph.png"), 
diff --git a/test/typ/compiler/spread-00.out b/test/typ/compiler/spread-00.out
--- a/test/typ/compiler/spread-00.out
+++ b/test/typ/compiler/spread-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-00.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
-                                 "typ/compiler/spread-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ LetFunc
diff --git a/test/typ/compiler/spread-01.out b/test/typ/compiler/spread-01.out
--- a/test/typ/compiler/spread-01.out
+++ b/test/typ/compiler/spread-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-01.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
-                                 "typ/compiler/spread-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ LetFunc
diff --git a/test/typ/compiler/spread-02.out b/test/typ/compiler/spread-02.out
--- a/test/typ/compiler/spread-02.out
+++ b/test/typ/compiler/spread-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-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
-                                 "typ/compiler/spread-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ LetFunc
diff --git a/test/typ/compiler/spread-03.out b/test/typ/compiler/spread-03.out
--- a/test/typ/compiler/spread-03.out
+++ b/test/typ/compiler/spread-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-03.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
-                                 "typ/compiler/spread-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
@@ -91,7 +52,7 @@
 , ParBreak
 , Code
     "typ/compiler/spread-03.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/compiler/spread-04.out b/test/typ/compiler/spread-04.out
--- a/test/typ/compiler/spread-04.out
+++ b/test/typ/compiler/spread-04.out
@@ -1,58 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-04.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
-                                 "typ/compiler/spread-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc (Identifier "f") [] (Literal None))
 , SoftBreak
 , Code
     "typ/compiler/spread-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "f")) [ SpreadArg (Literal None) ])
 , SoftBreak
 , Code
     "typ/compiler/spread-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "f"))
        [ SpreadArg
@@ -61,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/compiler/spread-04.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "f"))
        [ SpreadArg
diff --git a/test/typ/compiler/spread-05.out b/test/typ/compiler/spread-05.out
--- a/test/typ/compiler/spread-05.out
+++ b/test/typ/compiler/spread-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-05.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
-                                 "typ/compiler/spread-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "f")
        [ SinkParam Nothing , NormalParam (Identifier "a") ]
@@ -50,7 +11,7 @@
 , SoftBreak
 , Code
     "typ/compiler/spread-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/spread-09.out b/test/typ/compiler/spread-09.out
--- a/test/typ/compiler/spread-09.out
+++ b/test/typ/compiler/spread-09.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-09.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
-                                 "typ/compiler/spread-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-09.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Let
@@ -74,12 +35,22 @@
               ]
           , FuncCall
               (Ident (Identifier "test"))
-              [ NormalArg (Dict [ Spr (Literal None) ]) , NormalArg (Array []) ]
+              [ NormalArg (Array [ Spr (Literal None) ]) , NormalArg (Array []) ]
+          , FuncCall
+              (Ident (Identifier "test"))
+              [ NormalArg (Array [ Spr (Ident (Identifier "l")) ])
+              , NormalArg (Ident (Identifier "l"))
+              ]
+          , FuncCall
+              (Ident (Identifier "test"))
+              [ NormalArg (Array [ Spr (Ident (Identifier "l")) ])
+              , NormalArg (Ident (Identifier "l"))
+              ]
           ]))
 , ParBreak
 , Code
     "typ/compiler/spread-09.typ"
-    ( line 10 , column 2 )
+    ( line 11 , column 2 )
     (Block
        (CodeBlock
           [ Let
@@ -121,7 +92,14 @@
           ]))
 , ParBreak
 ]
-"typ/compiler/spread-09.typ" (line 3, column 2):
-unexpected end of input
-expecting end of input
-Could not spread TNone into dictionary
+--- evaluated ---
+document(body: { text(body: [
+]), 
+                 text(body: [✅]), 
+                 text(body: [✅]), 
+                 text(body: [✅]), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 text(body: [✅]), 
+                 parbreak() })
diff --git a/test/typ/compiler/spread-09.typ b/test/typ/compiler/spread-09.typ
--- a/test/typ/compiler/spread-09.typ
+++ b/test/typ/compiler/spread-09.typ
@@ -3,7 +3,9 @@
   let l = (1, 2, 3)
   let r = (5, 6, 7)
   test((..l, 4, ..r), range(1, 8))
-  test((..none), ())
+  test((..none), ()) // #47
+  test((..l), l)
+  test((..l,), l)
 }
 
 #{
diff --git a/test/typ/compiler/spread-12.out b/test/typ/compiler/spread-12.out
--- a/test/typ/compiler/spread-12.out
+++ b/test/typ/compiler/spread-12.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-12.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
-                                 "typ/compiler/spread-12.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-12.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-12.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ LetFunc
diff --git a/test/typ/compiler/spread-13.out b/test/typ/compiler/spread-13.out
--- a/test/typ/compiler/spread-13.out
+++ b/test/typ/compiler/spread-13.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/spread-13.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
-                                 "typ/compiler/spread-13.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/spread-13.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/spread-13.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ LetFunc
diff --git a/test/typ/compiler/string-00.out b/test/typ/compiler/string-00.out
--- a/test/typ/compiler/string-00.out
+++ b/test/typ/compiler/string-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-00.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
-                                 "typ/compiler/string-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-01.out b/test/typ/compiler/string-01.out
--- a/test/typ/compiler/string-01.out
+++ b/test/typ/compiler/string-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-01.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
-                                 "typ/compiler/string-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -84,7 +45,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-04.out b/test/typ/compiler/string-04.out
--- a/test/typ/compiler/string-04.out
+++ b/test/typ/compiler/string-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-04.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
-                                 "typ/compiler/string-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -66,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -78,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-04.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -90,7 +51,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-04.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-07.out b/test/typ/compiler/string-07.out
--- a/test/typ/compiler/string-07.out
+++ b/test/typ/compiler/string-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-07.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
-                                 "typ/compiler/string-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-07.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -67,7 +28,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-07.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -82,7 +43,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-07.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-09.out b/test/typ/compiler/string-09.out
--- a/test/typ/compiler/string-09.out
+++ b/test/typ/compiler/string-09.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-09.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
-                                 "typ/compiler/string-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-09.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -60,7 +21,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-09.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -78,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-09.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -96,7 +57,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-09.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-10.out b/test/typ/compiler/string-10.out
--- a/test/typ/compiler/string-10.out
+++ b/test/typ/compiler/string-10.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-10.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
-                                 "typ/compiler/string-10.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-10.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-10.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -65,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -82,7 +43,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -96,7 +57,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -109,7 +70,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -120,7 +81,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -137,7 +98,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-10.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-11.out b/test/typ/compiler/string-11.out
--- a/test/typ/compiler/string-11.out
+++ b/test/typ/compiler/string-11.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-11.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
-                                 "typ/compiler/string-11.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-11.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-11.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-11.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -72,7 +33,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-11.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -85,7 +46,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-11.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -98,7 +59,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-11.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -115,7 +76,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-11.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -132,7 +93,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-11.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-12.out b/test/typ/compiler/string-12.out
--- a/test/typ/compiler/string-12.out
+++ b/test/typ/compiler/string-12.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-12.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
-                                 "typ/compiler/string-12.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-12.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-12.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "date")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-12.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-12.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -77,7 +38,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-12.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -90,7 +51,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-12.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-13.out b/test/typ/compiler/string-13.out
--- a/test/typ/compiler/string-13.out
+++ b/test/typ/compiler/string-13.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-13.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
-                                 "typ/compiler/string-13.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-13.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-13.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -78,9 +39,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -93,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -121,9 +83,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (LetFunc
        (Identifier "timesum")
        [ NormalParam (Identifier "text") ]
@@ -197,7 +160,7 @@
 , ParBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -208,7 +171,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 27 , column 2 )
+    ( line 26 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -220,7 +183,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-13.typ"
-    ( line 28 , column 2 )
+    ( line 27 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -239,11 +202,15 @@
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  parbreak(), 
                  text(body: [✅]), 
                  text(body: [
diff --git a/test/typ/compiler/string-14.out b/test/typ/compiler/string-14.out
--- a/test/typ/compiler/string-14.out
+++ b/test/typ/compiler/string-14.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-14.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
-                                 "typ/compiler/string-14.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-14.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-14.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -57,7 +18,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-14.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -73,7 +34,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-14.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -89,7 +50,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-14.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -105,7 +66,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-14.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -138,7 +99,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-14.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -156,7 +117,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-14.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-15.out b/test/typ/compiler/string-15.out
--- a/test/typ/compiler/string-15.out
+++ b/test/typ/compiler/string-15.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-15.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
-                                 "typ/compiler/string-15.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-15.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -82,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -111,7 +71,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -167,7 +127,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -207,7 +167,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -248,7 +208,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -266,7 +226,7 @@
 , ParBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -282,7 +242,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -299,7 +259,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -315,7 +275,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -332,7 +292,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -367,7 +327,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 28 , column 2 )
+    ( line 27 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -406,7 +366,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-15.typ"
-    ( line 32 , column 2 )
+    ( line 31 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -433,10 +393,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compiler/string-18.out b/test/typ/compiler/string-18.out
--- a/test/typ/compiler/string-18.out
+++ b/test/typ/compiler/string-18.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-18.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
-                                 "typ/compiler/string-18.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-18.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-18.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "str")))
        (Literal (String "Typst, LaTeX, Word, InDesign")))
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "array")))
        (Array
@@ -61,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -84,7 +45,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -95,7 +56,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -108,7 +69,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -123,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -138,7 +99,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -153,7 +114,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -168,7 +129,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -184,7 +145,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -199,7 +160,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -216,7 +177,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -234,7 +195,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -252,7 +213,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -270,7 +231,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -288,7 +249,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -306,7 +267,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -325,7 +286,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -343,7 +304,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-18.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/string-20.out b/test/typ/compiler/string-20.out
--- a/test/typ/compiler/string-20.out
+++ b/test/typ/compiler/string-20.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/string-20.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
-                                 "typ/compiler/string-20.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/string-20.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/string-20.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -61,7 +22,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-20.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -74,7 +35,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-20.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -97,7 +58,7 @@
 , SoftBreak
 , Code
     "typ/compiler/string-20.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compiler/while-00.out b/test/typ/compiler/while-00.out
--- a/test/typ/compiler/while-00.out
+++ b/test/typ/compiler/while-00.out
@@ -1,53 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/while-00.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
-                                 "typ/compiler/while-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/while-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compiler/while-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0)))
 , SoftBreak
 , Code
     "typ/compiler/while-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (While
        (LessThan (Ident (Identifier "i")) (Literal (Int 10)))
        (Block
@@ -55,28 +16,29 @@
              [ SoftBreak
              , Code
                  "typ/compiler/while-00.typ"
-                 ( line 5 , column 4 )
+                 ( line 4 , column 4 )
                  (Assign
                     (Ident (Identifier "i"))
                     (Plus (Ident (Identifier "i")) (Literal (Int 2))))
              , SoftBreak
              , Code
                  "typ/compiler/while-00.typ"
-                 ( line 6 , column 4 )
+                 ( line 5 , column 4 )
                  (Ident (Identifier "i"))
              , ParBreak
              ])))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compiler/while-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Let
        (BasicBind (Just (Identifier "iter"))) (Literal (Boolean True)))
 , SoftBreak
 , Code
     "typ/compiler/while-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (While
        (Ident (Identifier "iter"))
        (Block
@@ -87,7 +49,7 @@
 , ParBreak
 , Code
     "typ/compiler/while-00.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (While
        (Literal (Boolean False))
        (Block (CodeBlock [ Ident (Identifier "dont-care") ])))
@@ -129,6 +91,8 @@
                  text(body: [10]), 
                  parbreak(), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  text(body: [Hi.]), 
diff --git a/test/typ/compiler/while-01.out b/test/typ/compiler/while-01.out
--- a/test/typ/compiler/while-01.out
+++ b/test/typ/compiler/while-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compiler/while-01.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
-                                 "typ/compiler/while-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compiler/while-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
-, SoftBreak
+, ParBreak
 , Code
     "typ/compiler/while-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,12 +15,12 @@
 , ParBreak
 , Code
     "typ/compiler/while-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0)))
 , SoftBreak
 , Code
     "typ/compiler/while-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -72,7 +33,7 @@
                         (Content
                            [ Code
                                "typ/compiler/while-01.typ"
-                               ( line 8 , column 26 )
+                               ( line 7 , column 26 )
                                (Assign
                                   (Ident (Identifier "i"))
                                   (Plus (Ident (Identifier "i")) (Literal (Int 1))))
@@ -85,8 +46,7 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
+                 parbreak(), 
                  text(body: [✅]), 
                  parbreak(), 
                  text(body: [
diff --git a/test/typ/compute/calc-00.out b/test/typ/compute/calc-00.out
--- a/test/typ/compute/calc-00.out
+++ b/test/typ/compute/calc-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-00.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
-                                 "typ/compute/calc-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -75,7 +36,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -86,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -98,7 +59,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -109,7 +70,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -124,7 +85,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -136,7 +97,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-01.out b/test/typ/compute/calc-01.out
--- a/test/typ/compute/calc-01.out
+++ b/test/typ/compute/calc-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compute/calc-01.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
-                                 "typ/compute/calc-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compute/calc-01.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -57,7 +17,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -73,9 +33,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compute/calc-06.out b/test/typ/compute/calc-06.out
--- a/test/typ/compute/calc-06.out
+++ b/test/typ/compute/calc-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-06.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
-                                 "typ/compute/calc-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-06.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-06.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-06.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -94,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-06.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -107,7 +68,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-06.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -120,7 +81,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-06.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-08.out b/test/typ/compute/calc-08.out
--- a/test/typ/compute/calc-08.out
+++ b/test/typ/compute/calc-08.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-08.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
-                                 "typ/compute/calc-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-08.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-08.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-08.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-08.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-09.out b/test/typ/compute/calc-09.out
--- a/test/typ/compute/calc-09.out
+++ b/test/typ/compute/calc-09.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-09.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
-                                 "typ/compute/calc-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-09.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-09.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-09.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -83,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-09.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -98,7 +59,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-09.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-12.out b/test/typ/compute/calc-12.out
--- a/test/typ/compute/calc-12.out
+++ b/test/typ/compute/calc-12.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-12.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
-                                 "typ/compute/calc-12.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-12.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-12.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-12.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-12.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -83,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-12.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -98,7 +59,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-12.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-15.out b/test/typ/compute/calc-15.out
--- a/test/typ/compute/calc-15.out
+++ b/test/typ/compute/calc-15.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-15.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
-                                 "typ/compute/calc-15.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-15.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-15.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -57,7 +18,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-15.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -74,7 +35,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-15.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -89,7 +50,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-15.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-16.out b/test/typ/compute/calc-16.out
--- a/test/typ/compute/calc-16.out
+++ b/test/typ/compute/calc-16.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-16.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
-                                 "typ/compute/calc-16.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-16.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-16.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-16.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-26.out b/test/typ/compute/calc-26.out
--- a/test/typ/compute/calc-26.out
+++ b/test/typ/compute/calc-26.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-26.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
-                                 "typ/compute/calc-26.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-26.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-26.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-26.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-28.out b/test/typ/compute/calc-28.out
--- a/test/typ/compute/calc-28.out
+++ b/test/typ/compute/calc-28.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-28.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
-                                 "typ/compute/calc-28.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-28.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-28.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-28.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-28.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-28.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-30.out b/test/typ/compute/calc-30.out
--- a/test/typ/compute/calc-30.out
+++ b/test/typ/compute/calc-30.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-30.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
-                                 "typ/compute/calc-30.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-30.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-30.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-30.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-30.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-30.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -94,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-30.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-31.out b/test/typ/compute/calc-31.out
--- a/test/typ/compute/calc-31.out
+++ b/test/typ/compute/calc-31.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-31.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
-                                 "typ/compute/calc-31.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-31.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-31.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-31.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-31.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-31.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -96,7 +57,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-31.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -111,7 +72,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-31.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -124,7 +85,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-31.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-32.out b/test/typ/compute/calc-32.out
--- a/test/typ/compute/calc-32.out
+++ b/test/typ/compute/calc-32.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-32.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
-                                 "typ/compute/calc-32.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-32.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-32.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-32.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-32.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -81,7 +42,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-32.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -96,7 +57,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-32.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -111,7 +72,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-32.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -124,7 +85,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-32.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/calc-36.out b/test/typ/compute/calc-36.out
--- a/test/typ/compute/calc-36.out
+++ b/test/typ/compute/calc-36.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/calc-36.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
-                                 "typ/compute/calc-36.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/calc-36.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/calc-36.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -59,7 +20,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -76,7 +37,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -98,7 +59,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -110,7 +71,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -130,7 +91,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -150,7 +111,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -171,7 +132,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -191,7 +152,7 @@
 , SoftBreak
 , Code
     "typ/compute/calc-36.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/construct-00.out b/test/typ/compute/construct-00.out
--- a/test/typ/compute/construct-00.out
+++ b/test/typ/compute/construct-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/construct-00.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
-                                 "typ/compute/construct-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/construct-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/construct-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -59,9 +20,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compute/construct-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -79,9 +41,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/compute/construct-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -106,7 +69,7 @@
 , SoftBreak
 , Code
     "typ/compute/construct-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -131,7 +94,7 @@
 , SoftBreak
 , Code
     "typ/compute/construct-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -153,7 +116,7 @@
 , SoftBreak
 , Code
     "typ/compute/construct-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -174,12 +137,16 @@
                  text(body: [rgb(0%,30%,70%,100%)]), 
                  text(body: [)]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [❌(]), 
                  text(body: [rgb(100%,0%,0%,50%)]), 
                  text(body: [ /= ]), 
                  text(body: [rgb(100%,0%,0%,50%)]), 
                  text(body: [)]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [✅]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compute/construct-01.out b/test/typ/compute/construct-01.out
--- a/test/typ/compute/construct-01.out
+++ b/test/typ/compute/construct-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/compute/construct-01.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
-                                 "typ/compute/construct-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/construct-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compute/construct-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
@@ -69,6 +31,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  stack(children: (rect(fill: luma(0%)), 
                                   rect(fill: luma(80%))), 
diff --git a/test/typ/compute/construct-07.out b/test/typ/compute/construct-07.out
--- a/test/typ/compute/construct-07.out
+++ b/test/typ/compute/construct-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/construct-07.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
-                                 "typ/compute/construct-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/construct-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/construct-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "envelope")))
        (FuncCall
@@ -72,24 +33,24 @@
 , ParBreak
 , Code
     "typ/compute/construct-07.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Ident (Identifier "envelope"))
 , SoftBreak
 , Code
     "typ/compute/construct-07.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FieldAccess
        (Ident (Identifier "stamped")) (Ident (Identifier "envelope")))
 , SoftBreak
 , Code
     "typ/compute/construct-07.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FieldAccess
        (Ident (Identifier "pen")) (Ident (Identifier "envelope")))
 , SoftBreak
 , Code
     "typ/compute/construct-07.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FieldAccess
        (Ident (Identifier "pen"))
        (FieldAccess
@@ -97,13 +58,13 @@
 , SoftBreak
 , Code
     "typ/compute/construct-07.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FieldAccess
        (Ident (Identifier "lightning")) (Ident (Identifier "envelope")))
 , SoftBreak
 , Code
     "typ/compute/construct-07.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FieldAccess
        (Ident (Identifier "fly")) (Ident (Identifier "envelope")))
 , ParBreak
diff --git a/test/typ/compute/construct-09.out b/test/typ/compute/construct-09.out
--- a/test/typ/compute/construct-09.out
+++ b/test/typ/compute/construct-09.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/construct-09.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
-                                 "typ/compute/construct-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/construct-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/construct-09.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compute/construct-09.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compute/construct-09.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/construct-11.out b/test/typ/compute/construct-11.out
--- a/test/typ/compute/construct-11.out
+++ b/test/typ/compute/construct-11.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compute/construct-11.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
-                                 "typ/compute/construct-11.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/construct-11.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compute/construct-11.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "assert"))
        [ NormalArg
@@ -58,6 +18,4 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak() })
+document(body: parbreak())
diff --git a/test/typ/compute/data-00.out b/test/typ/compute/data-00.out
--- a/test/typ/compute/data-00.out
+++ b/test/typ/compute/data-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/data-00.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
-                                 "typ/compute/data-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/data-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/data-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "data")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "data"))
diff --git a/test/typ/compute/data-03.out b/test/typ/compute/data-03.out
--- a/test/typ/compute/data-03.out
+++ b/test/typ/compute/data-03.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/compute/data-03.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
-                                 "typ/compute/data-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/data-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/compute/data-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , SoftBreak
 , Code
     "typ/compute/data-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "data")))
        (FuncCall
@@ -59,7 +21,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "cells")))
        (Plus
@@ -81,7 +43,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -99,6 +61,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/compute/data-06.out b/test/typ/compute/data-06.out
--- a/test/typ/compute/data-06.out
+++ b/test/typ/compute/data-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/data-06.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
-                                 "typ/compute/data-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/data-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/data-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "data")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-06.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-06.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -78,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-06.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/data-08.out b/test/typ/compute/data-08.out
--- a/test/typ/compute/data-08.out
+++ b/test/typ/compute/data-08.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/data-08.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
-                                 "typ/compute/data-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/data-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/data-08.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "data")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -62,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -73,7 +34,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -84,7 +45,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -95,7 +56,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -106,7 +67,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -123,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -138,7 +99,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -151,7 +112,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-08.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/data-10.out b/test/typ/compute/data-10.out
--- a/test/typ/compute/data-10.out
+++ b/test/typ/compute/data-10.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/data-10.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
-                                 "typ/compute/data-10.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/data-10.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/data-10.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "data")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -75,7 +36,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -86,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -97,7 +58,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -108,7 +69,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -123,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -140,7 +101,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -151,7 +112,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-10.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/data-12.out b/test/typ/compute/data-12.out
--- a/test/typ/compute/data-12.out
+++ b/test/typ/compute/data-12.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/data-12.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
-                                 "typ/compute/data-12.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/data-12.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/data-12.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "data")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compute/data-12.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "data"))
diff --git a/test/typ/compute/foundations-00.out b/test/typ/compute/foundations-00.out
--- a/test/typ/compute/foundations-00.out
+++ b/test/typ/compute/foundations-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compute/foundations-00.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
-                                 "typ/compute/foundations-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/foundations-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compute/foundations-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -52,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/compute/foundations-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -64,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/compute/foundations-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -76,9 +36,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compute/foundations-01.out b/test/typ/compute/foundations-01.out
--- a/test/typ/compute/foundations-01.out
+++ b/test/typ/compute/foundations-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compute/foundations-01.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
-                                 "typ/compute/foundations-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/foundations-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compute/foundations-01.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/compute/foundations-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -71,9 +31,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [✅]), 
+document(body: { text(body: [✅]), 
                  text(body: [
 ]), 
                  text(body: [✅]), 
diff --git a/test/typ/compute/foundations-12.out b/test/typ/compute/foundations-12.out
--- a/test/typ/compute/foundations-12.out
+++ b/test/typ/compute/foundations-12.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/compute/foundations-12.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
-                                 "typ/compute/foundations-12.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/foundations-12.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/foundations-12.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "assert"))
        [ NormalArg (GreaterThan (Literal (Int 5)) (Literal (Int 3))) ])
 , SoftBreak
 , Code
     "typ/compute/foundations-12.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "eq")) (Ident (Identifier "assert")))
@@ -57,7 +18,7 @@
 , SoftBreak
 , Code
     "typ/compute/foundations-12.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "ne")) (Ident (Identifier "assert")))
diff --git a/test/typ/compute/foundations-13.out b/test/typ/compute/foundations-13.out
--- a/test/typ/compute/foundations-13.out
+++ b/test/typ/compute/foundations-13.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/compute/foundations-13.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
-                                 "typ/compute/foundations-13.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/foundations-13.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/compute/foundations-13.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/compute/foundations-13.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -65,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/compute/foundations-13.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/compute/foundations-14.out b/test/typ/compute/foundations-14.out
--- a/test/typ/compute/foundations-14.out
+++ b/test/typ/compute/foundations-14.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compute/foundations-14.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
-                                 "typ/compute/foundations-14.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/foundations-14.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compute/foundations-14.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "eval"))
        [ NormalArg
@@ -50,7 +10,5 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 emph(body: text(body: [Hello World!])), 
+document(body: { emph(body: text(body: [Hello World!])), 
                  parbreak() })
diff --git a/test/typ/compute/foundations-16.out b/test/typ/compute/foundations-16.out
--- a/test/typ/compute/foundations-16.out
+++ b/test/typ/compute/foundations-16.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/compute/foundations-16.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
-                                 "typ/compute/foundations-16.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/compute/foundations-16.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/compute/foundations-16.typ"
-    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "raw")))
        (FuncExpr
@@ -64,13 +24,11 @@
 , ParBreak
 , Text "Interacting"
 , SoftBreak
-, RawBlock "" "#set text(blue)\nBlue #move(dy: -0.15em)[\127754]\n"
+, RawBlock "" "#set text(blue)\nBlue #move(dy: -0.15em)[\127754]"
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [Interacting
 ]), 
                  text(body: { text(body: [
@@ -78,7 +36,6 @@
                                    color: rgb(0%,45%,85%,100%)), 
                               move(body: text(body: [🌊], 
                                               color: rgb(0%,45%,85%,100%)), 
-                                   dy: -0.15em), 
-                              parbreak() }, 
+                                   dy: -0.15em) }, 
                       font: "PT Sans"), 
                  parbreak() })
diff --git a/test/typ/layout/align-00.out b/test/typ/layout/align-00.out
--- a/test/typ/layout/align-00.out
+++ b/test/typ/layout/align-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/layout/align-00.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
-                                 "typ/layout/align-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/align-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/align-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 100.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/align-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
@@ -89,7 +49,7 @@
 , SoftBreak
 , Code
     "typ/layout/align-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg
@@ -104,7 +64,7 @@
 , SoftBreak
 , Code
     "typ/layout/align-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "bottom"))
@@ -135,8 +95,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  stack(children: (align(alignment: left, 
                                         body: square(fill: rgb(13%,61%,67%,100%), 
diff --git a/test/typ/layout/align-01.out b/test/typ/layout/align-01.out
--- a/test/typ/layout/align-01.out
+++ b/test/typ/layout/align-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/align-01.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
-                                 "typ/layout/align-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/align-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/align-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
diff --git a/test/typ/layout/align-02.out b/test/typ/layout/align-02.out
--- a/test/typ/layout/align-02.out
+++ b/test/typ/layout/align-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/align-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
-                                 "typ/layout/align-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/align-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/align-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rotate"))
        [ NormalArg (Negated (Literal (Numeric 30.0 Deg)))
@@ -54,14 +15,14 @@
 , ParBreak
 , Code
     "typ/layout/align-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de")) ])
 , SoftBreak
 , Code
     "typ/layout/align-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "start"))
@@ -70,7 +31,7 @@
 , SoftBreak
 , Code
     "typ/layout/align-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "end"))
@@ -79,14 +40,14 @@
 , ParBreak
 , Code
     "typ/layout/align-02.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ar")) ])
 , SoftBreak
 , Code
     "typ/layout/align-02.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "start"))
@@ -95,7 +56,7 @@
 , SoftBreak
 , Code
     "typ/layout/align-02.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "end"))
diff --git a/test/typ/layout/align-03.out b/test/typ/layout/align-03.out
--- a/test/typ/layout/align-03.out
+++ b/test/typ/layout/align-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/align-03.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
-                                 "typ/layout/align-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/align-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/align-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -54,7 +15,7 @@
 , SoftBreak
 , Code
     "typ/layout/align-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -66,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/layout/align-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
diff --git a/test/typ/layout/block-sizing-00.out b/test/typ/layout/block-sizing-00.out
--- a/test/typ/layout/block-sizing-00.out
+++ b/test/typ/layout/block-sizing-00.out
@@ -2,66 +2,26 @@
 [ Code
     "typ/layout/block-sizing-00.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
-                                 "typ/layout/block-sizing-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/block-sizing-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/block-sizing-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 100.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/block-sizing-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
 , ParBreak
 , Code
     "typ/layout/block-sizing-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 10)) ])
 , SoftBreak
 , Code
     "typ/layout/block-sizing-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 80.0 Percent))
@@ -71,13 +31,13 @@
 , SoftBreak
 , Code
     "typ/layout/block-sizing-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 6)) ])
 , SoftBreak
 , Code
     "typ/layout/block-sizing-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "breakable") (Literal (Boolean False))
@@ -94,8 +54,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do]), 
diff --git a/test/typ/layout/block-sizing-01.out b/test/typ/layout/block-sizing-01.out
--- a/test/typ/layout/block-sizing-01.out
+++ b/test/typ/layout/block-sizing-01.out
@@ -1,56 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/block-sizing-01.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
-                                 "typ/layout/block-sizing-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/block-sizing-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/layout/block-sizing-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 120.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/block-sizing-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 60.0 Pt))
@@ -78,7 +38,7 @@
                            , Space
                            , Code
                                "typ/layout/block-sizing-01.typ"
-                               ( line 6 , column 30 )
+                               ( line 5 , column 30 )
                                (FieldAccess
                                   (Ident (Identifier "width")) (Ident (Identifier "size")))
                            , Space
@@ -90,7 +50,7 @@
                            , Space
                            , Code
                                "typ/layout/block-sizing-01.typ"
-                               ( line 6 , column 56 )
+                               ( line 5 , column 56 )
                                (FieldAccess
                                   (Ident (Identifier "height")) (Ident (Identifier "size")))
                            , ParBreak
@@ -100,10 +60,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  block(body: layout(func: ), 
diff --git a/test/typ/layout/block-spacing-00.out b/test/typ/layout/block-spacing-00.out
--- a/test/typ/layout/block-spacing-00.out
+++ b/test/typ/layout/block-spacing-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/block-spacing-00.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
-                                 "typ/layout/block-spacing-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/block-spacing-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/block-spacing-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 10.0 Pt)) ])
@@ -52,7 +12,7 @@
 , ParBreak
 , Code
     "typ/layout/block-spacing-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 20.0 Pt))
@@ -62,8 +22,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 Hello]), 
                  parbreak(), 
                  text(body: [There]), 
diff --git a/test/typ/layout/clip-00.out b/test/typ/layout/clip-00.out
--- a/test/typ/layout/clip-00.out
+++ b/test/typ/layout/clip-00.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/clip-00.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
-                                 "typ/layout/clip-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/clip-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Hello"
 , Space
 , Code
     "typ/layout/clip-00.typ"
-    ( line 3 , column 8 )
+    ( line 2 , column 8 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Em))
@@ -53,7 +14,7 @@
        , BlockArg
            [ Code
                "typ/layout/clip-00.typ"
-               ( line 3 , column 51 )
+               ( line 2 , column 51 )
                (FuncCall
                   (Ident (Identifier "rect"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 3.0 Em))
@@ -73,7 +34,7 @@
 , Space
 , Code
     "typ/layout/clip-00.typ"
-    ( line 8 , column 8 )
+    ( line 7 , column 8 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Em))
@@ -82,7 +43,7 @@
        , BlockArg
            [ Code
                "typ/layout/clip-00.typ"
-               ( line 8 , column 50 )
+               ( line 7 , column 50 )
                (FuncCall
                   (Ident (Identifier "rect"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 3.0 Em))
@@ -100,8 +61,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Hello ]), 
+Hello ]), 
                  box(body: rect(fill: rgb(100%,25%,21%,100%), 
                                 height: 3.0em, 
                                 width: 3.0em), 
diff --git a/test/typ/layout/clip-01.out b/test/typ/layout/clip-01.out
--- a/test/typ/layout/clip-01.out
+++ b/test/typ/layout/clip-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/clip-01.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
-                                 "typ/layout/clip-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/clip-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/clip-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 5.0 Em))
@@ -69,13 +30,13 @@
 , ParBreak
 , Code
     "typ/layout/clip-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 2.0 Em)) ])
 , ParBreak
 , Code
     "typ/layout/clip-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 5.0 Em))
diff --git a/test/typ/layout/clip-02.out b/test/typ/layout/clip-02.out
--- a/test/typ/layout/clip-02.out
+++ b/test/typ/layout/clip-02.out
@@ -1,51 +1,12 @@
 --- parse tree ---
-[ Code
-    "typ/layout/clip-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
-                                 "typ/layout/clip-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/clip-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Emoji"
 , Text ":"
 , Space
 , Code
     "typ/layout/clip-02.typ"
-    ( line 3 , column 9 )
+    ( line 2 , column 9 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 0.5 Em))
@@ -66,7 +27,7 @@
 , Space
 , Code
     "typ/layout/clip-02.typ"
-    ( line 5 , column 9 )
+    ( line 4 , column 9 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 0.5 Em))
@@ -86,8 +47,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Emoji: ]), 
+Emoji: ]), 
                  box(body: text(body: [🐪, 🌋, 🏞]), 
                      height: 0.5em, 
                      stroke: (thickness: 1.0pt,
diff --git a/test/typ/layout/clip-03.out b/test/typ/layout/clip-03.out
--- a/test/typ/layout/clip-03.out
+++ b/test/typ/layout/clip-03.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/clip-03.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
-                                 "typ/layout/clip-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/clip-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/layout/clip-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
@@ -52,7 +12,7 @@
 , ParBreak
 , Code
     "typ/layout/clip-03.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 4.0 Em))
@@ -102,10 +62,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  text(body: [First!]), 
                  parbreak(), 
diff --git a/test/typ/layout/columns-00.out b/test/typ/layout/columns-00.out
--- a/test/typ/layout/columns-00.out
+++ b/test/typ/layout/columns-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-00.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
-                                 "typ/layout/columns-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 3.25 Cm))
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/layout/columns-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ar"))
@@ -66,14 +27,14 @@
 , SoftBreak
 , Code
     "typ/layout/columns-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "columns"))
        [ KeyValArg (Identifier "gutter") (Literal (Numeric 30.0 Pt)) ])
 , ParBreak
 , Code
     "typ/layout/columns-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
@@ -125,7 +86,7 @@
 , SoftBreak
 , Code
     "typ/layout/columns-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern"))
diff --git a/test/typ/layout/columns-01.out b/test/typ/layout/columns-01.out
--- a/test/typ/layout/columns-01.out
+++ b/test/typ/layout/columns-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-01.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
-                                 "typ/layout/columns-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , ParBreak
 , Code
     "typ/layout/columns-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt))
diff --git a/test/typ/layout/columns-02.out b/test/typ/layout/columns-02.out
--- a/test/typ/layout/columns-02.out
+++ b/test/typ/layout/columns-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-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
-                                 "typ/layout/columns-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 5.0 Cm))
@@ -94,7 +55,7 @@
 , SoftBreak
 , Code
     "typ/layout/columns-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "bottom"))
@@ -109,7 +70,7 @@
 , SoftBreak
 , Code
     "typ/layout/columns-02.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall (Ident (Identifier "colbreak")) [])
 , ParBreak
 , Text "so"
diff --git a/test/typ/layout/columns-03.out b/test/typ/layout/columns-03.out
--- a/test/typ/layout/columns-03.out
+++ b/test/typ/layout/columns-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-03.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
-                                 "typ/layout/columns-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 2.5 Cm))
@@ -51,7 +12,7 @@
 , ParBreak
 , Code
     "typ/layout/columns-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 6.0 Pt))
@@ -70,7 +31,7 @@
                         , SoftBreak
                         , Code
                             "typ/layout/columns-03.typ"
-                            ( line 8 , column 6 )
+                            ( line 7 , column 6 )
                             (FuncCall (Ident (Identifier "colbreak")) [])
                         , SoftBreak
                         , Text "DEF"
diff --git a/test/typ/layout/columns-04.out b/test/typ/layout/columns-04.out
--- a/test/typ/layout/columns-04.out
+++ b/test/typ/layout/columns-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-04.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
-                                 "typ/layout/columns-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 3.25 Cm))
@@ -52,14 +13,14 @@
 , SoftBreak
 , Code
     "typ/layout/columns-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "columns"))
        [ KeyValArg (Identifier "gutter") (Literal (Numeric 30.0 Pt)) ])
 , ParBreak
 , Code
     "typ/layout/columns-04.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
@@ -69,12 +30,12 @@
 , Space
 , Code
     "typ/layout/columns-04.typ"
-    ( line 6 , column 49 )
+    ( line 5 , column 49 )
     (FuncCall (Ident (Identifier "parbreak")) [])
 , SoftBreak
 , Code
     "typ/layout/columns-04.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
@@ -84,12 +45,12 @@
 , Space
 , Code
     "typ/layout/columns-04.typ"
-    ( line 7 , column 49 )
+    ( line 6 , column 49 )
     (FuncCall (Ident (Identifier "parbreak")) [])
 , SoftBreak
 , Code
     "typ/layout/columns-04.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "circle"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern")) ])
diff --git a/test/typ/layout/columns-05.out b/test/typ/layout/columns-05.out
--- a/test/typ/layout/columns-05.out
+++ b/test/typ/layout/columns-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-05.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
-                                 "typ/layout/columns-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 1.0 Cm))
@@ -54,26 +15,26 @@
 , SoftBreak
 , Code
     "typ/layout/columns-05.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall (Ident (Identifier "colbreak")) [])
 , SoftBreak
 , Code
     "typ/layout/columns-05.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall (Ident (Identifier "colbreak")) [])
 , SoftBreak
 , Text "B"
 , SoftBreak
 , Code
     "typ/layout/columns-05.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Text "C"
 , SoftBreak
 , Code
     "typ/layout/columns-05.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall (Ident (Identifier "colbreak")) [])
 , SoftBreak
 , Text "D"
diff --git a/test/typ/layout/columns-06.out b/test/typ/layout/columns-06.out
--- a/test/typ/layout/columns-06.out
+++ b/test/typ/layout/columns-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-06.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
-                                 "typ/layout/columns-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 7.05 Cm))
@@ -51,7 +12,7 @@
 , ParBreak
 , Code
     "typ/layout/columns-06.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
diff --git a/test/typ/layout/columns-07.out b/test/typ/layout/columns-07.out
--- a/test/typ/layout/columns-07.out
+++ b/test/typ/layout/columns-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-07.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
-                                 "typ/layout/columns-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto)
diff --git a/test/typ/layout/columns-08.out b/test/typ/layout/columns-08.out
--- a/test/typ/layout/columns-08.out
+++ b/test/typ/layout/columns-08.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-08.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
-                                 "typ/layout/columns-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-08.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 7.05 Cm))
@@ -92,7 +53,7 @@
 , ParBreak
 , Code
     "typ/layout/columns-08.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
@@ -108,7 +69,7 @@
 , Space
 , Code
     "typ/layout/columns-08.typ"
-    ( line 10 , column 19 )
+    ( line 9 , column 19 )
     (FuncCall (Ident (Identifier "colbreak")) [])
 , Space
 , RawInline "#colbreak()"
diff --git a/test/typ/layout/columns-09.out b/test/typ/layout/columns-09.out
--- a/test/typ/layout/columns-09.out
+++ b/test/typ/layout/columns-09.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/columns-09.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
-                                 "typ/layout/columns-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/columns-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/columns-09.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal Auto)
diff --git a/test/typ/layout/container-00.out b/test/typ/layout/container-00.out
--- a/test/typ/layout/container-00.out
+++ b/test/typ/layout/container-00.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/container-00.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
-                                 "typ/layout/container-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/container-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Space
 , Code
     "typ/layout/container-00.typ"
-    ( line 3 , column 4 )
+    ( line 2 , column 4 )
     (FuncCall
        (Ident (Identifier "box"))
        [ BlockArg [ Text "B" , Space , HardBreak , Text "C" ] ])
@@ -53,12 +14,13 @@
 , Text "."
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Spaced"
 , Space
 , HardBreak
 , Code
     "typ/layout/container-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 0.5 Cm)) ])
@@ -69,14 +31,14 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A ]), 
+A ]), 
                  box(body: { text(body: [B ]), 
                              linebreak(), 
                              text(body: [C]) }), 
                  text(body: [ D.]), 
                  parbreak(), 
-                 text(body: [Spaced ]), 
+                 text(body: [
+Spaced ]), 
                  linebreak(), 
                  box(height: 0.5cm), 
                  text(body: [ ]), 
diff --git a/test/typ/layout/container-01.out b/test/typ/layout/container-01.out
--- a/test/typ/layout/container-01.out
+++ b/test/typ/layout/container-01.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/layout/container-01.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
-                                 "typ/layout/container-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/container-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/container-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 120.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/container-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 0.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/container-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 90.0 Pt))
@@ -66,7 +27,7 @@
            [ SoftBreak
            , Code
                "typ/layout/container-01.typ"
-               ( line 6 , column 4 )
+               ( line 5 , column 4 )
                (FuncCall
                   (Ident (Identifier "block"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 60.0 Percent))
@@ -76,7 +37,7 @@
            , SoftBreak
            , Code
                "typ/layout/container-01.typ"
-               ( line 7 , column 4 )
+               ( line 6 , column 4 )
                (FuncCall
                   (Ident (Identifier "block"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Percent))
diff --git a/test/typ/layout/container-02.out b/test/typ/layout/container-02.out
--- a/test/typ/layout/container-02.out
+++ b/test/typ/layout/container-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/container-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
-                                 "typ/layout/container-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/container-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/container-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Pt))
diff --git a/test/typ/layout/container-03.out b/test/typ/layout/container-03.out
--- a/test/typ/layout/container-03.out
+++ b/test/typ/layout/container-03.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/container-03.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
-                                 "typ/layout/container-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/container-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Hello"
 , Space
 , Code
     "typ/layout/container-03.typ"
-    ( line 3 , column 8 )
+    ( line 2 , column 8 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -61,8 +22,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Hello ]), 
+Hello ]), 
                  box(body: rect(height: 0.7em, 
                                 width: 100%), 
                      width: 1.0fr), 
diff --git a/test/typ/layout/container-04.out b/test/typ/layout/container-04.out
--- a/test/typ/layout/container-04.out
+++ b/test/typ/layout/container-04.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/container-04.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
-                                 "typ/layout/container-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/container-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/layout/container-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
@@ -52,7 +12,7 @@
 , ParBreak
 , Code
     "typ/layout/container-04.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ BlockArg
@@ -97,10 +57,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  parbreak(), 
                  text(body: [First!]), 
                  parbreak(), 
diff --git a/test/typ/layout/container-fill-00.out b/test/typ/layout/container-fill-00.out
--- a/test/typ/layout/container-fill-00.out
+++ b/test/typ/layout/container-fill-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/layout/container-fill-00.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
-                                 "typ/layout/container-fill-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/container-fill-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/container-fill-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 100.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/container-fill-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "words")))
        (FuncCall
@@ -60,7 +20,7 @@
 , SoftBreak
 , Code
     "typ/layout/container-fill-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 8.0 Pt))
@@ -76,7 +36,7 @@
            [ SoftBreak
            , Code
                "typ/layout/container-fill-00.typ"
-               ( line 5 , column 4 )
+               ( line 4 , column 4 )
                (FuncCall
                   (FieldAccess
                      (Ident (Identifier "join"))
@@ -88,7 +48,7 @@
            , SoftBreak
            , Code
                "typ/layout/container-fill-00.typ"
-               ( line 6 , column 4 )
+               ( line 5 , column 4 )
                (FuncCall
                   (Ident (Identifier "box"))
                   [ KeyValArg (Identifier "fill") (Ident (Identifier "teal"))
@@ -98,7 +58,7 @@
            , SoftBreak
            , Code
                "typ/layout/container-fill-00.typ"
-               ( line 7 , column 4 )
+               ( line 6 , column 4 )
                (FuncCall
                   (FieldAccess
                      (Ident (Identifier "join"))
@@ -114,8 +74,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/enum-00.out b/test/typ/layout/enum-00.out
--- a/test/typ/layout/enum-00.out
+++ b/test/typ/layout/enum-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/enum-00.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
-                                 "typ/layout/enum-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/enum-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "enum"))
        [ BlockArg [ Text "Embrace" ]
@@ -51,9 +11,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 enum(children: (text(body: [Embrace]), 
+document(body: { enum(children: (text(body: [Embrace]), 
                                  text(body: [Extend]), 
                                  text(body: [Extinguish]))), 
                  parbreak() })
diff --git a/test/typ/layout/enum-01.out b/test/typ/layout/enum-01.out
--- a/test/typ/layout/enum-01.out
+++ b/test/typ/layout/enum-01.out
@@ -1,65 +1,22 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-01.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
-                                 "typ/layout/enum-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, EnumListItem (Just 0) [ Text "Before" , Space , Text "first!" ]
+[ EnumListItem (Just 0) [ Text "Before" , Space , Text "first!" ]
 , SoftBreak
 , EnumListItem
     (Just 1)
     [ Text "First"
     , Text "."
     , SoftBreak
-    , EnumListItem (Just 2) [ Text "Indented" , SoftBreak ]
+    , EnumListItem (Just 2) [ Text "Indented" ]
     ]
-, SoftBreak
-, EnumListItem Nothing [ Text "Second" , ParBreak ]
+, ParBreak
+, EnumListItem Nothing [ Text "Second" ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 enum(children: (text(body: [Before first!]), 
-                                 { text(body: [First.
+document(body: enum(children: (text(body: [Before first!]), 
+                               { text(body: [First.
 ]), 
-                                   enum(children: (text(body: [Indented
-])), 
-                                        start: 2) }, 
-                                 { text(body: [Second]), 
-                                   parbreak() }), 
-                      start: 0) })
+                                 enum(children: (text(body: [Indented])), 
+                                      start: 2) }, 
+                               text(body: [Second])), 
+                    start: 0))
diff --git a/test/typ/layout/enum-02.out b/test/typ/layout/enum-02.out
--- a/test/typ/layout/enum-02.out
+++ b/test/typ/layout/enum-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-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
-                                 "typ/layout/enum-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -55,7 +16,7 @@
                         Nothing
                         [ Code
                             "typ/layout/enum-02.typ"
-                            ( line 4 , column 8 )
+                            ( line 3 , column 8 )
                             (FuncCall
                                (Ident (Identifier "numbering"))
                                [ NormalArg (Literal (String "I"))
diff --git a/test/typ/layout/enum-03.out b/test/typ/layout/enum-03.out
--- a/test/typ/layout/enum-03.out
+++ b/test/typ/layout/enum-03.out
@@ -1,50 +1,12 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-03.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
-                                 "typ/layout/enum-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , BulletListItem [ Text "Bullet" , Space , Text "List" ]
 , SoftBreak
 , EnumListItem Nothing [ Text "Numbered" , Space , Text "List" ]
 , SoftBreak
-, DescListItem [ Text "Term" ] [ Text "List" , ParBreak ]
+, DescListItem [ Text "Term" ] [ Text "List" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -52,5 +14,4 @@
                  list(children: (text(body: [Bullet List]))), 
                  enum(children: (text(body: [Numbered List]))), 
                  terms(children: ((text(body: [Term]), 
-                                   { text(body: [List]), 
-                                     parbreak() }))) })
+                                   text(body: [List])))) })
diff --git a/test/typ/layout/enum-04.out b/test/typ/layout/enum-04.out
--- a/test/typ/layout/enum-04.out
+++ b/test/typ/layout/enum-04.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-04.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
-                                 "typ/layout/enum-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "1"
 , Text "."
 , Text "2"
@@ -65,8 +26,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [1.2 ]), 
+1.2 ]), 
                  linebreak(), 
                  text(body: [This is 0. ]), 
                  linebreak(), 
diff --git a/test/typ/layout/enum-05.out b/test/typ/layout/enum-05.out
--- a/test/typ/layout/enum-05.out
+++ b/test/typ/layout/enum-05.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-05.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
-                                 "typ/layout/enum-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , EnumListItem Nothing []
 , SoftBreak
 , Text "Empty"
diff --git a/test/typ/layout/enum-06.out b/test/typ/layout/enum-06.out
--- a/test/typ/layout/enum-06.out
+++ b/test/typ/layout/enum-06.out
@@ -1,54 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-06.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
-                                 "typ/layout/enum-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , EnumListItem (Just 1) [ Text "first" ]
 , SoftBreak
 , EnumListItem Nothing [ Text "second" ]
 , SoftBreak
-, EnumListItem (Just 5) [ Text "fifth" , SoftBreak ]
-, SoftBreak
+, EnumListItem (Just 5) [ Text "fifth" ]
+, ParBreak
 , Code
     "typ/layout/enum-06.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "enum"))
        [ NormalArg
@@ -70,8 +31,7 @@
 ]), 
                  enum(children: (text(body: [first]), 
                                  text(body: [second]), 
-                                 text(body: [fifth
-])), 
+                                 text(body: [fifth])), 
                       start: 1), 
                  enum(children: (enum.item(body: text(body: [First]), 
                                            number: 1), 
diff --git a/test/typ/layout/enum-align-00.out b/test/typ/layout/enum-align-00.out
--- a/test/typ/layout/enum-align-00.out
+++ b/test/typ/layout/enum-align-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-align-00.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
-                                 "typ/layout/enum-align-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-align-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-align-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "horizon")) ])
@@ -65,8 +26,8 @@
         ]
     ]
 , SoftBreak
-, EnumListItem
-    Nothing [ Text "BACK" , HardBreak , Text "HERE" , ParBreak ]
+, EnumListItem Nothing [ Text "BACK" , HardBreak , Text "HERE" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -85,5 +46,4 @@
                                                      text(body: [INNER]) })) }, 
                                  { text(body: [BACK]), 
                                    linebreak(), 
-                                   text(body: [HERE]), 
-                                   parbreak() })) })
+                                   text(body: [HERE]) })) })
diff --git a/test/typ/layout/enum-align-01.out b/test/typ/layout/enum-align-01.out
--- a/test/typ/layout/enum-align-01.out
+++ b/test/typ/layout/enum-align-01.out
@@ -1,79 +1,39 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-align-01.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
-                                 "typ/layout/enum-align-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-align-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , EnumListItem (Just 1) [ Text "a" ]
 , SoftBreak
 , EnumListItem (Just 10) [ Text "b" ]
 , SoftBreak
-, EnumListItem (Just 100) [ Text "c" , SoftBreak ]
-, SoftBreak
+, EnumListItem (Just 100) [ Text "c" ]
+, ParBreak
 , Code
     "typ/layout/enum-align-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg
            (Identifier "number-align") (Ident (Identifier "start"))
        ])
 , SoftBreak
-, EnumListItem (Just 1) [ Space , Text "a" ]
+, EnumListItem (Just 1) [ Text "a" ]
 , SoftBreak
-, EnumListItem (Just 8) [ Space , Text "b" ]
+, EnumListItem (Just 8) [ Text "b" ]
 , SoftBreak
-, EnumListItem (Just 16) [ Text "c" , ParBreak ]
+, EnumListItem (Just 16) [ Text "c" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
                  enum(children: (text(body: [a]), 
                                  text(body: [b]), 
-                                 text(body: [c
-])), 
+                                 text(body: [c])), 
                       start: 1), 
                  text(body: [
 ]), 
-                 enum(children: (text(body: [ a]), 
-                                 text(body: [ b]), 
-                                 { text(body: [c]), 
-                                   parbreak() }), 
+                 enum(children: (text(body: [a]), 
+                                 text(body: [b]), 
+                                 text(body: [c])), 
                       number-align: start, 
                       start: 1) })
diff --git a/test/typ/layout/enum-align-02.out b/test/typ/layout/enum-align-02.out
--- a/test/typ/layout/enum-align-02.out
+++ b/test/typ/layout/enum-align-02.out
@@ -1,64 +1,25 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-align-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
-                                 "typ/layout/enum-align-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-align-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-align-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
 , SoftBreak
 , Code
     "typ/layout/enum-align-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg
            (Identifier "number-align") (Ident (Identifier "start"))
        ])
 , ParBreak
-, EnumListItem (Just 4) [ Space , Text "c" ]
+, EnumListItem (Just 4) [ Text "c" ]
 , SoftBreak
-, EnumListItem (Just 8) [ Space , Text "d" ]
+, EnumListItem (Just 8) [ Text "d" ]
 , SoftBreak
 , EnumListItem
     (Just 16)
@@ -66,12 +27,13 @@
     , HardBreak
     , Text "f"
     , SoftBreak
-    , EnumListItem (Just 2) [ Space , Text "f" , HardBreak , Text "g" ]
+    , EnumListItem (Just 2) [ Text "f" , HardBreak , Text "g" ]
     , SoftBreak
     , EnumListItem (Just 32) [ Text "g" ]
     , SoftBreak
-    , EnumListItem (Just 64) [ Text "h" , ParBreak ]
+    , EnumListItem (Just 64) [ Text "h" ]
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -79,18 +41,17 @@
                  text(body: [
 ]), 
                  parbreak(), 
-                 enum(children: (text(body: [ c]), 
-                                 text(body: [ d]), 
+                 enum(children: (text(body: [c]), 
+                                 text(body: [d]), 
                                  { text(body: [e]), 
                                    linebreak(), 
                                    text(body: [f
 ]), 
-                                   enum(children: ({ text(body: [ f]), 
+                                   enum(children: ({ text(body: [f]), 
                                                      linebreak(), 
                                                      text(body: [g]) }, 
                                                    text(body: [g]), 
-                                                   { text(body: [h]), 
-                                                     parbreak() }), 
+                                                   text(body: [h])), 
                                         number-align: start, 
                                         start: 2) }), 
                       number-align: start, 
diff --git a/test/typ/layout/enum-numbering-00.out b/test/typ/layout/enum-numbering-00.out
--- a/test/typ/layout/enum-numbering-00.out
+++ b/test/typ/layout/enum-numbering-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-numbering-00.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
-                                 "typ/layout/enum-numbering-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-numbering-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-numbering-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg (Identifier "numbering") (Literal (String "(1.a.*)"))
@@ -62,7 +23,8 @@
         ]
     ]
 , SoftBreak
-, EnumListItem Nothing [ Text "Normal" , ParBreak ]
+, EnumListItem Nothing [ Text "Normal" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -78,6 +40,5 @@
                                                           numbering: "(1.a.*)") }), 
                                         numbering: "(1.a.*)", 
                                         start: 2) }, 
-                                 { text(body: [Normal]), 
-                                   parbreak() }), 
+                                 text(body: [Normal])), 
                       numbering: "(1.a.*)") })
diff --git a/test/typ/layout/enum-numbering-01.out b/test/typ/layout/enum-numbering-01.out
--- a/test/typ/layout/enum-numbering-01.out
+++ b/test/typ/layout/enum-numbering-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-numbering-01.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
-                                 "typ/layout/enum-numbering-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-numbering-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-numbering-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg (Identifier "numbering") (Literal (String "1.a."))
@@ -53,8 +14,9 @@
     Nothing
     [ Text "First"
     , SoftBreak
-    , EnumListItem Nothing [ Text "Nested" , ParBreak ]
+    , EnumListItem Nothing [ Text "Nested" ]
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -63,8 +25,7 @@
 ]), 
                  enum(children: ({ text(body: [First
 ]), 
-                                   enum(children: ({ text(body: [Nested]), 
-                                                     parbreak() }), 
+                                   enum(children: (text(body: [Nested])), 
                                         full: true, 
                                         numbering: "1.a.") }), 
                       full: true, 
diff --git a/test/typ/layout/enum-numbering-02.out b/test/typ/layout/enum-numbering-02.out
--- a/test/typ/layout/enum-numbering-02.out
+++ b/test/typ/layout/enum-numbering-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-numbering-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
-                                 "typ/layout/enum-numbering-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-numbering-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-numbering-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "enum"))
        [ KeyValArg (Identifier "start") (Literal (Int 3))
diff --git a/test/typ/layout/enum-numbering-03.out b/test/typ/layout/enum-numbering-03.out
--- a/test/typ/layout/enum-numbering-03.out
+++ b/test/typ/layout/enum-numbering-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-numbering-03.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
-                                 "typ/layout/enum-numbering-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-numbering-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-numbering-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg
@@ -54,7 +15,7 @@
                  [ BlockArg
                      [ Code
                          "typ/layout/enum-numbering-03.typ"
-                         ( line 3 , column 34 )
+                         ( line 2 , column 34 )
                          (Ident (Identifier "n"))
                      ]
                  ]))
@@ -64,7 +25,8 @@
     Nothing
     [ Text "A" , SoftBreak , EnumListItem Nothing [ Text "B" ] ]
 , SoftBreak
-, EnumListItem Nothing [ Text "C" , ParBreak ]
+, EnumListItem Nothing [ Text "C" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -75,6 +37,5 @@
 ]), 
                                    enum(children: (text(body: [B])), 
                                         numbering: ) }, 
-                                 { text(body: [C]), 
-                                   parbreak() }), 
+                                 text(body: [C])), 
                       numbering: ) })
diff --git a/test/typ/layout/enum-numbering-04.out b/test/typ/layout/enum-numbering-04.out
--- a/test/typ/layout/enum-numbering-04.out
+++ b/test/typ/layout/enum-numbering-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/enum-numbering-04.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
-                                 "typ/layout/enum-numbering-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/enum-numbering-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/enum-numbering-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/layout/enum-numbering-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "enum"))
        [ KeyValArg
@@ -83,7 +44,8 @@
 , SoftBreak
 , EnumListItem Nothing [ Text "E" ]
 , SoftBreak
-, EnumListItem Nothing [ Text "F" , ParBreak ]
+, EnumListItem Nothing [ Text "F" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -110,8 +72,7 @@
                                         numbering: ) }, 
                                  text(body: [E], 
                                       font: "New Computer Modern"), 
-                                 { text(body: [F], 
-                                        font: "New Computer Modern"), 
-                                   parbreak() }), 
+                                 text(body: [F], 
+                                      font: "New Computer Modern")), 
                       full: true, 
                       numbering: ) })
diff --git a/test/typ/layout/flow-orphan-00.out b/test/typ/layout/flow-orphan-00.out
--- a/test/typ/layout/flow-orphan-00.out
+++ b/test/typ/layout/flow-orphan-00.out
@@ -2,57 +2,18 @@
 [ Code
     "typ/layout/flow-orphan-00.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
-                                 "typ/layout/flow-orphan-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/flow-orphan-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/flow-orphan-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 100.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/flow-orphan-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 12)) ])
 , ParBreak
 , Heading 1 [ Text "Introduction" ]
+, SoftBreak
 , Text "This"
 , Space
 , Text "is"
@@ -73,8 +34,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor]), 
                  parbreak(), 
diff --git a/test/typ/layout/flow-orphan-01.out b/test/typ/layout/flow-orphan-01.out
--- a/test/typ/layout/flow-orphan-01.out
+++ b/test/typ/layout/flow-orphan-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/flow-orphan-01.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
-                                 "typ/layout/flow-orphan-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/flow-orphan-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/flow-orphan-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a8"))
@@ -50,64 +10,69 @@
 , SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "weight") (Literal (Int 700)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Ident (Identifier "blue")) ])
 , SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 27)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 20)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Ident (Identifier "maroon")) ])
 , SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 11)) ])
 , ParBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 13)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Ident (Identifier "olive")) ])
 , SoftBreak
 , Code
     "typ/layout/flow-orphan-01.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 10)) ])
 , ParBreak
@@ -115,10 +80,10 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  text(body: [
+], weight: 700), 
+                 text(body: [
 ], 
                       color: rgb(0%,45%,85%,100%), 
                       weight: 700), 
@@ -126,12 +91,24 @@
                       color: rgb(0%,45%,85%,100%), 
                       weight: 700), 
                  parbreak(), 
+                 text(body: [
+], 
+                      color: rgb(0%,45%,85%,100%), 
+                      weight: 700), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut], 
                       color: rgb(0%,45%,85%,100%), 
                       weight: 700), 
                  parbreak(), 
                  text(body: [
 ], 
+                      color: rgb(0%,45%,85%,100%), 
+                      weight: 700), 
+                 text(body: [
+], 
+                      color: rgb(0%,45%,85%,100%), 
+                      weight: 700), 
+                 text(body: [
+], 
                       color: rgb(52%,7%,29%,100%), 
                       weight: 700), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod], 
@@ -142,6 +119,10 @@
                       color: rgb(52%,7%,29%,100%), 
                       weight: 700), 
                  parbreak(), 
+                 text(body: [
+], 
+                      color: rgb(52%,7%,29%,100%), 
+                      weight: 700), 
                  text(body: [
 ], 
                       color: rgb(23%,60%,43%,100%), 
diff --git a/test/typ/layout/grid-1-00.out b/test/typ/layout/grid-1-00.out
--- a/test/typ/layout/grid-1-00.out
+++ b/test/typ/layout/grid-1-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/grid-1-00.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
-                                 "typ/layout/grid-1-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-1-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-1-00.typ"
-    ( line 2 , column 2 )
     (LetFunc
        (Identifier "cell")
        [ NormalParam (Identifier "width")
@@ -56,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-1-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Pt))
@@ -65,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-1-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
@@ -180,8 +140,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/grid-1-01.out b/test/typ/layout/grid-1-01.out
--- a/test/typ/layout/grid-1-01.out
+++ b/test/typ/layout/grid-1-01.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/layout/grid-1-01.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
-                                 "typ/layout/grid-1-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-1-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-1-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/grid-1-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
@@ -88,8 +48,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  grid(children: (rect(body: text(body: [dddaa aaa aaa]), 
                                       fill: rgb(13%,61%,67%,100%), 
diff --git a/test/typ/layout/grid-1-02.out b/test/typ/layout/grid-1-02.out
--- a/test/typ/layout/grid-1-02.out
+++ b/test/typ/layout/grid-1-02.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/grid-1-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
-                                 "typ/layout/grid-1-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-1-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-1-02.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 3.0 Cm))
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-1-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
@@ -87,8 +47,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  grid(children: ({  }, 
                                  align(alignment: center, 
diff --git a/test/typ/layout/grid-2-00.out b/test/typ/layout/grid-2-00.out
--- a/test/typ/layout/grid-2-00.out
+++ b/test/typ/layout/grid-2-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/grid-2-00.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
-                                 "typ/layout/grid-2-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-2-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-2-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 11.0 Cm))
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-2-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg (Identifier "columns") (Literal (Int 5))
@@ -134,8 +94,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  grid(children: (strong(body: text(body: [Quarter])), 
                                  text(body: [Expenditure]), 
diff --git a/test/typ/layout/grid-3-00.out b/test/typ/layout/grid-3-00.out
--- a/test/typ/layout/grid-3-00.out
+++ b/test/typ/layout/grid-3-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/grid-3-00.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
-                                 "typ/layout/grid-3-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-3-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-3-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 5.0 Cm))
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-3-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -114,8 +74,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  grid(children: ({ text(body: [Lorem ipsum dolor sit amet.]), 
                                    parbreak(), 
diff --git a/test/typ/layout/grid-3-01.out b/test/typ/layout/grid-3-01.out
--- a/test/typ/layout/grid-3-01.out
+++ b/test/typ/layout/grid-3-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-3-01.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
-                                 "typ/layout/grid-3-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-3-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/grid-3-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 5.0 Cm))
@@ -52,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-3-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
@@ -104,6 +66,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/grid-3-02.out b/test/typ/layout/grid-3-02.out
--- a/test/typ/layout/grid-3-02.out
+++ b/test/typ/layout/grid-3-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-3-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
-                                 "typ/layout/grid-3-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-3-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-3-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 5.0 Cm))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-3-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/layout/grid-3-03.out b/test/typ/layout/grid-3-03.out
--- a/test/typ/layout/grid-3-03.out
+++ b/test/typ/layout/grid-3-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-3-03.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
-                                 "typ/layout/grid-3-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-3-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-3-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 5.0 Cm))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-3-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/layout/grid-4-00.out b/test/typ/layout/grid-4-00.out
--- a/test/typ/layout/grid-4-00.out
+++ b/test/typ/layout/grid-4-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-4-00.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
-                                 "typ/layout/grid-4-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-4-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-4-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/layout/grid-4-01.out b/test/typ/layout/grid-4-01.out
--- a/test/typ/layout/grid-4-01.out
+++ b/test/typ/layout/grid-4-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-4-01.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
-                                 "typ/layout/grid-4-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-4-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-4-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/layout/grid-4-02.out b/test/typ/layout/grid-4-02.out
--- a/test/typ/layout/grid-4-02.out
+++ b/test/typ/layout/grid-4-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-4-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
-                                 "typ/layout/grid-4-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-4-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-4-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 4.0 Cm))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/layout/grid-4-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/layout/grid-5-00.out b/test/typ/layout/grid-5-00.out
--- a/test/typ/layout/grid-5-00.out
+++ b/test/typ/layout/grid-5-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-5-00.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
-                                 "typ/layout/grid-5-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-5-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-5-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 2.0 Cm)) ])
 , SoftBreak
 , Code
     "typ/layout/grid-5-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ BlockArg
diff --git a/test/typ/layout/grid-5-01.out b/test/typ/layout/grid-5-01.out
--- a/test/typ/layout/grid-5-01.out
+++ b/test/typ/layout/grid-5-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/grid-5-01.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
-                                 "typ/layout/grid-5-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-5-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/grid-5-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 2.25 Cm)) ])
 , SoftBreak
 , Code
     "typ/layout/grid-5-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -68,7 +29,7 @@
                  , SoftBreak
                  , Code
                      "typ/layout/grid-5-01.typ"
-                     ( line 10 , column 6 )
+                     ( line 9 , column 6 )
                      (FuncCall
                         (Ident (Identifier "align"))
                         [ NormalArg (Ident (Identifier "bottom"))
@@ -82,7 +43,7 @@
                             , HardBreak
                             , Code
                                 "typ/layout/grid-5-01.typ"
-                                ( line 13 , column 8 )
+                                ( line 12 , column 8 )
                                 (FuncCall
                                    (Ident (Identifier "v"))
                                    [ NormalArg (Literal (Numeric 0.0 Pt)) ])
diff --git a/test/typ/layout/grid-auto-shrink-00.out b/test/typ/layout/grid-auto-shrink-00.out
--- a/test/typ/layout/grid-auto-shrink-00.out
+++ b/test/typ/layout/grid-auto-shrink-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/grid-auto-shrink-00.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
-                                 "typ/layout/grid-auto-shrink-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-auto-shrink-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-auto-shrink-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg
@@ -55,14 +15,14 @@
 , SoftBreak
 , Code
     "typ/layout/grid-auto-shrink-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 11.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/grid-auto-shrink-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 4))
@@ -121,8 +81,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ], 
diff --git a/test/typ/layout/grid-rtl-00.out b/test/typ/layout/grid-rtl-00.out
--- a/test/typ/layout/grid-rtl-00.out
+++ b/test/typ/layout/grid-rtl-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/grid-rtl-00.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
-                                 "typ/layout/grid-rtl-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-rtl-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-rtl-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
@@ -50,14 +10,12 @@
     [ Text "\1502\1497\1502\1497\1503"
     , Space
     , Text "\1500\1513\1502\1488\1500"
-    , ParBreak
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
-], dir: rtl), 
-                 list(children: ({ text(body: [מימין לשמאל], 
-                                        dir: rtl), 
-                                   parbreak() })) })
+], 
+                      dir: rtl), 
+                 list(children: (text(body: [מימין לשמאל], 
+                                      dir: rtl))) })
diff --git a/test/typ/layout/grid-rtl-01.out b/test/typ/layout/grid-rtl-01.out
--- a/test/typ/layout/grid-rtl-01.out
+++ b/test/typ/layout/grid-rtl-01.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/layout/grid-rtl-01.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
-                                 "typ/layout/grid-rtl-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/grid-rtl-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/grid-rtl-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
 , SoftBreak
 , Code
     "typ/layout/grid-rtl-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -61,9 +21,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
-], dir: rtl), 
+], 
+                      dir: rtl), 
                  table(children: (text(body: [A], 
                                        dir: rtl), 
                                   text(body: [B], 
diff --git a/test/typ/layout/hide-00.out b/test/typ/layout/hide-00.out
--- a/test/typ/layout/hide-00.out
+++ b/test/typ/layout/hide-00.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/hide-00.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
-                                 "typ/layout/hide-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/hide-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "AB"
+[ Text "AB"
 , Space
 , Code
     "typ/layout/hide-00.typ"
-    ( line 2 , column 5 )
+    ( line 1 , column 5 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -52,26 +12,25 @@
 , HardBreak
 , Code
     "typ/layout/hide-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall (Ident (Identifier "hide")) [ BlockArg [ Text "A" ] ])
 , Text "B"
 , Space
 , Code
     "typ/layout/hide-00.typ"
-    ( line 3 , column 12 )
+    ( line 2 , column 12 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
 , Text "C"
 , Code
     "typ/layout/hide-00.typ"
-    ( line 3 , column 21 )
+    ( line 2 , column 21 )
     (FuncCall (Ident (Identifier "hide")) [ BlockArg [ Text "D" ] ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-AB ]), 
+document(body: { text(body: [AB ]), 
                  h(amount: 1.0fr), 
                  text(body: [ CD ]), 
                  linebreak(), 
diff --git a/test/typ/layout/list-00.out b/test/typ/layout/list-00.out
--- a/test/typ/layout/list-00.out
+++ b/test/typ/layout/list-00.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-00.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
-                                 "typ/layout/list-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Emph [ Text "Shopping" , Space , Text "list" ]
+[ Emph [ Text "Shopping" , Space , Text "list" ]
 , SoftBreak
 , Code
     "typ/layout/list-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "list"))
        [ BlockArg [ Text "Apples" ]
@@ -53,9 +13,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 emph(body: text(body: [Shopping list])), 
+document(body: { emph(body: text(body: [Shopping list])), 
                  text(body: [
 ]), 
                  list(children: (text(body: [Apples]), 
diff --git a/test/typ/layout/list-01.out b/test/typ/layout/list-01.out
--- a/test/typ/layout/list-01.out
+++ b/test/typ/layout/list-01.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-01.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
-                                 "typ/layout/list-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, BulletListItem
+[ BulletListItem
     [ Text "First"
     , Space
     , Text "level"
@@ -60,9 +20,8 @@
         , Text "paragraphs"
         , Text "."
         , ParBreak
-        , BulletListItem
-            [ Text "Third" , Space , Text "level" , Text "." , SoftBreak ]
-        , SoftBreak
+        , BulletListItem [ Text "Third" , Space , Text "level" , Text "." ]
+        , ParBreak
         , Text "Still"
         , Space
         , Text "the"
@@ -73,9 +32,8 @@
         , Space
         , Text "point"
         , Text "."
-        , SoftBreak
         ]
-    , SoftBreak
+    , ParBreak
     , BulletListItem
         [ Text "Still"
         , Space
@@ -83,33 +41,20 @@
         , Space
         , Text "2"
         , Text "."
-        , SoftBreak
         ]
     ]
-, SoftBreak
+, ParBreak
 , BulletListItem
-    [ Text "At"
-    , Space
-    , Text "the"
-    , Space
-    , Text "top"
-    , Text "."
-    , ParBreak
-    ]
+    [ Text "At" , Space , Text "the" , Space , Text "top" , Text "." ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 list(children: ({ text(body: [First level.]), 
-                                   parbreak(), 
-                                   list(children: ({ text(body: [Second level.
+document(body: list(children: ({ text(body: [First level.]), 
+                                 parbreak(), 
+                                 list(children: ({ text(body: [Second level.
 There are multiple paragraphs.]), 
-                                                     parbreak(), 
-                                                     list(children: (text(body: [Third level.
-]))), 
-                                                     text(body: [Still the same bullet point.
-]) }, 
-                                                   text(body: [Still level 2.
-]))) }, 
-                                 { text(body: [At the top.]), 
-                                   parbreak() })) })
+                                                   parbreak(), 
+                                                   list(children: (text(body: [Third level.]))), 
+                                                   text(body: [Still the same bullet point.]) }, 
+                                                 text(body: [Still level 2.]))) }, 
+                               text(body: [At the top.]))))
diff --git a/test/typ/layout/list-02.out b/test/typ/layout/list-02.out
--- a/test/typ/layout/list-02.out
+++ b/test/typ/layout/list-02.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-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
-                                 "typ/layout/list-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, BulletListItem
+[ BulletListItem
     [ Text "Level"
     , Space
     , Text "1"
@@ -49,7 +9,7 @@
         , Space
         , Code
             "typ/layout/list-02.typ"
-            ( line 3 , column 12 )
+            ( line 2 , column 12 )
             (Block
                (Content
                   [ SoftBreak
@@ -62,17 +22,14 @@
                   , Text "block"
                   , ParBreak
                   ]))
-        , ParBreak
         ]
     ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 list(children: ({ text(body: [Level 1
+document(body: list(children: ({ text(body: [Level 1
 ]), 
-                                   list(children: ({ text(body: [Level ]), 
-                                                     text(body: [
+                                 list(children: ({ text(body: [Level ]), 
+                                                   text(body: [
 2 through content block]), 
-                                                     parbreak(), 
-                                                     parbreak() })) })) })
+                                                   parbreak() })) })))
diff --git a/test/typ/layout/list-03.out b/test/typ/layout/list-03.out
--- a/test/typ/layout/list-03.out
+++ b/test/typ/layout/list-03.out
@@ -1,53 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-03.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
-                                 "typ/layout/list-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, BulletListItem
+[ BulletListItem
     [ Text "Top" , Text "-" , Text "level" , Space , Text "indent" ]
 , SoftBreak
-, BulletListItem
-    [ Text "is" , Space , Text "fine" , Text "." , ParBreak ]
+, BulletListItem [ Text "is" , Space , Text "fine" , Text "." ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 list(children: (text(body: [Top-level indent]), 
-                                 { text(body: [is fine.]), 
-                                   parbreak() })) })
+document(body: list(children: (text(body: [Top-level indent]), 
+                               text(body: [is fine.]))))
diff --git a/test/typ/layout/list-04.out b/test/typ/layout/list-04.out
--- a/test/typ/layout/list-04.out
+++ b/test/typ/layout/list-04.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-04.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
-                                 "typ/layout/list-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, BulletListItem
+[ BulletListItem
     [ Text "A"
     , SoftBreak
     , BulletListItem [ Text "B" ]
@@ -47,14 +7,12 @@
     , BulletListItem [ Text "C" ]
     ]
 , SoftBreak
-, BulletListItem [ Text "D" , ParBreak ]
+, BulletListItem [ Text "D" ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 list(children: ({ text(body: [A
+document(body: list(children: ({ text(body: [A
 ]), 
-                                   list(children: (text(body: [B]), 
-                                                   text(body: [C]))) }, 
-                                 { text(body: [D]), 
-                                   parbreak() })) })
+                                 list(children: (text(body: [B]), 
+                                                 text(body: [C]))) }, 
+                               text(body: [D]))))
diff --git a/test/typ/layout/list-05.out b/test/typ/layout/list-05.out
--- a/test/typ/layout/list-05.out
+++ b/test/typ/layout/list-05.out
@@ -1,71 +1,30 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-05.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
-                                 "typ/layout/list-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, Space
-, Text "-"
-, Space
-, Text "A"
-, Space
-, Text "with"
-, Space
-, Text "1"
-, Space
-, Text "tab"
+[ Comment
 , SoftBreak
 , BulletListItem
-    [ Text "B"
+    [ Text "A"
     , Space
     , Text "with"
     , Space
-    , Text "2"
+    , Text "1"
     , Space
-    , Text "tabs"
-    , ParBreak
+    , Text "tab"
+    , SoftBreak
+    , BulletListItem
+        [ Text "B"
+        , Space
+        , Text "with"
+        , Space
+        , Text "2"
+        , Space
+        , Text "tabs"
+        ]
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [ - A with 1 tab
+                 list(children: ({ text(body: [A with 1 tab
 ]), 
-                 list(children: ({ text(body: [B with 2 tabs]), 
-                                   parbreak() })) })
+                                   list(children: (text(body: [B with 2 tabs]))) })) })
diff --git a/test/typ/layout/list-06.out b/test/typ/layout/list-06.out
--- a/test/typ/layout/list-06.out
+++ b/test/typ/layout/list-06.out
@@ -1,71 +1,30 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-06.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
-                                 "typ/layout/list-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, Space
-, Text "-"
-, Space
-, Text "A"
-, Space
-, Text "with"
-, Space
-, Text "2"
-, Space
-, Text "spaces"
+[ Comment
 , SoftBreak
 , BulletListItem
-    [ Text "B"
+    [ Text "A"
     , Space
     , Text "with"
     , Space
     , Text "2"
     , Space
-    , Text "tabs"
-    , ParBreak
+    , Text "spaces"
+    , SoftBreak
+    , BulletListItem
+        [ Text "B"
+        , Space
+        , Text "with"
+        , Space
+        , Text "2"
+        , Space
+        , Text "tabs"
+        ]
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [ - A with 2 spaces
+                 list(children: ({ text(body: [A with 2 spaces
 ]), 
-                 list(children: ({ text(body: [B with 2 tabs]), 
-                                   parbreak() })) })
+                                   list(children: (text(body: [B with 2 tabs]))) })) })
diff --git a/test/typ/layout/list-07.out b/test/typ/layout/list-07.out
--- a/test/typ/layout/list-07.out
+++ b/test/typ/layout/list-07.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-07.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
-                                 "typ/layout/list-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , BulletListItem []
 , SoftBreak
 , Text "Not"
diff --git a/test/typ/layout/list-08.out b/test/typ/layout/list-08.out
--- a/test/typ/layout/list-08.out
+++ b/test/typ/layout/list-08.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-08.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
-                                 "typ/layout/list-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-08.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "horizon")) ])
@@ -53,8 +14,8 @@
     , Text "GHIJKL"
     , HardBreak
     , Text "MNOPQR"
-    , ParBreak
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -64,5 +25,4 @@
                                    linebreak(), 
                                    text(body: [GHIJKL]), 
                                    linebreak(), 
-                                   text(body: [MNOPQR]), 
-                                   parbreak() })) })
+                                   text(body: [MNOPQR]) })) })
diff --git a/test/typ/layout/list-attach-00.out b/test/typ/layout/list-attach-00.out
--- a/test/typ/layout/list-attach-00.out
+++ b/test/typ/layout/list-attach-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-attach-00.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
-                                 "typ/layout/list-attach-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-attach-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Attached"
 , Space
 , Text "to"
@@ -48,14 +9,8 @@
 , BulletListItem [ Text "the" , Space , Text "bottom" ]
 , SoftBreak
 , BulletListItem
-    [ Text "of"
-    , Space
-    , Text "the"
-    , Space
-    , Text "paragraph"
-    , SoftBreak
-    ]
-, SoftBreak
+    [ Text "of" , Space , Text "the" , Space , Text "paragraph" ]
+, ParBreak
 , Text "Next"
 , Space
 , Text "paragraph"
@@ -64,11 +19,9 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Attached to:
+Attached to:
 ]), 
                  list(children: (text(body: [the bottom]), 
-                                 text(body: [of the paragraph
-]))), 
+                                 text(body: [of the paragraph]))), 
                  text(body: [Next paragraph.]), 
                  parbreak() })
diff --git a/test/typ/layout/list-attach-01.out b/test/typ/layout/list-attach-01.out
--- a/test/typ/layout/list-attach-01.out
+++ b/test/typ/layout/list-attach-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-attach-01.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
-                                 "typ/layout/list-attach-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-attach-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-attach-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (Set
@@ -55,7 +16,8 @@
 , SoftBreak
 , Text "World"
 , SoftBreak
-, BulletListItem [ Text "B" , ParBreak ]
+, BulletListItem [ Text "B" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -66,5 +28,4 @@
                  list(children: (text(body: [A]))), 
                  text(body: [World
 ]), 
-                 list(children: ({ text(body: [B]), 
-                                   parbreak() })) })
+                 list(children: (text(body: [B]))) })
diff --git a/test/typ/layout/list-attach-02.out b/test/typ/layout/list-attach-02.out
--- a/test/typ/layout/list-attach-02.out
+++ b/test/typ/layout/list-attach-02.out
@@ -1,62 +1,24 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-attach-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
-                                 "typ/layout/list-attach-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-attach-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Text "Hello"
 , ParBreak
-, BulletListItem [ Text "A" , SoftBreak ]
-, SoftBreak
+, BulletListItem [ Text "A" ]
+, ParBreak
 , Text "World"
 , SoftBreak
-, BulletListItem [ Text "B" , ParBreak ]
+, BulletListItem [ Text "B" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [Hello]), 
+                 text(body: [
+Hello]), 
                  parbreak(), 
-                 list(children: (text(body: [A
-]))), 
+                 list(children: (text(body: [A]))), 
                  text(body: [World
 ]), 
-                 list(children: ({ text(body: [B]), 
-                                   parbreak() })) })
+                 list(children: (text(body: [B]))) })
diff --git a/test/typ/layout/list-attach-03.out b/test/typ/layout/list-attach-03.out
--- a/test/typ/layout/list-attach-03.out
+++ b/test/typ/layout/list-attach-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-attach-03.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
-                                 "typ/layout/list-attach-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-attach-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-attach-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 15.0 Pt)) ])
@@ -55,8 +16,8 @@
 , ParBreak
 , BulletListItem [ Text "B" ]
 , SoftBreak
-, BulletListItem [ Text "C" , SoftBreak ]
-, SoftBreak
+, BulletListItem [ Text "C" ]
+, ParBreak
 , Text "More"
 , Text "."
 , ParBreak
@@ -71,7 +32,6 @@
                  text(body: [World]), 
                  parbreak(), 
                  list(children: (text(body: [B]), 
-                                 text(body: [C
-]))), 
+                                 text(body: [C]))), 
                  text(body: [More.]), 
                  parbreak() })
diff --git a/test/typ/layout/list-attach-04.out b/test/typ/layout/list-attach-04.out
--- a/test/typ/layout/list-attach-04.out
+++ b/test/typ/layout/list-attach-04.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-attach-04.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
-                                 "typ/layout/list-attach-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-attach-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-attach-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 15.0 Pt)) ])
 , SoftBreak
 , Text "Hello"
 , SoftBreak
-, BulletListItem [ Text "A" , SoftBreak ]
-, SoftBreak
+, BulletListItem [ Text "A" ]
+, ParBreak
 , BulletListItem [ Text "B" ]
 , SoftBreak
 , Text "World"
@@ -62,8 +23,7 @@
                  text(body: [
 Hello
 ]), 
-                 list(children: (text(body: [A
-]), 
+                 list(children: (text(body: [A]), 
                                  text(body: [B]))), 
                  text(body: [World]), 
                  parbreak() })
diff --git a/test/typ/layout/list-attach-05.out b/test/typ/layout/list-attach-05.out
--- a/test/typ/layout/list-attach-05.out
+++ b/test/typ/layout/list-attach-05.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-attach-05.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
-                                 "typ/layout/list-attach-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-attach-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Hello"
 , SoftBreak
 , Code
     "typ/layout/list-attach-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "list"))
        [ KeyValArg (Identifier "tight") (Literal (Boolean False))
@@ -57,8 +18,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Hello
+Hello
 ]), 
                  list(children: (text(body: [A]), 
                                  text(body: [B])), 
diff --git a/test/typ/layout/list-marker-00.out b/test/typ/layout/list-marker-00.out
--- a/test/typ/layout/list-marker-00.out
+++ b/test/typ/layout/list-marker-00.out
@@ -1,55 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-marker-00.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
-                                 "typ/layout/list-marker-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-marker-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-marker-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "list"))
        [ KeyValArg (Identifier "marker") (Block (Content [ EnDash ])) ])
 , SoftBreak
 , BulletListItem [ Text "A" ]
 , SoftBreak
-, BulletListItem [ Text "B" , ParBreak ]
+, BulletListItem [ Text "B" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -57,6 +19,5 @@
                  text(body: [
 ]), 
                  list(children: (text(body: [A]), 
-                                 { text(body: [B]), 
-                                   parbreak() }), 
+                                 text(body: [B])), 
                       marker: text(body: [–])) })
diff --git a/test/typ/layout/list-marker-01.out b/test/typ/layout/list-marker-01.out
--- a/test/typ/layout/list-marker-01.out
+++ b/test/typ/layout/list-marker-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-marker-01.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
-                                 "typ/layout/list-marker-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-marker-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-marker-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "list"))
        [ KeyValArg
@@ -57,8 +18,9 @@
     [ Text "A"
     , SoftBreak
     , BulletListItem
-        [ Text "B" , SoftBreak , BulletListItem [ Text "C" , ParBreak ] ]
+        [ Text "B" , SoftBreak , BulletListItem [ Text "C" ] ]
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -69,8 +31,7 @@
 ]), 
                                    list(children: ({ text(body: [B
 ]), 
-                                                     list(children: ({ text(body: [C]), 
-                                                                       parbreak() }), 
+                                                     list(children: (text(body: [C])), 
                                                           marker: (text(body: [–]), 
                                                                    text(body: [•]))) }), 
                                         marker: (text(body: [–]), 
diff --git a/test/typ/layout/list-marker-02.out b/test/typ/layout/list-marker-02.out
--- a/test/typ/layout/list-marker-02.out
+++ b/test/typ/layout/list-marker-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-marker-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
-                                 "typ/layout/list-marker-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-marker-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-marker-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "list"))
        [ KeyValArg
@@ -68,7 +29,8 @@
         [ Text "D" , SoftBreak , BulletListItem [ Text "E" ] ]
     ]
 , SoftBreak
-, BulletListItem [ Text "F" , ParBreak ]
+, BulletListItem [ Text "F" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -84,6 +46,5 @@
                                                      list(children: (text(body: [E])), 
                                                           marker: ) }), 
                                         marker: ) }, 
-                                 { text(body: [F]), 
-                                   parbreak() }), 
+                                 text(body: [F])), 
                       marker: ) })
diff --git a/test/typ/layout/list-marker-03.out b/test/typ/layout/list-marker-03.out
--- a/test/typ/layout/list-marker-03.out
+++ b/test/typ/layout/list-marker-03.out
@@ -1,65 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/layout/list-marker-03.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
-                                 "typ/layout/list-marker-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/list-marker-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/list-marker-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "list"))
-       [ KeyValArg
-           (Identifier "marker") (Block (Content [ BulletListItem [] ]))
-       ])
+       [ KeyValArg (Identifier "marker") (Block (Content [ Text "-" ])) ])
 , SoftBreak
 , BulletListItem
     [ Text "Bare" , Space , Text "hyphen" , Space , Text "is" ]
 , SoftBreak
 , BulletListItem
-    [ Text "a"
-    , Space
-    , Text "bad"
-    , Space
-    , Text "marker"
-    , ParBreak
-    ]
+    [ Text "a" , Space , Text "bad" , Space , Text "marker" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -67,6 +21,5 @@
                  text(body: [
 ]), 
                  list(children: (text(body: [Bare hyphen is]), 
-                                 { text(body: [a bad marker]), 
-                                   parbreak() }), 
-                      marker: list(children: ({  }))) })
+                                 text(body: [a bad marker])), 
+                      marker: text(body: [-])) })
diff --git a/test/typ/layout/pad-00.out b/test/typ/layout/pad-00.out
--- a/test/typ/layout/pad-00.out
+++ b/test/typ/layout/pad-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pad-00.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
-                                 "typ/layout/pad-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pad-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/pad-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "pad"))
        [ KeyValArg (Identifier "left") (Literal (Numeric 10.0 Pt))
@@ -50,16 +11,17 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/pad-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/pad-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
@@ -86,7 +48,7 @@
 , Space
 , Code
     "typ/layout/pad-00.typ"
-    ( line 13 , column 5 )
+    ( line 12 , column 5 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -106,6 +68,8 @@
                  pad(body: text(body: [Indented!]), 
                      left: 10.0pt), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  rect(body: pad(body: rect(fill: rgb(92%,32%,47%,100%), 
diff --git a/test/typ/layout/pad-01.out b/test/typ/layout/pad-01.out
--- a/test/typ/layout/pad-01.out
+++ b/test/typ/layout/pad-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pad-01.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
-                                 "typ/layout/pad-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pad-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/pad-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "pad"))
        [ KeyValArg (Identifier "left") (Literal (Numeric 10.0 Pt))
@@ -52,7 +13,7 @@
            , Space
            , Code
                "typ/layout/pad-01.typ"
-               ( line 3 , column 35 )
+               ( line 2 , column 35 )
                (FuncCall
                   (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
            , Space
diff --git a/test/typ/layout/pad-02.out b/test/typ/layout/pad-02.out
--- a/test/typ/layout/pad-02.out
+++ b/test/typ/layout/pad-02.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pad-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
-                                 "typ/layout/pad-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pad-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/pad-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 6.0 Cm)) ])
 , SoftBreak
 , Code
     "typ/layout/pad-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "left"))
@@ -58,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/layout/pad-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "pad"))
        [ NormalArg (Literal (Numeric 10.0 Pt))
@@ -70,7 +31,7 @@
 , SoftBreak
 , Code
     "typ/layout/pad-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "right"))
diff --git a/test/typ/layout/pad-03.out b/test/typ/layout/pad-03.out
--- a/test/typ/layout/pad-03.out
+++ b/test/typ/layout/pad-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pad-03.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
-                                 "typ/layout/pad-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pad-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/pad-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "pad"))
        [ NormalArg (Literal (Numeric 50.0 Percent)) , BlockArg [] ])
diff --git a/test/typ/layout/page-00.out b/test/typ/layout/page-00.out
--- a/test/typ/layout/page-00.out
+++ b/test/typ/layout/page-00.out
@@ -1,54 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-00.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
-                                 "typ/layout/page-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "page")) [ BlockArg [] ])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  page(body: {  }), 
                  parbreak() })
diff --git a/test/typ/layout/page-01.out b/test/typ/layout/page-01.out
--- a/test/typ/layout/page-01.out
+++ b/test/typ/layout/page-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-01.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
-                                 "typ/layout/page-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a11"))
@@ -55,6 +17,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  page(body: [a11], 
                       fill: rgb(18%,80%,25%,100%), 
diff --git a/test/typ/layout/page-02.out b/test/typ/layout/page-02.out
--- a/test/typ/layout/page-02.out
+++ b/test/typ/layout/page-02.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-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
-                                 "typ/layout/page-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 80.0 Pt))
@@ -52,12 +14,12 @@
 , SoftBreak
 , Code
     "typ/layout/page-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-02.typ"
-              ( line 5 , column 4 )
+              ( line 4 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg (Identifier "width") (Literal (Numeric 40.0 Pt)) ])
@@ -66,12 +28,12 @@
 , SoftBreak
 , Code
     "typ/layout/page-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-02.typ"
-              ( line 6 , column 4 )
+              ( line 5 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg (Identifier "height") (Literal (Numeric 40.0 Pt)) ])
@@ -79,14 +41,15 @@
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/page-02.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-02.typ"
-              ( line 9 , column 4 )
+              ( line 8 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg (Identifier "paper") (Literal (String "a11"))
@@ -103,10 +66,14 @@
 ]), 
                  text(body: [
 ]), 
+                 text(body: [
+]), 
                  text(body: [High]), 
                  text(body: [
 ]), 
                  text(body: [Wide]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [Flipped A11]), 
                  parbreak() })
diff --git a/test/typ/layout/page-03.out b/test/typ/layout/page-03.out
--- a/test/typ/layout/page-03.out
+++ b/test/typ/layout/page-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-03.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
-                                 "typ/layout/page-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/page-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 80.0 Pt))
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/layout/page-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 15.0 Pt))
@@ -65,7 +26,7 @@
 , SoftBreak
 , Code
     "typ/layout/page-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 40.0 Pt))
diff --git a/test/typ/layout/page-04.out b/test/typ/layout/page-04.out
--- a/test/typ/layout/page-04.out
+++ b/test/typ/layout/page-04.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-04.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
-                                 "typ/layout/page-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a11"))
@@ -54,12 +16,14 @@
 , SoftBreak
 , Code
     "typ/layout/page-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  page(body: [a11], 
                       fill: rgb(100%,25%,21%,100%), 
diff --git a/test/typ/layout/page-05.out b/test/typ/layout/page-05.out
--- a/test/typ/layout/page-05.out
+++ b/test/typ/layout/page-05.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-05.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
-                                 "typ/layout/page-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/layout/page-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Pt))
@@ -72,7 +32,7 @@
                                   , Space
                                   , Code
                                       "typ/layout/page-05.typ"
-                                      ( line 5 , column 45 )
+                                      ( line 4 , column 45 )
                                       (FieldAccess
                                          (Ident (Identifier "width")) (Ident (Identifier "size")))
                                   , Space
@@ -84,7 +44,7 @@
                                   , Space
                                   , Code
                                       "typ/layout/page-05.typ"
-                                      ( line 5 , column 71 )
+                                      ( line 4 , column 71 )
                                       (FieldAccess
                                          (Ident (Identifier "height")) (Ident (Identifier "size")))
                                   , Space
@@ -107,10 +67,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  page(body: { layout(func: ), 
                               h(amount: 1.0em), 
                               place(alignment: left, 
diff --git a/test/typ/layout/page-margin-00.out b/test/typ/layout/page-margin-00.out
--- a/test/typ/layout/page-margin-00.out
+++ b/test/typ/layout/page-margin-00.out
@@ -1,54 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-margin-00.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
-                                 "typ/layout/page-margin-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-margin-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/page-margin-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (Content
           [ SoftBreak
           , Code
               "typ/layout/page-margin-00.typ"
-              ( line 4 , column 4 )
+              ( line 3 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg (Identifier "height") (Literal (Numeric 20.0 Pt))
@@ -57,7 +18,7 @@
           , SoftBreak
           , Code
               "typ/layout/page-margin-00.typ"
-              ( line 5 , column 4 )
+              ( line 4 , column 4 )
               (FuncCall
                  (Ident (Identifier "place"))
                  [ NormalArg
@@ -67,7 +28,7 @@
           , SoftBreak
           , Code
               "typ/layout/page-margin-00.typ"
-              ( line 6 , column 4 )
+              ( line 5 , column 4 )
               (FuncCall
                  (Ident (Identifier "place"))
                  [ NormalArg
diff --git a/test/typ/layout/page-margin-01.out b/test/typ/layout/page-margin-01.out
--- a/test/typ/layout/page-margin-01.out
+++ b/test/typ/layout/page-margin-01.out
@@ -1,60 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-margin-01.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
-                                 "typ/layout/page-margin-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-margin-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/page-margin-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 40.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/page-margin-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-margin-01.typ"
-              ( line 4 , column 4 )
+              ( line 3 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg
@@ -65,7 +26,7 @@
           , Space
           , Code
               "typ/layout/page-margin-01.typ"
-              ( line 4 , column 36 )
+              ( line 3 , column 36 )
               (FuncCall
                  (Ident (Identifier "align"))
                  [ NormalArg (Ident (Identifier "left"))
@@ -75,12 +36,12 @@
 , SoftBreak
 , Code
     "typ/layout/page-margin-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-margin-01.typ"
-              ( line 5 , column 4 )
+              ( line 4 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg
@@ -91,7 +52,7 @@
           , Space
           , Code
               "typ/layout/page-margin-01.typ"
-              ( line 5 , column 37 )
+              ( line 4 , column 37 )
               (FuncCall
                  (Ident (Identifier "align"))
                  [ NormalArg (Ident (Identifier "right"))
@@ -101,12 +62,12 @@
 , SoftBreak
 , Code
     "typ/layout/page-margin-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-margin-01.typ"
-              ( line 6 , column 4 )
+              ( line 5 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg
@@ -117,7 +78,7 @@
           , Space
           , Code
               "typ/layout/page-margin-01.typ"
-              ( line 6 , column 35 )
+              ( line 5 , column 35 )
               (FuncCall
                  (Ident (Identifier "align"))
                  [ NormalArg (Ident (Identifier "top")) , BlockArg [ Text "Top" ] ])
@@ -125,12 +86,12 @@
 , SoftBreak
 , Code
     "typ/layout/page-margin-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-margin-01.typ"
-              ( line 7 , column 4 )
+              ( line 6 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg
@@ -141,7 +102,7 @@
           , Space
           , Code
               "typ/layout/page-margin-01.typ"
-              ( line 7 , column 38 )
+              ( line 6 , column 38 )
               (FuncCall
                  (Ident (Identifier "align"))
                  [ NormalArg (Ident (Identifier "bottom"))
@@ -150,14 +111,15 @@
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/page-margin-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/page-margin-01.typ"
-              ( line 10 , column 4 )
+              ( line 9 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg
@@ -196,5 +158,7 @@
                  align(alignment: bottom, 
                        body: text(body: [Bottom])), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [ Overridden]), 
                  parbreak() })
diff --git a/test/typ/layout/page-marginals-00.out b/test/typ/layout/page-marginals-00.out
--- a/test/typ/layout/page-marginals-00.out
+++ b/test/typ/layout/page-marginals-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/page-marginals-00.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
-                                 "typ/layout/page-marginals-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-marginals-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/page-marginals-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "paper") (Literal (String "a8"))
@@ -78,7 +38,7 @@
                   , Space
                   , Code
                       "typ/layout/page-marginals-00.typ"
-                      ( line 10 , column 29 )
+                      ( line 9 , column 29 )
                       (FuncCall
                          (FieldAccess
                             (Ident (Identifier "display"))
@@ -336,7 +296,7 @@
 , ParBreak
 , Code
     "typ/layout/page-marginals-00.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "header") (Literal None)
@@ -356,9 +316,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [But, soft! what light through yonder window breaks? It is the east, and Juliet
 is the sun. Arise, fair sun, and kill the envious moon, Who is already sick and
 pale with grief, That thou her maid art far more fair than she: Be not her maid,
diff --git a/test/typ/layout/page-style-00.out b/test/typ/layout/page-style-00.out
--- a/test/typ/layout/page-style-00.out
+++ b/test/typ/layout/page-style-00.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-style-00.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
-                                 "typ/layout/page-style-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-style-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-style-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a11"))
@@ -54,5 +16,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  parbreak() })
diff --git a/test/typ/layout/page-style-01.out b/test/typ/layout/page-style-01.out
--- a/test/typ/layout/page-style-01.out
+++ b/test/typ/layout/page-style-01.out
@@ -1,61 +1,25 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-style-01.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
-                                 "typ/layout/page-style-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-style-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-style-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red")) ])
 , SoftBreak
 , Code
     "typ/layout/page-style-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/page-style-02.out b/test/typ/layout/page-style-02.out
--- a/test/typ/layout/page-style-02.out
+++ b/test/typ/layout/page-style-02.out
@@ -1,61 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-style-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
-                                 "typ/layout/page-style-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-style-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-style-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page")) [ NormalArg (Literal (String "a4")) ])
 , SoftBreak
 , Code
     "typ/layout/page-style-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "page")) [ NormalArg (Literal (String "a5")) ])
 , SoftBreak
 , Code
     "typ/layout/page-style-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Cm))
@@ -65,6 +27,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/page-style-03.out b/test/typ/layout/page-style-03.out
--- a/test/typ/layout/page-style-03.out
+++ b/test/typ/layout/page-style-03.out
@@ -1,61 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/layout/page-style-03.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
-                                 "typ/layout/page-style-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/page-style-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/page-style-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page")) [ NormalArg (Literal (String "a4")) ])
 , SoftBreak
 , Code
     "typ/layout/page-style-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "page")) [ NormalArg (Literal (String "a5")) ])
 , SoftBreak
 , Code
     "typ/layout/page-style-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a11"))
@@ -65,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/layout/page-style-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "Roboto"))
@@ -74,13 +36,15 @@
 , SoftBreak
 , Code
     "typ/layout/page-style-03.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "smallcaps")) [ BlockArg [ Text "Typst" ] ])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/pagebreak-00.out b/test/typ/layout/pagebreak-00.out
--- a/test/typ/layout/pagebreak-00.out
+++ b/test/typ/layout/pagebreak-00.out
@@ -1,54 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pagebreak-00.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
-                                 "typ/layout/pagebreak-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pagebreak-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/pagebreak-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  pagebreak(), 
                  parbreak() })
diff --git a/test/typ/layout/pagebreak-01.out b/test/typ/layout/pagebreak-01.out
--- a/test/typ/layout/pagebreak-01.out
+++ b/test/typ/layout/pagebreak-01.out
@@ -1,54 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pagebreak-01.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
-                                 "typ/layout/pagebreak-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pagebreak-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/pagebreak-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 2.0 Cm))
@@ -57,12 +19,14 @@
 , SoftBreak
 , Code
     "typ/layout/pagebreak-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  pagebreak(), 
                  text(body: [
diff --git a/test/typ/layout/pagebreak-02.out b/test/typ/layout/pagebreak-02.out
--- a/test/typ/layout/pagebreak-02.out
+++ b/test/typ/layout/pagebreak-02.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pagebreak-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
-                                 "typ/layout/pagebreak-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pagebreak-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/pagebreak-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "aqua")) ])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "pagebreak"))
        [ KeyValArg (Identifier "weak") (Literal (Boolean True)) ])
@@ -59,7 +21,7 @@
 , SoftBreak
 , Code
     "typ/layout/pagebreak-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "pagebreak"))
        [ KeyValArg (Identifier "weak") (Literal (Boolean True)) ])
@@ -68,7 +30,7 @@
 , SoftBreak
 , Code
     "typ/layout/pagebreak-02.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "pagebreak"))
        [ KeyValArg (Identifier "weak") (Literal (Boolean True)) ])
@@ -76,6 +38,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/pagebreak-03.out b/test/typ/layout/pagebreak-03.out
--- a/test/typ/layout/pagebreak-03.out
+++ b/test/typ/layout/pagebreak-03.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pagebreak-03.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
-                                 "typ/layout/pagebreak-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pagebreak-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/pagebreak-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 80.0 Pt))
@@ -52,12 +14,12 @@
 , SoftBreak
 , Code
     "typ/layout/pagebreak-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (Content
           [ Code
               "typ/layout/pagebreak-03.typ"
-              ( line 5 , column 4 )
+              ( line 4 , column 4 )
               (Set
                  (Ident (Identifier "page"))
                  [ KeyValArg (Identifier "width") (Literal (Numeric 60.0 Pt)) ])
@@ -67,19 +29,19 @@
 , SoftBreak
 , Code
     "typ/layout/pagebreak-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Text "Third"
 , SoftBreak
 , Code
     "typ/layout/pagebreak-03.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 20.0 Pt))
@@ -90,12 +52,12 @@
 , Text "Fif"
 , Code
     "typ/layout/pagebreak-03.typ"
-    ( line 10 , column 5 )
+    ( line 9 , column 5 )
     (Block
        (Content
           [ Code
               "typ/layout/pagebreak-03.typ"
-              ( line 10 , column 7 )
+              ( line 9 , column 7 )
               (Set (Ident (Identifier "page")) [])
           , Text "th"
           ]))
@@ -103,6 +65,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/pagebreak-04.out b/test/typ/layout/pagebreak-04.out
--- a/test/typ/layout/pagebreak-04.out
+++ b/test/typ/layout/pagebreak-04.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/layout/pagebreak-04.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
-                                 "typ/layout/pagebreak-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/pagebreak-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/pagebreak-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "navy")) ])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "white")) ])
@@ -59,31 +21,33 @@
 , SoftBreak
 , Code
     "typ/layout/pagebreak-04.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-04.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "page")) [ BlockArg [ Text "Second" ] ])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-04.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "pagebreak"))
        [ KeyValArg (Identifier "weak") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/layout/pagebreak-04.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "page")) [ BlockArg [ Text "Third" ] ])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-00.out b/test/typ/layout/par-00.out
--- a/test/typ/layout/par-00.out
+++ b/test/typ/layout/par-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-00.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
-                                 "typ/layout/par-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "right")) ])
diff --git a/test/typ/layout/par-01.out b/test/typ/layout/par-01.out
--- a/test/typ/layout/par-01.out
+++ b/test/typ/layout/par-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-01.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
-                                 "typ/layout/par-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 1.0 Em)) ])
 , SoftBreak
 , Code
     "typ/layout/par-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "leading") (Literal (Numeric 2.0 Pt)) ])
diff --git a/test/typ/layout/par-02.out b/test/typ/layout/par-02.out
--- a/test/typ/layout/par-02.out
+++ b/test/typ/layout/par-02.out
@@ -1,56 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-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
-                                 "typ/layout/par-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/par-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 100.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/par-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Show
        (Just (Ident (Identifier "table")))
        (Set
@@ -63,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 4))
@@ -90,6 +52,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-03.out b/test/typ/layout/par-03.out
--- a/test/typ/layout/par-03.out
+++ b/test/typ/layout/par-03.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-03.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
-                                 "typ/layout/par-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 0.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/par-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "raw")))
        (Set
@@ -58,17 +19,17 @@
 , SoftBreak
 , Code
     "typ/layout/par-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Show
        (Just (Ident (Identifier "list")))
        (Set
           (Ident (Identifier "block"))
           [ KeyValArg (Identifier "spacing") (Literal (Numeric 2.5 Pt)) ]))
 , ParBreak
-, RawBlock "rust" "fn main() {}\n"
+, RawBlock "rust" "fn main() {}"
 , ParBreak
-, BulletListItem [ Text "List" , SoftBreak ]
-, SoftBreak
+, BulletListItem [ Text "List" ]
+, ParBreak
 , Text "Paragraph"
 , ParBreak
 ]
@@ -82,9 +43,8 @@
                  parbreak(), 
                  raw(block: true, 
                      lang: "rust", 
-                     text: "fn main() {}\n"), 
+                     text: "fn main() {}"), 
                  parbreak(), 
-                 list(children: (text(body: [List
-]))), 
+                 list(children: (text(body: [List]))), 
                  text(body: [Paragraph]), 
                  parbreak() })
diff --git a/test/typ/layout/par-bidi-00.out b/test/typ/layout/par-bidi-00.out
--- a/test/typ/layout/par-bidi-00.out
+++ b/test/typ/layout/par-bidi-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-00.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
-                                 "typ/layout/par-bidi-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-bidi-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "content")))
        (FuncCall
@@ -53,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "he"))
@@ -62,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de"))
diff --git a/test/typ/layout/par-bidi-01.out b/test/typ/layout/par-bidi-01.out
--- a/test/typ/layout/par-bidi-01.out
+++ b/test/typ/layout/par-bidi-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-01.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
-                                 "typ/layout/par-bidi-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/par-bidi-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "content")))
        (FuncCall
@@ -54,7 +16,7 @@
               , Text "A"
               , Code
                   "typ/layout/par-bidi-01.typ"
-                  ( line 4 , column 26 )
+                  ( line 3 , column 26 )
                   (FuncCall (Ident (Identifier "emph")) [ BlockArg [ Text "B" ] ])
               , Text "\1605\1591\1585C"
               ]
@@ -62,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -75,7 +37,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ar"))
@@ -84,7 +46,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de"))
@@ -94,6 +56,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-bidi-02.out b/test/typ/layout/par-bidi-02.out
--- a/test/typ/layout/par-bidi-02.out
+++ b/test/typ/layout/par-bidi-02.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-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
-                                 "typ/layout/par-bidi-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/par-bidi-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "content")))
        (FuncCall
@@ -52,7 +14,7 @@
               [ Text "A\1490\1462"
               , Code
                   "typ/layout/par-bidi-02.typ"
-                  ( line 4 , column 24 )
+                  ( line 3 , column 24 )
                   (FuncCall
                      (Ident (Identifier "strong"))
                      [ BlockArg [ Text "\1513\1473\1462" ] ])
@@ -62,7 +24,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -75,7 +37,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "he"))
@@ -84,7 +46,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-bidi-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de"))
@@ -94,6 +56,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-bidi-03.out b/test/typ/layout/par-bidi-03.out
--- a/test/typ/layout/par-bidi-03.out
+++ b/test/typ/layout/par-bidi-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-03.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
-                                 "typ/layout/par-bidi-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-bidi-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
diff --git a/test/typ/layout/par-bidi-04.out b/test/typ/layout/par-bidi-04.out
--- a/test/typ/layout/par-bidi-04.out
+++ b/test/typ/layout/par-bidi-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-04.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
-                                 "typ/layout/par-bidi-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-bidi-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ar"))
diff --git a/test/typ/layout/par-bidi-05.out b/test/typ/layout/par-bidi-05.out
--- a/test/typ/layout/par-bidi-05.out
+++ b/test/typ/layout/par-bidi-05.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-05.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
-                                 "typ/layout/par-bidi-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "L"
 , Space
 , Code
     "typ/layout/par-bidi-05.typ"
-    ( line 3 , column 4 )
+    ( line 2 , column 4 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Cm)) ])
 , Space
@@ -55,7 +16,7 @@
 , Space
 , Code
     "typ/layout/par-bidi-05.typ"
-    ( line 4 , column 9 )
+    ( line 3 , column 9 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Cm)) ])
 , Space
@@ -64,8 +25,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [L ]), 
+L ]), 
                  h(amount: 1.0cm), 
                  text(body: [ ריווחR ]), 
                  linebreak(), 
diff --git a/test/typ/layout/par-bidi-06.out b/test/typ/layout/par-bidi-06.out
--- a/test/typ/layout/par-bidi-06.out
+++ b/test/typ/layout/par-bidi-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-06.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
-                                 "typ/layout/par-bidi-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-bidi-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "he")) ])
@@ -50,7 +11,7 @@
 , Text "\1511\1512\1504\1508\1497\1501Rh"
 , Code
     "typ/layout/par-bidi-06.typ"
-    ( line 4 , column 10 )
+    ( line 3 , column 10 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/layout/par-bidi-07.out b/test/typ/layout/par-bidi-07.out
--- a/test/typ/layout/par-bidi-07.out
+++ b/test/typ/layout/par-bidi-07.out
@@ -1,65 +1,25 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-bidi-07.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
-                                 "typ/layout/par-bidi-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-bidi-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "\1575\1604\1594\1575\1604\1576"
 , Space
 , Code
     "typ/layout/par-bidi-07.typ"
-    ( line 3 , column 9 )
+    ( line 2 , column 9 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 70.0 Pt)) ])
 , Space
 , Text "\1606"
 , Code
     "typ/layout/par-bidi-07.typ"
-    ( line 3 , column 19 )
+    ( line 2 , column 19 )
     (Literal (String " "))
 , Text "\1577"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [الغالب ]), 
+الغالب ]), 
                  h(amount: 70.0pt), 
                  text(body: [ ن]), 
                  text(body: [ ]), 
diff --git a/test/typ/layout/par-indent-00.out b/test/typ/layout/par-indent-00.out
--- a/test/typ/layout/par-indent-00.out
+++ b/test/typ/layout/par-indent-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/par-indent-00.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
-                                 "typ/layout/par-indent-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-indent-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/par-indent-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg
@@ -51,14 +11,14 @@
 , SoftBreak
 , Code
     "typ/layout/par-indent-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 5.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/par-indent-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Set
@@ -91,7 +51,7 @@
 , ParBreak
 , Code
     "typ/layout/par-indent-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -117,7 +77,7 @@
 , ParBreak
 , Code
     "typ/layout/par-indent-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
@@ -130,6 +90,7 @@
        ])
 , ParBreak
 , Heading 1 [ Text "Headings" ]
+, SoftBreak
 , BulletListItem [ Text "And" , Space , Text "lists" , Text "." ]
 , SoftBreak
 , BulletListItem
@@ -156,12 +117,11 @@
     , Space
     , Text "them"
     , Text "."
-    , SoftBreak
     ]
-, SoftBreak
+, ParBreak
 , Code
     "typ/layout/par-indent-00.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt))
@@ -176,12 +136,13 @@
 , SoftBreak
 , Code
     "typ/layout/par-indent-00.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "leading") (Literal (Numeric 8.0 Pt)) ])
 , ParBreak
 , Heading 1 [ Text "Arabic" ]
+, SoftBreak
 , Text "\1583\1593"
 , Space
 , Text "\1575\1604\1606\1589"
@@ -215,8 +176,6 @@
 ]), 
                  text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  text(body: [The first paragraph has no indent.]), 
                  parbreak(), 
@@ -236,8 +195,7 @@
                  list(children: (text(body: [And lists.]), 
                                  { text(body: [Have no indent.]), 
                                    parbreak(), 
-                                   text(body: [Except if you have another paragraph in them.
-]) })), 
+                                   text(body: [Except if you have another paragraph in them.]) })), 
                  text(body: [
 ], 
                       font: ("Noto Sans Arabic", 
diff --git a/test/typ/layout/par-indent-01.out b/test/typ/layout/par-indent-01.out
--- a/test/typ/layout/par-indent-01.out
+++ b/test/typ/layout/par-indent-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-indent-01.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
-                                 "typ/layout/par-indent-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-indent-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-indent-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg
diff --git a/test/typ/layout/par-indent-02.out b/test/typ/layout/par-indent-02.out
--- a/test/typ/layout/par-indent-02.out
+++ b/test/typ/layout/par-indent-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-indent-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
-                                 "typ/layout/par-indent-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-indent-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-indent-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-indent-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 10)) ])
 , ParBreak
diff --git a/test/typ/layout/par-indent-03.out b/test/typ/layout/par-indent-03.out
--- a/test/typ/layout/par-indent-03.out
+++ b/test/typ/layout/par-indent-03.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/par-indent-03.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
-                                 "typ/layout/par-indent-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-indent-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/par-indent-03.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg
@@ -65,8 +25,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 Welcome ]), 
                  linebreak(), 
                  text(body: [here. Does this work well?]), 
diff --git a/test/typ/layout/par-indent-04.out b/test/typ/layout/par-indent-04.out
--- a/test/typ/layout/par-indent-04.out
+++ b/test/typ/layout/par-indent-04.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/par-indent-04.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
-                                 "typ/layout/par-indent-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-indent-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/par-indent-04.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-indent-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
@@ -92,8 +52,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 لآن وقد أظلم الليل وبدأت النجوم
diff --git a/test/typ/layout/par-justify-00.out b/test/typ/layout/par-justify-00.out
--- a/test/typ/layout/par-justify-00.out
+++ b/test/typ/layout/par-justify-00.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/layout/par-justify-00.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
-                                 "typ/layout/par-justify-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/par-justify-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 5.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True))
@@ -135,8 +95,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-justify-01.out b/test/typ/layout/par-justify-01.out
--- a/test/typ/layout/par-justify-01.out
+++ b/test/typ/layout/par-justify-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-01.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
-                                 "typ/layout/par-justify-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-justify-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
diff --git a/test/typ/layout/par-justify-02.out b/test/typ/layout/par-justify-02.out
--- a/test/typ/layout/par-justify-02.out
+++ b/test/typ/layout/par-justify-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-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
-                                 "typ/layout/par-justify-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Space
 , Text "B"
@@ -48,7 +9,7 @@
 , Space
 , Code
     "typ/layout/par-justify-02.typ"
-    ( line 3 , column 8 )
+    ( line 2 , column 8 )
     (FuncCall
        (Ident (Identifier "linebreak"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -61,7 +22,7 @@
 , Space
 , Code
     "typ/layout/par-justify-02.typ"
-    ( line 4 , column 8 )
+    ( line 3 , column 8 )
     (FuncCall
        (Ident (Identifier "linebreak"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -69,8 +30,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A B C ]), 
+A B C ]), 
                  linebreak(justify: true), 
                  text(body: [
 D E F ]), 
diff --git a/test/typ/layout/par-justify-03.out b/test/typ/layout/par-justify-03.out
--- a/test/typ/layout/par-justify-03.out
+++ b/test/typ/layout/par-justify-03.out
@@ -1,61 +1,25 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-03.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
-                                 "typ/layout/par-justify-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/layout/par-justify-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Literal (String ""))
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-justify-04.out b/test/typ/layout/par-justify-04.out
--- a/test/typ/layout/par-justify-04.out
+++ b/test/typ/layout/par-justify-04.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-04.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
-                                 "typ/layout/par-justify-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-justify-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 155.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
diff --git a/test/typ/layout/par-justify-cjk-00.out b/test/typ/layout/par-justify-cjk-00.out
--- a/test/typ/layout/par-justify-cjk-00.out
+++ b/test/typ/layout/par-justify-cjk-00.out
@@ -1,66 +1,29 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-cjk-00.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
-                                 "typ/layout/par-justify-cjk-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-cjk-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/par-justify-cjk-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -70,7 +33,7 @@
 , ParBreak
 , Code
     "typ/layout/par-justify-cjk-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt))
@@ -97,7 +60,10 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
+document(body: { parbreak(), 
+                 text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-justify-cjk-01.out b/test/typ/layout/par-justify-cjk-01.out
--- a/test/typ/layout/par-justify-cjk-01.out
+++ b/test/typ/layout/par-justify-cjk-01.out
@@ -1,69 +1,30 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-cjk-01.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
-                                 "typ/layout/par-justify-cjk-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-cjk-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-justify-cjk-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "jp")) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt))
diff --git a/test/typ/layout/par-justify-cjk-02.out b/test/typ/layout/par-justify-cjk-02.out
--- a/test/typ/layout/par-justify-cjk-02.out
+++ b/test/typ/layout/par-justify-cjk-02.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-cjk-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
-                                 "typ/layout/par-justify-cjk-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-cjk-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-justify-cjk-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "zh"))
@@ -59,14 +20,14 @@
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt))
diff --git a/test/typ/layout/par-justify-cjk-03.out b/test/typ/layout/par-justify-cjk-03.out
--- a/test/typ/layout/par-justify-cjk-03.out
+++ b/test/typ/layout/par-justify-cjk-03.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/par-justify-cjk-03.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
-                                 "typ/layout/par-justify-cjk-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-justify-cjk-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/par-justify-cjk-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg
@@ -58,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -68,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-justify-cjk-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -81,7 +42,7 @@
 , ParBreak
 , Code
     "typ/layout/par-justify-cjk-03.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -95,8 +56,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [
diff --git a/test/typ/layout/par-knuth-00.out b/test/typ/layout/par-knuth-00.out
--- a/test/typ/layout/par-knuth-00.out
+++ b/test/typ/layout/par-knuth-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/par-knuth-00.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
-                                 "typ/layout/par-knuth-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-knuth-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/par-knuth-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto)
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-knuth-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "leading") (Literal (Numeric 4.0 Pt))
@@ -59,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/layout/par-knuth-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -68,7 +28,7 @@
 , ParBreak
 , Code
     "typ/layout/par-knuth-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "story")))
        (Block
@@ -306,7 +266,7 @@
 , ParBreak
 , Code
     "typ/layout/par-knuth-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (LetFunc
        (Identifier "column")
        [ NormalParam (Identifier "title")
@@ -327,7 +287,7 @@
                      [ SoftBreak
                      , Code
                          "typ/layout/par-knuth-00.typ"
-                         ( line 19 , column 6 )
+                         ( line 18 , column 6 )
                          (Set
                             (Ident (Identifier "par"))
                             [ KeyValArg
@@ -336,7 +296,7 @@
                      , SoftBreak
                      , Code
                          "typ/layout/par-knuth-00.typ"
-                         ( line 20 , column 6 )
+                         ( line 19 , column 6 )
                          (Set
                             (Ident (Identifier "text"))
                             [ KeyValArg
@@ -345,7 +305,7 @@
                      , SoftBreak
                      , Code
                          "typ/layout/par-knuth-00.typ"
-                         ( line 21 , column 6 )
+                         ( line 20 , column 6 )
                          (FuncCall
                             (Ident (Identifier "strong"))
                             [ NormalArg (Ident (Identifier "title")) ])
@@ -353,7 +313,7 @@
                      , HardBreak
                      , Code
                          "typ/layout/par-knuth-00.typ"
-                         ( line 21 , column 23 )
+                         ( line 20 , column 23 )
                          (Ident (Identifier "story"))
                      , ParBreak
                      ]
@@ -362,7 +322,7 @@
 , ParBreak
 , Code
     "typ/layout/par-knuth-00.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg (Identifier "columns") (Literal (Int 3))
@@ -412,8 +372,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/layout/par-simple-00.out b/test/typ/layout/par-simple-00.out
--- a/test/typ/layout/par-simple-00.out
+++ b/test/typ/layout/par-simple-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/par-simple-00.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
-                                 "typ/layout/par-simple-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/par-simple-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/par-simple-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 250.0 Pt))
@@ -467,9 +427,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [But, soft! what light through yonder window breaks? It is the east, and Juliet
 is the sun. Arise, fair sun, and kill the envious moon, Who is already sick and
 pale with grief, That thou her maid art far more fair than she: Be not her maid,
diff --git a/test/typ/layout/place-00.out b/test/typ/layout/place-00.out
--- a/test/typ/layout/place-00.out
+++ b/test/typ/layout/place-00.out
@@ -2,52 +2,12 @@
 [ Code
     "typ/layout/place-00.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
-                                 "typ/layout/place-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/place-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/place-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page")) [ NormalArg (Literal (String "a8")) ])
 , SoftBreak
 , Code
     "typ/layout/place-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ NormalArg
@@ -56,9 +16,10 @@
        ])
 , ParBreak
 , Heading 1 [ Text "Placement" ]
+, SoftBreak
 , Code
     "typ/layout/place-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ NormalArg (Ident (Identifier "right"))
@@ -112,7 +73,7 @@
 , ParBreak
 , Code
     "typ/layout/place-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ NormalArg
@@ -151,7 +112,7 @@
                   [ SoftBreak
                   , Code
                       "typ/layout/place-00.typ"
-                      ( line 19 , column 6 )
+                      ( line 18 , column 6 )
                       (FuncCall
                          (Ident (Identifier "place"))
                          [ NormalArg (Ident (Identifier "center"))
@@ -162,7 +123,7 @@
                   , SoftBreak
                   , Code
                       "typ/layout/place-00.typ"
-                      ( line 20 , column 6 )
+                      ( line 19 , column 6 )
                       (FuncCall
                          (Ident (Identifier "place"))
                          [ NormalArg (Ident (Identifier "center"))
@@ -175,7 +136,7 @@
                   , Space
                   , Code
                       "typ/layout/place-00.typ"
-                      ( line 21 , column 12 )
+                      ( line 20 , column 12 )
                       (FuncCall
                          (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
                   , Space
@@ -188,8 +149,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  place(alignment: Axes(center, bottom), 
                        body: text(body: [© Typst])), 
diff --git a/test/typ/layout/place-01.out b/test/typ/layout/place-01.out
--- a/test/typ/layout/place-01.out
+++ b/test/typ/layout/place-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/place-01.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
-                                 "typ/layout/place-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/place-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/place-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a8"))
@@ -53,7 +14,7 @@
 , ParBreak
 , Code
     "typ/layout/place-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ NormalArg
diff --git a/test/typ/layout/place-background-00.out b/test/typ/layout/place-background-00.out
--- a/test/typ/layout/place-background-00.out
+++ b/test/typ/layout/place-background-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/place-background-00.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
-                                 "typ/layout/place-background-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/place-background-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/place-background-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "paper") (Literal (String "a10"))
@@ -50,14 +10,14 @@
 , SoftBreak
 , Code
     "typ/layout/place-background-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "white")) ])
 , SoftBreak
 , Code
     "typ/layout/place-background-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "place"))
        [ KeyValArg (Identifier "dx") (Negated (Literal (Numeric 10.0 Pt)))
@@ -80,7 +40,7 @@
 , SoftBreak
 , Code
     "typ/layout/place-background-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg
@@ -91,7 +51,7 @@
            , Space
            , Code
                "typ/layout/place-background-00.typ"
-               ( line 15 , column 17 )
+               ( line 14 , column 17 )
                (FuncCall
                   (Ident (Identifier "underline"))
                   [ BlockArg [ Strong [ Text "Tigerland" ] ] ])
@@ -102,8 +62,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ], 
diff --git a/test/typ/layout/repeat-00.out b/test/typ/layout/repeat-00.out
--- a/test/typ/layout/repeat-00.out
+++ b/test/typ/layout/repeat-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/repeat-00.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
-                                 "typ/layout/repeat-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/repeat-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/repeat-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "sections")))
        (Array
@@ -68,7 +29,7 @@
 , ParBreak
 , Code
     "typ/layout/repeat-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (For
        (BasicBind (Just (Identifier "section")))
        (Ident (Identifier "sections"))
@@ -77,7 +38,7 @@
              [ SoftBreak
              , Code
                  "typ/layout/repeat-00.typ"
-                 ( line 13 , column 4 )
+                 ( line 12 , column 4 )
                  (FuncCall
                     (FieldAccess
                        (Ident (Identifier "at")) (Ident (Identifier "section")))
@@ -85,7 +46,7 @@
              , Space
              , Code
                  "typ/layout/repeat-00.typ"
-                 ( line 13 , column 19 )
+                 ( line 12 , column 19 )
                  (FuncCall
                     (Ident (Identifier "box"))
                     [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -95,7 +56,7 @@
              , Space
              , Code
                  "typ/layout/repeat-00.typ"
-                 ( line 13 , column 47 )
+                 ( line 12 , column 47 )
                  (FuncCall
                     (FieldAccess
                        (Ident (Identifier "at")) (Ident (Identifier "section")))
diff --git a/test/typ/layout/repeat-01.out b/test/typ/layout/repeat-01.out
--- a/test/typ/layout/repeat-01.out
+++ b/test/typ/layout/repeat-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/repeat-01.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
-                                 "typ/layout/repeat-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/repeat-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/repeat-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ar")) ])
@@ -51,7 +12,7 @@
 , Space
 , Code
     "typ/layout/repeat-01.typ"
-    ( line 4 , column 8 )
+    ( line 3 , column 8 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
diff --git a/test/typ/layout/repeat-02.out b/test/typ/layout/repeat-02.out
--- a/test/typ/layout/repeat-02.out
+++ b/test/typ/layout/repeat-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/layout/repeat-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
-                                 "typ/layout/repeat-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/repeat-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Space
 , Code
     "typ/layout/repeat-02.typ"
-    ( line 3 , column 4 )
+    ( line 2 , column 4 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -57,8 +18,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A ]), 
+A ]), 
                  box(body: repeat(body: {  }), 
                      width: 1.0fr), 
                  text(body: [ B]), 
diff --git a/test/typ/layout/repeat-03.out b/test/typ/layout/repeat-03.out
--- a/test/typ/layout/repeat-03.out
+++ b/test/typ/layout/repeat-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/repeat-03.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
-                                 "typ/layout/repeat-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/repeat-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/repeat-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "repeat"))
        [ NormalArg
diff --git a/test/typ/layout/repeat-04.out b/test/typ/layout/repeat-04.out
--- a/test/typ/layout/repeat-04.out
+++ b/test/typ/layout/repeat-04.out
@@ -1,49 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/layout/repeat-04.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
-                                 "typ/layout/repeat-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/repeat-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Code
     "typ/layout/repeat-04.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -62,7 +23,7 @@
 , ParBreak
 , Code
     "typ/layout/repeat-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
@@ -70,7 +31,7 @@
 , Text "A"
 , Code
     "typ/layout/repeat-04.typ"
-    ( line 6 , column 3 )
+    ( line 5 , column 3 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -89,7 +50,7 @@
 , ParBreak
 , Code
     "typ/layout/repeat-04.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
@@ -97,7 +58,7 @@
 , Text "\1585\1610\1580\1610\1606"
 , Code
     "typ/layout/repeat-04.typ"
-    ( line 9 , column 7 )
+    ( line 8 , column 7 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -117,8 +78,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
+A]), 
                  box(body: repeat(body: rect(height: 0.7em, 
                                              width: 6.0em)), 
                      width: 1.0fr), 
diff --git a/test/typ/layout/spacing-00.out b/test/typ/layout/spacing-00.out
--- a/test/typ/layout/spacing-00.out
+++ b/test/typ/layout/spacing-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/spacing-00.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
-                                 "typ/layout/spacing-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/spacing-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ BlockArg [ Text "A" , Space , HardBreak , Text "B" ] ])
 , Space
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 3 , column 14 )
+    ( line 2 , column 14 )
     (FuncCall
        (Ident (Identifier "box"))
        [ BlockArg
@@ -57,7 +18,7 @@
            , Space
            , Code
                "typ/layout/spacing-00.typ"
-               ( line 3 , column 21 )
+               ( line 2 , column 21 )
                (FuncCall
                   (Ident (Identifier "v"))
                   [ NormalArg (Literal (Numeric 0.65 Em))
@@ -69,35 +30,38 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Inv"
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 6 , column 5 )
+    ( line 5 , column 5 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 0.0 Pt)) ])
 , Text "isible"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Add"
 , Space
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 9 , column 6 )
+    ( line 8 , column 6 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 10.0 Pt)) ])
 , Space
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 9 , column 15 )
+    ( line 8 , column 15 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 10.0 Pt)) ])
 , Space
 , Text "up"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (Minus
@@ -106,35 +70,36 @@
 , Text "|"
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 13 , column 3 )
+    ( line 12 , column 3 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Ident (Identifier "x")) ])
 , Text "|"
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 13 , column 9 )
+    ( line 12 , column 9 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Ident (Identifier "x")) ])
 , Text "|"
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 13 , column 15 )
+    ( line 12 , column 15 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Ident (Identifier "x")) ])
 , Text "|"
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 13 , column 21 )
+    ( line 12 , column 21 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Ident (Identifier "x")) ])
 , Text "|"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "|"
 , Space
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 16 , column 4 )
+    ( line 15 , column 4 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -142,7 +107,7 @@
 , Space
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 16 , column 14 )
+    ( line 15 , column 14 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 2.0 Fr)) ])
 , Space
@@ -150,7 +115,7 @@
 , Space
 , Code
     "typ/layout/spacing-00.typ"
-    ( line 16 , column 24 )
+    ( line 15 , column 24 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -169,17 +134,21 @@
                                weak: true), 
                              text(body: [ B]) }), 
                  parbreak(), 
-                 text(body: [Inv]), 
+                 text(body: [
+Inv]), 
                  h(amount: 0.0pt), 
                  text(body: [isible]), 
                  parbreak(), 
-                 text(body: [Add ]), 
+                 text(body: [
+Add ]), 
                  h(amount: 10.0pt), 
                  text(body: [ ]), 
                  h(amount: 10.0pt), 
                  text(body: [ up]), 
                  parbreak(), 
                  text(body: [
+]), 
+                 text(body: [
 |]), 
                  h(amount: -4.0pt + 25%), 
                  text(body: [|]), 
@@ -190,7 +159,8 @@
                  h(amount: -4.0pt + 25%), 
                  text(body: [|]), 
                  parbreak(), 
-                 text(body: [| ]), 
+                 text(body: [
+| ]), 
                  h(amount: 1.0fr), 
                  text(body: [ | ]), 
                  h(amount: 2.0fr), 
diff --git a/test/typ/layout/spacing-01.out b/test/typ/layout/spacing-01.out
--- a/test/typ/layout/spacing-01.out
+++ b/test/typ/layout/spacing-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/spacing-01.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
-                                 "typ/layout/spacing-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/spacing-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/spacing-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "right")) ])
@@ -51,7 +12,7 @@
 , Space
 , Code
     "typ/layout/spacing-01.typ"
-    ( line 4 , column 4 )
+    ( line 3 , column 4 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 0.0 Pt)) ])
 , Space
@@ -59,7 +20,7 @@
 , Space
 , Code
     "typ/layout/spacing-01.typ"
-    ( line 4 , column 14 )
+    ( line 3 , column 14 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 0.0 Pt)) ])
 , Space
@@ -73,7 +34,7 @@
 , Space
 , Code
     "typ/layout/spacing-01.typ"
-    ( line 6 , column 4 )
+    ( line 5 , column 4 )
     (FuncCall
        (Ident (Identifier "h"))
        [ NormalArg (Negated (Literal (Numeric 1.0 Fr))) ])
diff --git a/test/typ/layout/spacing-02.out b/test/typ/layout/spacing-02.out
--- a/test/typ/layout/spacing-02.out
+++ b/test/typ/layout/spacing-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/spacing-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
-                                 "typ/layout/spacing-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/spacing-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/spacing-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
@@ -51,7 +12,7 @@
 , Space
 , Code
     "typ/layout/spacing-02.typ"
-    ( line 4 , column 4 )
+    ( line 3 , column 4 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 10.0 Pt)) ])
 , Space
@@ -62,7 +23,7 @@
 , Space
 , Code
     "typ/layout/spacing-02.typ"
-    ( line 5 , column 4 )
+    ( line 4 , column 4 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
diff --git a/test/typ/layout/stack-1-00.out b/test/typ/layout/stack-1-00.out
--- a/test/typ/layout/stack-1-00.out
+++ b/test/typ/layout/stack-1-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/stack-1-00.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
-                                 "typ/layout/stack-1-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/stack-1-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/stack-1-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "widths")))
        (Array
@@ -58,7 +19,7 @@
 , ParBreak
 , Code
     "typ/layout/stack-1-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (LetFunc
        (Identifier "shaded")
        [ NormalParam (Identifier "i") , NormalParam (Identifier "w") ]
@@ -86,13 +47,13 @@
 , ParBreak
 , Code
     "typ/layout/stack-1-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Let
        (BasicBind (Just (Identifier "items")))
        (For
           (DestructuringBind
-             [ Simple (Just (Identifier "i"))
-             , Simple (Just (Identifier "w"))
+             [ Simple (BasicBind (Just (Identifier "i")))
+             , Simple (BasicBind (Just (Identifier "w")))
              ])
           (FuncCall
              (FieldAccess
@@ -117,7 +78,7 @@
 , ParBreak
 , Code
     "typ/layout/stack-1-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Pt))
@@ -126,7 +87,7 @@
 , SoftBreak
 , Code
     "typ/layout/stack-1-00.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "btt"))
diff --git a/test/typ/layout/stack-1-01.out b/test/typ/layout/stack-1-01.out
--- a/test/typ/layout/stack-1-01.out
+++ b/test/typ/layout/stack-1-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/stack-1-01.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
-                                 "typ/layout/stack-1-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/stack-1-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/stack-1-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Pt))
@@ -51,7 +12,7 @@
 , ParBreak
 , Code
     "typ/layout/stack-1-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (FuncCall
@@ -62,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/layout/stack-1-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 5.0 Pt))
diff --git a/test/typ/layout/stack-1-02.out b/test/typ/layout/stack-1-02.out
--- a/test/typ/layout/stack-1-02.out
+++ b/test/typ/layout/stack-1-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/stack-1-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
-                                 "typ/layout/stack-1-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/stack-1-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/stack-1-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Pt))
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/layout/stack-1-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/layout/stack-1-03.out b/test/typ/layout/stack-1-03.out
--- a/test/typ/layout/stack-1-03.out
+++ b/test/typ/layout/stack-1-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/stack-1-03.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
-                                 "typ/layout/stack-1-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/stack-1-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/stack-1-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Pt))
@@ -51,21 +12,21 @@
 , SoftBreak
 , Code
     "typ/layout/stack-1-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "block"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 5.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/stack-1-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/stack-1-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl"))
@@ -78,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/layout/stack-1-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl"))
diff --git a/test/typ/layout/stack-2-00.out b/test/typ/layout/stack-2-00.out
--- a/test/typ/layout/stack-2-00.out
+++ b/test/typ/layout/stack-2-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/layout/stack-2-00.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
-                                 "typ/layout/stack-2-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/stack-2-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/stack-2-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 3.5 Cm)) ])
 , SoftBreak
 , Code
     "typ/layout/stack-2-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
@@ -65,7 +25,7 @@
                                (Content
                                   [ Code
                                       "typ/layout/stack-2-00.typ"
-                                      ( line 6 , column 30 )
+                                      ( line 5 , column 30 )
                                       (Ident (Identifier "c"))
                                   ]))
                         ]
@@ -76,7 +36,7 @@
 , SoftBreak
 , Code
     "typ/layout/stack-2-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 2.0 Fr)) ])
 , SoftBreak
@@ -84,7 +44,7 @@
 , Space
 , Code
     "typ/layout/stack-2-00.typ"
-    ( line 11 , column 7 )
+    ( line 10 , column 7 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -92,7 +52,7 @@
 , Space
 , Code
     "typ/layout/stack-2-00.typ"
-    ( line 11 , column 19 )
+    ( line 10 , column 19 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , Space
@@ -100,7 +60,7 @@
 , SoftBreak
 , Code
     "typ/layout/stack-2-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
 , SoftBreak
@@ -111,8 +71,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  stack(children: (text(body: [A]), 
                                   text(body: [B]), 
diff --git a/test/typ/layout/stack-2-01.out b/test/typ/layout/stack-2-01.out
--- a/test/typ/layout/stack-2-01.out
+++ b/test/typ/layout/stack-2-01.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/layout/stack-2-01.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
-                                 "typ/layout/stack-2-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/stack-2-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/stack-2-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 2.0 Cm)) ])
 , SoftBreak
 , Code
     "typ/layout/stack-2-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Ident (Identifier "white")) ])
 , SoftBreak
 , Code
     "typ/layout/stack-2-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -63,13 +23,13 @@
            [ SoftBreak
            , Code
                "typ/layout/stack-2-01.typ"
-               ( line 5 , column 12 )
+               ( line 4 , column 12 )
                (FuncCall
                   (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
            , SoftBreak
            , Code
                "typ/layout/stack-2-01.typ"
-               ( line 6 , column 4 )
+               ( line 5 , column 4 )
                (FuncCall
                   (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Fr)) ])
            , Space
@@ -83,8 +43,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ], 
diff --git a/test/typ/layout/table-00.out b/test/typ/layout/table-00.out
--- a/test/typ/layout/table-00.out
+++ b/test/typ/layout/table-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/layout/table-00.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
-                                 "typ/layout/table-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/table-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/table-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 70.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/table-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -73,7 +33,7 @@
 , ParBreak
 , Code
     "typ/layout/table-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -113,8 +73,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  table(children: (text(body: [A]), 
diff --git a/test/typ/layout/table-01.out b/test/typ/layout/table-01.out
--- a/test/typ/layout/table-01.out
+++ b/test/typ/layout/table-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/layout/table-01.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
-                                 "typ/layout/table-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/table-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/layout/table-01.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 3))
@@ -54,9 +14,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 table(children: (text(body: [A]), 
+document(body: { table(children: (text(body: [A]), 
                                   text(body: [B]), 
                                   text(body: [C])), 
                        columns: 3, 
diff --git a/test/typ/layout/table-02.out b/test/typ/layout/table-02.out
--- a/test/typ/layout/table-02.out
+++ b/test/typ/layout/table-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/table-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
-                                 "typ/layout/table-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/table-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/table-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -65,16 +26,17 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/layout/table-02.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
 , SoftBreak
 , Code
     "typ/layout/table-02.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -104,6 +66,8 @@
                                  1.0fr, 
                                  1.0fr)), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  table(align: (), 
diff --git a/test/typ/layout/table-03.out b/test/typ/layout/table-03.out
--- a/test/typ/layout/table-03.out
+++ b/test/typ/layout/table-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/table-03.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
-                                 "typ/layout/table-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/table-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/table-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall (Ident (Identifier "table")) [])
 , ParBreak
 ]
diff --git a/test/typ/layout/terms-00.out b/test/typ/layout/terms-00.out
--- a/test/typ/layout/terms-00.out
+++ b/test/typ/layout/terms-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/terms-00.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
-                                 "typ/layout/terms-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/terms-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/terms-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "terms"))
        [ NormalArg
diff --git a/test/typ/layout/terms-01.out b/test/typ/layout/terms-01.out
--- a/test/typ/layout/terms-01.out
+++ b/test/typ/layout/terms-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/terms-01.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
-                                 "typ/layout/terms-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/terms-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/terms-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "word")))
        (FuncCall
@@ -67,10 +28,11 @@
              , DescListItem
                  [ Code
                      "typ/layout/terms-01.typ"
-                     ( line 4 , column 6 )
+                     ( line 3 , column 6 )
                      (Ident (Identifier "word"))
                  ]
-                 [ Text "Latin" , Space , Text "stuff" , Text "." , ParBreak ]
+                 [ Text "Latin" , Space , Text "stuff" , Text "." ]
+             , ParBreak
              ])))
 , ParBreak
 ]
@@ -80,21 +42,17 @@
                  text(body: [
 ]), 
                  terms(children: ((text(body: [Lorem]), 
-                                   { text(body: [Latin stuff.]), 
-                                     parbreak() }))), 
+                                   text(body: [Latin stuff.])))), 
                  text(body: [
 ]), 
                  terms(children: ((text(body: [ipsum]), 
-                                   { text(body: [Latin stuff.]), 
-                                     parbreak() }))), 
+                                   text(body: [Latin stuff.])))), 
                  text(body: [
 ]), 
                  terms(children: ((text(body: [dolor]), 
-                                   { text(body: [Latin stuff.]), 
-                                     parbreak() }))), 
+                                   text(body: [Latin stuff.])))), 
                  text(body: [
 ]), 
                  terms(children: ((text(body: [sit]), 
-                                   { text(body: [Latin stuff.]), 
-                                     parbreak() }))), 
+                                   text(body: [Latin stuff.])))), 
                  parbreak() })
diff --git a/test/typ/layout/terms-02.out b/test/typ/layout/terms-02.out
--- a/test/typ/layout/terms-02.out
+++ b/test/typ/layout/terms-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/terms-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
-                                 "typ/layout/terms-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/terms-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/terms-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt)) ])
@@ -61,8 +22,7 @@
 , SoftBreak
 , DescListItem
     [ Text "Veggie" ]
-    [ SoftBreak
-    , Text "An"
+    [ Text "An"
     , Space
     , Text "important"
     , Space
@@ -74,8 +34,8 @@
     , Space
     , Text "vegetarians"
     , Text "."
-    , ParBreak
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -87,8 +47,6 @@
                                         size: 8.0pt)), 
                                   (text(body: [Veggie], 
                                         size: 8.0pt), 
-                                   { text(body: [
-An important energy source
+                                   text(body: [An important energy source
 for vegetarians.], 
-                                          size: 8.0pt), 
-                                     parbreak() }))) })
+                                        size: 8.0pt)))) })
diff --git a/test/typ/layout/terms-03.out b/test/typ/layout/terms-03.out
--- a/test/typ/layout/terms-03.out
+++ b/test/typ/layout/terms-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/terms-03.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
-                                 "typ/layout/terms-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/terms-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/terms-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt)) ])
@@ -51,15 +12,14 @@
     [ Text "First" , Space , Text "list" ]
     [ Code
         "typ/layout/terms-03.typ"
-        ( line 4 , column 16 )
+        ( line 3 , column 16 )
         (FuncCall
            (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 6)) ])
-    , SoftBreak
     ]
-, SoftBreak
+, ParBreak
 , Code
     "typ/layout/terms-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "terms"))
        [ KeyValArg
@@ -70,11 +30,11 @@
     [ Text "Second" , Space , Text "list" ]
     [ Code
         "typ/layout/terms-03.typ"
-        ( line 7 , column 17 )
+        ( line 6 , column 17 )
         (FuncCall
            (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 5)) ])
-    , ParBreak
     ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -83,16 +43,12 @@
 ], size: 8.0pt), 
                  terms(children: ((text(body: [First list], 
                                         size: 8.0pt), 
-                                   { text(body: [Lorem ipsum dolor sit amet, consectetur], 
-                                          size: 8.0pt), 
-                                     text(body: [
-], 
-                                          size: 8.0pt) }))), 
+                                   text(body: [Lorem ipsum dolor sit amet, consectetur], 
+                                        size: 8.0pt)))), 
                  text(body: [
 ], size: 8.0pt), 
                  terms(children: ((text(body: [Second list], 
                                         size: 8.0pt), 
-                                   { text(body: [Lorem ipsum dolor sit amet,], 
-                                          size: 8.0pt), 
-                                     parbreak() })), 
+                                   text(body: [Lorem ipsum dolor sit amet,], 
+                                        size: 8.0pt))), 
                        hanging-indent: 30.0pt) })
diff --git a/test/typ/layout/terms-04.out b/test/typ/layout/terms-04.out
--- a/test/typ/layout/terms-04.out
+++ b/test/typ/layout/terms-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/terms-04.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
-                                 "typ/layout/terms-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/terms-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/terms-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "terms")))
        (FuncExpr
@@ -87,7 +48,8 @@
     [ Text "BB" ] [ Text "Two" , Space , Text "letters" ]
 , SoftBreak
 , DescListItem
-    [ Text "CCC" ] [ Text "Three" , Space , Text "letters" , ParBreak ]
+    [ Text "CCC" ] [ Text "Three" , Space , Text "letters" ]
+, ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
@@ -98,7 +60,6 @@
                                   emph(body: text(body: [BB])), 
                                   text(body: [Two letters]), 
                                   emph(body: text(body: [CCC])), 
-                                  { text(body: [Three letters]), 
-                                    parbreak() }), 
+                                  text(body: [Three letters])), 
                        columns: 2, 
                        inset: 3.0pt) })
diff --git a/test/typ/layout/terms-05.out b/test/typ/layout/terms-05.out
--- a/test/typ/layout/terms-05.out
+++ b/test/typ/layout/terms-05.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/layout/terms-05.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
-                                 "typ/layout/terms-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/terms-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, DescListItem [ Text "Term" ] []
+[ DescListItem [ Text "Term" ] []
 , SoftBreak
 , Text "Not"
 , Space
@@ -52,9 +12,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 terms(children: ((text(body: [Term]), 
+document(body: { terms(children: ((text(body: [Term]), 
                                    {  }))), 
                  text(body: [Not in list
 /Nope]), 
diff --git a/test/typ/layout/transform-00.out b/test/typ/layout/transform-00.out
--- a/test/typ/layout/transform-00.out
+++ b/test/typ/layout/transform-00.out
@@ -1,54 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/layout/transform-00.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
-                                 "typ/layout/transform-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/transform-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/transform-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "size"))) (Literal (Numeric 11.0 Pt)))
 , SoftBreak
 , Code
     "typ/layout/transform-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "tex")))
        (Block
@@ -82,7 +43,7 @@
 , ParBreak
 , Code
     "typ/layout/transform-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Let
        (BasicBind (Just (Identifier "xetex")))
        (Block
@@ -146,7 +107,7 @@
 , ParBreak
 , Code
     "typ/layout/transform-00.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -158,7 +119,7 @@
 , Space
 , Code
     "typ/layout/transform-00.typ"
-    ( line 25 , column 10 )
+    ( line 24 , column 10 )
     (Ident (Identifier "tex"))
 , Text ","
 , Space
@@ -167,7 +128,7 @@
 , Space
 , Code
     "typ/layout/transform-00.typ"
-    ( line 26 , column 6 )
+    ( line 25 , column 6 )
     (Ident (Identifier "xetex"))
 , Text "!"
 , ParBreak
diff --git a/test/typ/layout/transform-01.out b/test/typ/layout/transform-01.out
--- a/test/typ/layout/transform-01.out
+++ b/test/typ/layout/transform-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/layout/transform-01.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
-                                 "typ/layout/transform-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/transform-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/transform-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 80.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/transform-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg
diff --git a/test/typ/layout/transform-02.out b/test/typ/layout/transform-02.out
--- a/test/typ/layout/transform-02.out
+++ b/test/typ/layout/transform-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/transform-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
-                                 "typ/layout/transform-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/transform-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/transform-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rotate"))
        [ NormalArg (Literal (Numeric 10.0 Deg))
diff --git a/test/typ/layout/transform-03.out b/test/typ/layout/transform-03.out
--- a/test/typ/layout/transform-03.out
+++ b/test/typ/layout/transform-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/layout/transform-03.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
-                                 "typ/layout/transform-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/layout/transform-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/layout/transform-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "r")))
        (FuncCall
@@ -54,14 +15,14 @@
 , SoftBreak
 , Code
     "typ/layout/transform-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 65.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/layout/transform-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -78,7 +39,7 @@
 , SoftBreak
 , Code
     "typ/layout/transform-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -92,7 +53,7 @@
 , SoftBreak
 , Code
     "typ/layout/transform-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/math/accent-00.out b/test/typ/math/accent-00.out
--- a/test/typ/math/accent-00.out
+++ b/test/typ/math/accent-00.out
@@ -1,109 +1,70 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-00.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
-                                 "typ/math/accent-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Code
         "typ/math/accent-00.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FuncCall (Ident (Identifier "grave")) [ BlockArg [ Text "a" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 3 , column 12 )
+        ( line 2 , column 12 )
         (FuncCall (Ident (Identifier "acute")) [ BlockArg [ Text "b" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 3 , column 22 )
+        ( line 2 , column 22 )
         (FuncCall (Ident (Identifier "hat")) [ BlockArg [ Text "f" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 3 , column 30 )
+        ( line 2 , column 30 )
         (FuncCall
            (Ident (Identifier "tilde")) [ BlockArg [ Text "\167" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 3 , column 40 )
+        ( line 2 , column 40 )
         (FuncCall
            (Ident (Identifier "macron")) [ BlockArg [ Text "\228" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 3 , column 51 )
+        ( line 2 , column 51 )
         (FuncCall (Ident (Identifier "diaer")) [ BlockArg [ Text "a" ] ])
     , Text ","
     , Text "\228"
     , HardBreak
     , Code
         "typ/math/accent-00.typ"
-        ( line 4 , column 2 )
+        ( line 3 , column 2 )
         (FuncCall (Ident (Identifier "breve")) [ BlockArg [ Text "&" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 4 , column 13 )
+        ( line 3 , column 13 )
         (FuncCall (Ident (Identifier "dot")) [ BlockArg [ Text "!" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 4 , column 21 )
+        ( line 3 , column 21 )
         (FuncCall (Ident (Identifier "circle")) [ BlockArg [ Text "a" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 4 , column 32 )
+        ( line 3 , column 32 )
         (FuncCall (Ident (Identifier "caron")) [ BlockArg [ Text "@" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 4 , column 42 )
+        ( line 3 , column 42 )
         (FuncCall (Ident (Identifier "arrow")) [ BlockArg [ Text "Z" ] ])
     , Text ","
     , Code
         "typ/math/accent-00.typ"
-        ( line 4 , column 52 )
+        ( line 3 , column 52 )
         (FuncCall
            (FieldAccess (Ident (Identifier "l")) (Ident (Identifier "arrow")))
            [ BlockArg [ Text "Z" ] ])
diff --git a/test/typ/math/accent-01.out b/test/typ/math/accent-01.out
--- a/test/typ/math/accent-01.out
+++ b/test/typ/math/accent-01.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-01.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
-                                 "typ/math/accent-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ Text "x"
     , MAlignPoint
@@ -48,7 +8,7 @@
     , HardBreak
     , Code
         "typ/math/accent-01.typ"
-        ( line 2 , column 12 )
+        ( line 1 , column 12 )
         (FuncCall (Ident (Identifier "dot")) [ BlockArg [ Text "x" ] ])
     , MAlignPoint
     , Text "="
@@ -56,7 +16,7 @@
     , HardBreak
     , Code
         "typ/math/accent-01.typ"
-        ( line 2 , column 26 )
+        ( line 1 , column 26 )
         (FuncCall
            (FieldAccess
               (Ident (Identifier "double")) (Ident (Identifier "dot")))
@@ -67,7 +27,7 @@
     , HardBreak
     , Code
         "typ/math/accent-01.typ"
-        ( line 2 , column 47 )
+        ( line 1 , column 47 )
         (FuncCall
            (FieldAccess
               (Ident (Identifier "triple")) (Ident (Identifier "dot")))
@@ -78,7 +38,7 @@
     , HardBreak
     , Code
         "typ/math/accent-01.typ"
-        ( line 2 , column 68 )
+        ( line 1 , column 68 )
         (FuncCall
            (FieldAccess
               (Ident (Identifier "quad")) (Ident (Identifier "dot")))
@@ -90,9 +50,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: { text(body: [x]), 
                                        math.alignpoint(), 
                                        text(body: [=]), 
diff --git a/test/typ/math/accent-02.out b/test/typ/math/accent-02.out
--- a/test/typ/math/accent-02.out
+++ b/test/typ/math/accent-02.out
@@ -1,77 +1,38 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-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
-                                 "typ/math/accent-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Code
         "typ/math/accent-02.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FuncCall
            (Ident (Identifier "accent"))
            [ BlockArg [ Text "\246" ] , BlockArg [ Text "." ] ])
     , Text ","
     , Code
         "typ/math/accent-02.typ"
-        ( line 3 , column 16 )
+        ( line 2 , column 16 )
         (FuncCall
            (Ident (Identifier "accent"))
            [ BlockArg [ Text "v" ]
            , BlockArg
                [ Code
                    "typ/math/accent-02.typ"
-                   ( line 3 , column 26 )
+                   ( line 2 , column 26 )
                    (FieldAccess (Ident (Identifier "l")) (Ident (Identifier "arrow")))
                ]
            ])
     , Text ","
     , Code
         "typ/math/accent-02.typ"
-        ( line 3 , column 31 )
+        ( line 2 , column 31 )
         (FuncCall
            (Ident (Identifier "accent"))
            [ BlockArg
                [ Code
                    "typ/math/accent-02.typ"
-                   ( line 3 , column 38 )
+                   ( line 2 , column 38 )
                    (Ident (Identifier "ZZ"))
                ]
            , BlockArg [ Text "\771" ]
diff --git a/test/typ/math/accent-03.out b/test/typ/math/accent-03.out
--- a/test/typ/math/accent-03.out
+++ b/test/typ/math/accent-03.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-03.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
-                                 "typ/math/accent-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Code
         "typ/math/accent-03.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
                [ Code
                    "typ/math/accent-03.typ"
-                   ( line 3 , column 7 )
+                   ( line 2 , column 7 )
                    (FuncCall (Ident (Identifier "tilde")) [ BlockArg [ Text "T" ] ])
                ]
            ])
@@ -58,11 +19,11 @@
     , MFrac
         (Code
            "typ/math/accent-03.typ"
-           ( line 3 , column 19 )
+           ( line 2 , column 19 )
            (FuncCall (Ident (Identifier "hat")) [ BlockArg [ Text "f" ] ]))
         (Code
            "typ/math/accent-03.typ"
-           ( line 3 , column 26 )
+           ( line 2 , column 26 )
            (FuncCall (Ident (Identifier "hat")) [ BlockArg [ Text "g" ] ]))
     ]
 , ParBreak
diff --git a/test/typ/math/accent-04.out b/test/typ/math/accent-04.out
--- a/test/typ/math/accent-04.out
+++ b/test/typ/math/accent-04.out
@@ -1,63 +1,24 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-04.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
-                                 "typ/math/accent-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Code
         "typ/math/accent-04.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FuncCall
            (Ident (Identifier "arrow"))
            [ BlockArg [ Text "ABC " , Text "+" , Text "d" ] ])
     , Text ","
     , Code
         "typ/math/accent-04.typ"
-        ( line 3 , column 20 )
+        ( line 2 , column 20 )
         (FuncCall
            (Ident (Identifier "tilde"))
            [ BlockArg
                [ Code
                    "typ/math/accent-04.typ"
-                   ( line 3 , column 26 )
+                   ( line 2 , column 26 )
                    (Ident (Identifier "sum"))
                ]
            ])
diff --git a/test/typ/math/accent-05.out b/test/typ/math/accent-05.out
--- a/test/typ/math/accent-05.out
+++ b/test/typ/math/accent-05.out
@@ -1,75 +1,36 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-05.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
-                                 "typ/math/accent-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ MAttach Nothing (Just (Text "x")) (Text "A")
     , Code
         "typ/math/accent-05.typ"
-        ( line 3 , column 6 )
+        ( line 2 , column 6 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MAttach
         Nothing
         (Just (Text "x"))
         (Code
            "typ/math/accent-05.typ"
-           ( line 3 , column 9 )
+           ( line 2 , column 9 )
            (FuncCall (Ident (Identifier "hat")) [ BlockArg [ Text "A" ] ]))
     , Code
         "typ/math/accent-05.typ"
-        ( line 3 , column 18 )
+        ( line 2 , column 18 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MAttach
         Nothing
         (Just (Text "x"))
         (Code
            "typ/math/accent-05.typ"
-           ( line 3 , column 21 )
+           ( line 2 , column 21 )
            (FuncCall
               (Ident (Identifier "hat"))
               [ BlockArg
                   [ Code
                       "typ/math/accent-05.typ"
-                      ( line 3 , column 25 )
+                      ( line 2 , column 25 )
                       (FuncCall (Ident (Identifier "hat")) [ BlockArg [ Text "A" ] ])
                   ]
               ]))
diff --git a/test/typ/math/accent-06.out b/test/typ/math/accent-06.out
--- a/test/typ/math/accent-06.out
+++ b/test/typ/math/accent-06.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/math/accent-06.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
-                                 "typ/math/accent-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/accent-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/accent-06.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "tilde"))
            [ BlockArg
                [ Code
                    "typ/math/accent-06.typ"
-                   ( line 3 , column 9 )
+                   ( line 2 , column 9 )
                    (Ident (Identifier "integral"))
                ]
            ])
@@ -60,20 +21,20 @@
         (Just (Text "b"))
         (Code
            "typ/math/accent-06.typ"
-           ( line 3 , column 20 )
+           ( line 2 , column 20 )
            (FuncCall
               (Ident (Identifier "tilde"))
               [ BlockArg
                   [ Code
                       "typ/math/accent-06.typ"
-                      ( line 3 , column 26 )
+                      ( line 2 , column 26 )
                       (Ident (Identifier "integral"))
                   ]
               ]))
     , Text ","
     , Code
         "typ/math/accent-06.typ"
-        ( line 3 , column 41 )
+        ( line 2 , column 41 )
         (FuncCall
            (Ident (Identifier "tilde"))
            [ BlockArg
@@ -82,7 +43,7 @@
                    (Just (Text "b"))
                    (Code
                       "typ/math/accent-06.typ"
-                      ( line 3 , column 47 )
+                      ( line 2 , column 47 )
                       (Ident (Identifier "integral")))
                ]
            ])
diff --git a/test/typ/math/alignment-00.out b/test/typ/math/alignment-00.out
--- a/test/typ/math/alignment-00.out
+++ b/test/typ/math/alignment-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/alignment-00.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
-                                 "typ/math/alignment-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/alignment-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/alignment-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 225.0 Pt)) ])
diff --git a/test/typ/math/alignment-01.out b/test/typ/math/alignment-01.out
--- a/test/typ/math/alignment-01.out
+++ b/test/typ/math/alignment-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/alignment-01.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
-                                 "typ/math/alignment-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/alignment-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAlignPoint
diff --git a/test/typ/math/alignment-02.out b/test/typ/math/alignment-02.out
--- a/test/typ/math/alignment-02.out
+++ b/test/typ/math/alignment-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/alignment-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
-                                 "typ/math/alignment-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/alignment-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text " right "
diff --git a/test/typ/math/alignment-03.out b/test/typ/math/alignment-03.out
--- a/test/typ/math/alignment-03.out
+++ b/test/typ/math/alignment-03.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/alignment-03.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
-                                 "typ/math/alignment-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/alignment-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "a"
@@ -49,7 +10,7 @@
     , MAlignPoint
     , Code
         "typ/math/alignment-03.typ"
-        ( line 4 , column 9 )
+        ( line 3 , column 9 )
         (Ident (Identifier "quad"))
     , Text "c"
     , MAlignPoint
diff --git a/test/typ/math/attach-00.out b/test/typ/math/attach-00.out
--- a/test/typ/math/attach-00.out
+++ b/test/typ/math/attach-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-00.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
-                                 "typ/math/attach-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ MAttach (Just (Text "x")) Nothing (Text "f")
@@ -50,7 +11,7 @@
     , Text "+"
     , Code
         "typ/math/attach-00.typ"
-        ( line 3 , column 22 )
+        ( line 2 , column 22 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "A" ]
@@ -60,7 +21,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-00.typ"
-                         ( line 3 , column 35 )
+                         ( line 2 , column 35 )
                          (Ident (Identifier "alpha"))
                      ]))
            , KeyValArg
@@ -69,7 +30,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-00.typ"
-                         ( line 3 , column 45 )
+                         ( line 2 , column 45 )
                          (Ident (Identifier "beta"))
                      ]))
            ])
diff --git a/test/typ/math/attach-01.out b/test/typ/math/attach-01.out
--- a/test/typ/math/attach-01.out
+++ b/test/typ/math/attach-01.out
@@ -1,57 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-01.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
-                                 "typ/math/attach-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Equation
     True
     [ Code
         "typ/math/attach-01.typ"
-        ( line 5 , column 1 )
+        ( line 4 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-01.typ"
-                   ( line 5 , column 8 )
+                   ( line 4 , column 8 )
                    (FuncCall (Ident (Identifier "upright")) [ BlockArg [ Text "O" ] ])
                ]
            , KeyValArg (Identifier "bl") (Block (Content [ Text "8" ]))
@@ -64,14 +26,14 @@
                      [ Text "2"
                      , Code
                          "typ/math/attach-01.typ"
-                         ( line 5 , column 47 )
+                         ( line 4 , column 47 )
                          (Ident (Identifier "minus"))
                      ]))
            ])
     , Text ","
     , Code
         "typ/math/attach-01.typ"
-        ( line 6 , column 1 )
+        ( line 5 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "Pb" ]
@@ -81,13 +43,13 @@
     , Text "+"
     , Code
         "typ/math/attach-01.typ"
-        ( line 6 , column 33 )
+        ( line 5 , column 33 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-01.typ"
-                   ( line 6 , column 40 )
+                   ( line 5 , column 40 )
                    (FuncCall (Ident (Identifier "upright")) [ BlockArg [ Text "e" ] ])
                ]
            , KeyValArg
@@ -96,7 +58,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-01.typ"
-                         ( line 6 , column 56 )
+                         ( line 5 , column 56 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]))
@@ -108,7 +70,7 @@
         Nothing
         (Code
            "typ/math/attach-01.typ"
-           ( line 6 , column 69 )
+           ( line 5 , column 69 )
            (FuncCall (Ident (Identifier "macron")) [ BlockArg [ Text "v" ] ]))
     , HardBreak
     ]
@@ -116,6 +78,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  math.equation(block: true, 
                                body: { math.attach(base: math.upright(body: text(body: [O])), 
diff --git a/test/typ/math/attach-02.out b/test/typ/math/attach-02.out
--- a/test/typ/math/attach-02.out
+++ b/test/typ/math/attach-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-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
-                                 "typ/math/attach-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/attach-02.typ"
-        ( line 4 , column 1 )
+        ( line 3 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -53,7 +14,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 4 , column 21 )
+        ( line 3 , column 21 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -62,7 +23,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 4 , column 41 )
+        ( line 3 , column 41 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -71,7 +32,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 5 , column 1 )
+        ( line 4 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -83,7 +44,7 @@
         (Just (Text "t"))
         (Code
            "typ/math/attach-02.typ"
-           ( line 5 , column 21 )
+           ( line 4 , column 21 )
            (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ]))
     , Text ","
     , MAttach
@@ -91,12 +52,12 @@
         Nothing
         (Code
            "typ/math/attach-02.typ"
-           ( line 5 , column 41 )
+           ( line 4 , column 41 )
            (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ]))
     , HardBreak
     , Code
         "typ/math/attach-02.typ"
-        ( line 7 , column 1 )
+        ( line 6 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -106,7 +67,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 8 , column 1 )
+        ( line 7 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -116,7 +77,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 9 , column 1 )
+        ( line 8 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -126,13 +87,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 10 , column 1 )
+        ( line 9 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 10 , column 8 )
+                   ( line 9 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "b") (Block (Content [ Text "b" ]))
@@ -141,7 +102,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 11 , column 1 )
+        ( line 10 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -151,13 +112,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 12 , column 1 )
+        ( line 11 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 12 , column 8 )
+                   ( line 11 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "t" ]))
@@ -166,7 +127,7 @@
     , HardBreak
     , Code
         "typ/math/attach-02.typ"
-        ( line 14 , column 1 )
+        ( line 13 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -176,13 +137,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 15 , column 1 )
+        ( line 14 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 15 , column 8 )
+                   ( line 14 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "t" ]))
@@ -191,13 +152,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 16 , column 1 )
+        ( line 15 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 16 , column 8 )
+                   ( line 15 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "b") (Block (Content [ Text "b" ]))
@@ -206,7 +167,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 17 , column 1 )
+        ( line 16 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -216,13 +177,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 18 , column 1 )
+        ( line 17 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 18 , column 8 )
+                   ( line 17 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "b") (Block (Content [ Text "b" ]))
@@ -231,13 +192,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 19 , column 1 )
+        ( line 18 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 19 , column 8 )
+                   ( line 18 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "t" ]))
@@ -249,12 +210,12 @@
         (Just (Text "t"))
         (Code
            "typ/math/attach-02.typ"
-           ( line 20 , column 1 )
+           ( line 19 , column 1 )
            (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ]))
     , HardBreak
     , Code
         "typ/math/attach-02.typ"
-        ( line 22 , column 1 )
+        ( line 21 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
@@ -266,13 +227,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 23 , column 1 )
+        ( line 22 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 23 , column 8 )
+                   ( line 22 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "t" ]))
@@ -283,13 +244,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 24 , column 1 )
+        ( line 23 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 24 , column 8 )
+                   ( line 23 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "t" ]))
@@ -300,13 +261,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 25 , column 1 )
+        ( line 24 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 25 , column 8 )
+                   ( line 24 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "tl") (Block (Content [ Text "u" ]))
@@ -317,13 +278,13 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 26 , column 1 )
+        ( line 25 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-02.typ"
-                   ( line 26 , column 8 )
+                   ( line 25 , column 8 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "a" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "t" ]))
@@ -334,7 +295,7 @@
     , Text ","
     , Code
         "typ/math/attach-02.typ"
-        ( line 27 , column 1 )
+        ( line 26 , column 1 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "a" ]
diff --git a/test/typ/math/attach-03.out b/test/typ/math/attach-03.out
--- a/test/typ/math/attach-03.out
+++ b/test/typ/math/attach-03.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-03.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
-                                 "typ/math/attach-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ MAttach
@@ -47,7 +8,7 @@
         Nothing
         (Code
            "typ/math/attach-03.typ"
-           ( line 3 , column 2 )
+           ( line 2 , column 2 )
            (Ident (Identifier "pi")))
     , MGroup (Just "(") (Just ")") [ Text "Y" ]
     , Text ","
@@ -65,7 +26,7 @@
         (Just
            (Code
               "typ/math/attach-03.typ"
-              ( line 3 , column 21 )
+              ( line 2 , column 21 )
               (FuncCall (Ident (Identifier "zeta")) [ BlockArg [ Text "x" ] ])))
         (Text "a")
     , HardBreak
@@ -74,7 +35,7 @@
         (Just
            (Code
               "typ/math/attach-03.typ"
-              ( line 4 , column 4 )
+              ( line 3 , column 4 )
               (FuncCall
                  (FieldAccess
                     (Ident (Identifier "eq")) (Ident (Identifier "subset")))
@@ -88,7 +49,7 @@
               Nothing
               [ Code
                   "typ/math/attach-03.typ"
-                  ( line 4 , column 21 )
+                  ( line 3 , column 21 )
                   (FuncCall (Ident (Identifier "zeta")) [ BlockArg [ Text "x" ] ])
               ]))
         Nothing
@@ -103,7 +64,7 @@
         Nothing
         (Code
            "typ/math/attach-03.typ"
-           ( line 4 , column 31 )
+           ( line 3 , column 31 )
            (Ident (Identifier "pi")))
     ]
 , ParBreak
diff --git a/test/typ/math/attach-04.out b/test/typ/math/attach-04.out
--- a/test/typ/math/attach-04.out
+++ b/test/typ/math/attach-04.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-04.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
-                                 "typ/math/attach-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MFrac
@@ -63,7 +24,7 @@
         (Text "1")
         (Code
            "typ/math/attach-04.typ"
-           ( line 4 , column 5 )
+           ( line 3 , column 5 )
            (FuncCall
               (Ident (Identifier "attach"))
               [ BlockArg [ Text "V" ]
@@ -73,7 +34,7 @@
                      (Content
                         [ Code
                             "typ/math/attach-04.typ"
-                            ( line 4 , column 19 )
+                            ( line 3 , column 19 )
                             (FuncCall
                                (Ident (Identifier "attach"))
                                [ BlockArg [ Text "2" ]
@@ -83,7 +44,7 @@
                                       (Content
                                          [ Code
                                              "typ/math/attach-04.typ"
-                                             ( line 4 , column 33 )
+                                             ( line 3 , column 33 )
                                              (FuncCall
                                                 (Ident (Identifier "attach"))
                                                 [ BlockArg [ Text "3" ]
@@ -93,7 +54,7 @@
                                                        (Content
                                                           [ Code
                                                               "typ/math/attach-04.typ"
-                                                              ( line 4 , column 47 )
+                                                              ( line 3 , column 47 )
                                                               (FuncCall
                                                                  (Ident (Identifier "attach"))
                                                                  [ BlockArg [ Text "4" ]
@@ -110,13 +71,13 @@
     , Text ","
     , Code
         "typ/math/attach-04.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/attach-04.typ"
-                   ( line 5 , column 10 )
+                   ( line 4 , column 10 )
                    (Ident (Identifier "Omega"))
                ]
            , KeyValArg
@@ -125,7 +86,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-04.typ"
-                         ( line 6 , column 9 )
+                         ( line 5 , column 9 )
                          (FuncCall
                             (Ident (Identifier "attach"))
                             [ BlockArg [ Text "2" ]
@@ -135,7 +96,7 @@
                                    (Content
                                       [ Code
                                           "typ/math/attach-04.typ"
-                                          ( line 6 , column 23 )
+                                          ( line 5 , column 23 )
                                           (FuncCall
                                              (Ident (Identifier "attach"))
                                              [ BlockArg [ Text "3" ]
@@ -145,7 +106,7 @@
                                                     (Content
                                                        [ Code
                                                            "typ/math/attach-04.typ"
-                                                           ( line 6 , column 37 )
+                                                           ( line 5 , column 37 )
                                                            (FuncCall
                                                               (Ident (Identifier "attach"))
                                                               [ BlockArg [ Text "4" ]
@@ -164,7 +125,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-04.typ"
-                         ( line 7 , column 9 )
+                         ( line 6 , column 9 )
                          (FuncCall
                             (Ident (Identifier "attach"))
                             [ BlockArg [ Text "2" ]
@@ -174,7 +135,7 @@
                                    (Content
                                       [ Code
                                           "typ/math/attach-04.typ"
-                                          ( line 7 , column 23 )
+                                          ( line 6 , column 23 )
                                           (FuncCall
                                              (Ident (Identifier "attach"))
                                              [ BlockArg [ Text "3" ]
@@ -184,7 +145,7 @@
                                                     (Content
                                                        [ Code
                                                            "typ/math/attach-04.typ"
-                                                           ( line 7 , column 37 )
+                                                           ( line 6 , column 37 )
                                                            (FuncCall
                                                               (Ident (Identifier "attach"))
                                                               [ BlockArg [ Text "4" ]
@@ -203,7 +164,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-04.typ"
-                         ( line 8 , column 9 )
+                         ( line 7 , column 9 )
                          (FuncCall
                             (Ident (Identifier "attach"))
                             [ BlockArg [ Text "2" ]
@@ -213,7 +174,7 @@
                                    (Content
                                       [ Code
                                           "typ/math/attach-04.typ"
-                                          ( line 8 , column 23 )
+                                          ( line 7 , column 23 )
                                           (FuncCall
                                              (Ident (Identifier "attach"))
                                              [ BlockArg [ Text "3" ]
@@ -223,7 +184,7 @@
                                                     (Content
                                                        [ Code
                                                            "typ/math/attach-04.typ"
-                                                           ( line 8 , column 37 )
+                                                           ( line 7 , column 37 )
                                                            (FuncCall
                                                               (Ident (Identifier "attach"))
                                                               [ BlockArg [ Text "4" ]
@@ -242,7 +203,7 @@
                   (Content
                      [ Code
                          "typ/math/attach-04.typ"
-                         ( line 9 , column 9 )
+                         ( line 8 , column 9 )
                          (FuncCall
                             (Ident (Identifier "attach"))
                             [ BlockArg [ Text "2" ]
@@ -252,7 +213,7 @@
                                    (Content
                                       [ Code
                                           "typ/math/attach-04.typ"
-                                          ( line 9 , column 23 )
+                                          ( line 8 , column 23 )
                                           (FuncCall
                                              (Ident (Identifier "attach"))
                                              [ BlockArg [ Text "3" ]
@@ -262,7 +223,7 @@
                                                     (Content
                                                        [ Code
                                                            "typ/math/attach-04.typ"
-                                                           ( line 9 , column 37 )
+                                                           ( line 8 , column 37 )
                                                            (FuncCall
                                                               (Ident (Identifier "attach"))
                                                               [ BlockArg [ Text "4" ]
diff --git a/test/typ/math/attach-05.out b/test/typ/math/attach-05.out
--- a/test/typ/math/attach-05.out
+++ b/test/typ/math/attach-05.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-05.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
-                                 "typ/math/attach-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/attach-05.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
@@ -53,7 +14,7 @@
                    (Just
                       (Code
                          "typ/math/attach-05.typ"
-                         ( line 3 , column 16 )
+                         ( line 2 , column 16 )
                          (Ident (Identifier "zeta"))))
                    (Text "a")
                ]
@@ -61,7 +22,7 @@
     , Text ","
     , Code
         "typ/math/attach-05.typ"
-        ( line 3 , column 23 )
+        ( line 2 , column 23 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
@@ -69,7 +30,7 @@
                    (Just
                       (Code
                          "typ/math/attach-05.typ"
-                         ( line 3 , column 30 )
+                         ( line 2 , column 30 )
                          (Ident (Identifier "alpha"))))
                    (Just (MGroup Nothing Nothing [ MFrac (Text "1") (Text "2") ]))
                    (Text "a")
@@ -78,7 +39,7 @@
     , Text ","
     , Code
         "typ/math/attach-05.typ"
-        ( line 3 , column 44 )
+        ( line 2 , column 44 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
@@ -91,13 +52,13 @@
     , HardBreak
     , Code
         "typ/math/attach-05.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
                [ Code
                    "typ/math/attach-05.typ"
-                   ( line 4 , column 8 )
+                   ( line 3 , column 8 )
                    (FuncCall
                       (Ident (Identifier "attach"))
                       [ BlockArg [ Text "a" ]
@@ -111,13 +72,13 @@
     , Text ","
     , Code
         "typ/math/attach-05.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
                [ Code
                    "typ/math/attach-05.typ"
-                   ( line 5 , column 8 )
+                   ( line 4 , column 8 )
                    (FuncCall
                       (Ident (Identifier "attach"))
                       [ BlockArg [ Text "a" ]
diff --git a/test/typ/math/attach-06.out b/test/typ/math/attach-06.out
--- a/test/typ/math/attach-06.out
+++ b/test/typ/math/attach-06.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-06.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
-                                 "typ/math/attach-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -50,7 +11,7 @@
            (Just ")")
            [ Code
                "typ/math/attach-06.typ"
-               ( line 3 , column 4 )
+               ( line 2 , column 4 )
                (Ident (Identifier "minus"))
            , Text "1"
            ])
@@ -63,7 +24,7 @@
               Nothing
               [ Code
                   "typ/math/attach-06.typ"
-                  ( line 3 , column 23 )
+                  ( line 2 , column 23 )
                   (Ident (Identifier "minus"))
               , MFrac (Text "1") (Text "2")
               ]))
diff --git a/test/typ/math/attach-07.out b/test/typ/math/attach-07.out
--- a/test/typ/math/attach-07.out
+++ b/test/typ/math/attach-07.out
@@ -2,51 +2,12 @@
 [ Code
     "typ/math/attach-07.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
-                                 "typ/math/attach-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/math/attach-07.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "size") (Literal (Numeric 8.0 Pt)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Equation
     True
     [ MAttach (Just (Text "1")) Nothing (Text "x")
@@ -56,7 +17,7 @@
         Nothing
         (Code
            "typ/math/attach-07.typ"
-           ( line 5 , column 11 )
+           ( line 4 , column 11 )
            (FuncCall (Ident (Identifier "frak")) [ BlockArg [ Text "p" ] ]))
     , MAttach (Just (Text "1")) Nothing (Text "2")
     , MAttach
@@ -64,14 +25,14 @@
         Nothing
         (Code
            "typ/math/attach-07.typ"
-           ( line 5 , column 25 )
+           ( line 4 , column 25 )
            (Ident (Identifier "dot")))
     , MAttach
         (Just (Text "1"))
         Nothing
         (Code
            "typ/math/attach-07.typ"
-           ( line 5 , column 31 )
+           ( line 4 , column 31 )
            (Ident (Identifier "lg")))
     , MAttach (Just (Text "1")) Nothing (Text "!")
     , MAttach (Just (Text "1")) Nothing (Text "\\")
@@ -82,7 +43,7 @@
         Nothing
         (Code
            "typ/math/attach-07.typ"
-           ( line 5 , column 56 )
+           ( line 4 , column 56 )
            (FuncCall (Ident (Identifier "op")) [ BlockArg [ Text "iq" ] ]))
     , HardBreak
     , MAttach Nothing (Just (Text "1")) (Text "x")
@@ -92,7 +53,7 @@
         (Just (Text "1"))
         (Code
            "typ/math/attach-07.typ"
-           ( line 6 , column 11 )
+           ( line 5 , column 11 )
            (FuncCall (Ident (Identifier "frak")) [ BlockArg [ Text "b" ] ]))
     , MAttach Nothing (Just (Text "1")) (Text "2")
     , MAttach
@@ -100,14 +61,14 @@
         (Just (Text "1"))
         (Code
            "typ/math/attach-07.typ"
-           ( line 6 , column 25 )
+           ( line 5 , column 25 )
            (Ident (Identifier "dot")))
     , MAttach
         Nothing
         (Just (Text "1"))
         (Code
            "typ/math/attach-07.typ"
-           ( line 6 , column 31 )
+           ( line 5 , column 31 )
            (Ident (Identifier "lg")))
     , MAttach Nothing (Just (Text "1")) (Text "!")
     , MAttach Nothing (Just (Text "1")) (Text "\\")
@@ -118,7 +79,7 @@
         (Just (Text "1"))
         (Code
            "typ/math/attach-07.typ"
-           ( line 6 , column 56 )
+           ( line 5 , column 56 )
            (FuncCall (Ident (Identifier "op")) [ BlockArg [ Text "id" ] ]))
     , HardBreak
     , MAttach (Just (Text "1")) Nothing (Text "x")
@@ -129,7 +90,7 @@
     , MAttach Nothing (Just (Text "1")) (Text " `")
     , Code
         "typ/math/attach-07.typ"
-        ( line 7 , column 31 )
+        ( line 6 , column 31 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg [ Text "I" ]
@@ -143,13 +104,13 @@
         (Just (Text "1"))
         (Code
            "typ/math/attach-07.typ"
-           ( line 8 , column 3 )
+           ( line 7 , column 3 )
            (FuncCall
               (Ident (Identifier "scripts"))
               [ BlockArg
                   [ Code
                       "typ/math/attach-07.typ"
-                      ( line 8 , column 11 )
+                      ( line 7 , column 11 )
                       (Ident (Identifier "sum"))
                   ]
               ]))
@@ -158,7 +119,7 @@
         (Just (Text "1"))
         (Code
            "typ/math/attach-07.typ"
-           ( line 8 , column 20 )
+           ( line 7 , column 20 )
            (Ident (Identifier "integral")))
     , Text "|"
     , MFrac (Text "1") (Text "2")
@@ -172,7 +133,7 @@
     , MAttach (Just (Text "1")) (Just (Text "1")) (Text ")")
     , Code
         "typ/math/attach-07.typ"
-        ( line 9 , column 24 )
+        ( line 8 , column 24 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MAttach
         (Just (Text "1"))
@@ -188,16 +149,16 @@
            (Just "]")
            [ Code
                "typ/math/attach-07.typ"
-               ( line 9 , column 47 )
+               ( line 8 , column 47 )
                (Ident (Identifier "integral"))
            ])
     ]
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
+                 text(body: [
+], size: 8.0pt), 
                  math.equation(block: true, 
                                body: { math.attach(b: text(body: [1], 
                                                            size: 8.0pt), 
diff --git a/test/typ/math/attach-08.out b/test/typ/math/attach-08.out
--- a/test/typ/math/attach-08.out
+++ b/test/typ/math/attach-08.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-08.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
-                                 "typ/math/attach-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -50,11 +11,11 @@
               [ Text "n"
               , Code
                   "typ/math/attach-08.typ"
-                  ( line 3 , column 9 )
+                  ( line 2 , column 9 )
                   (FieldAccess (Ident (Identifier "r")) (Ident (Identifier "arrow")))
               , Code
                   "typ/math/attach-08.typ"
-                  ( line 3 , column 11 )
+                  ( line 2 , column 11 )
                   (Ident (Identifier "oo"))
               , HardBreak
               , Text "n"
@@ -63,7 +24,7 @@
         Nothing
         (Code
            "typ/math/attach-08.typ"
-           ( line 3 , column 3 )
+           ( line 2 , column 3 )
            (Ident (Identifier "lim")))
     , MAttach
         (Just
@@ -77,17 +38,17 @@
               , Text "k"
               , Code
                   "typ/math/attach-08.typ"
-                  ( line 3 , column 40 )
+                  ( line 2 , column 40 )
                   (Ident (Identifier "in"))
               , Code
                   "typ/math/attach-08.typ"
-                  ( line 3 , column 43 )
+                  ( line 2 , column 43 )
                   (Ident (Identifier "NN"))
               ]))
         (Just (Text "n"))
         (Code
            "typ/math/attach-08.typ"
-           ( line 3 , column 27 )
+           ( line 2 , column 27 )
            (Ident (Identifier "sum")))
     , Text "k"
     ]
diff --git a/test/typ/math/attach-09.out b/test/typ/math/attach-09.out
--- a/test/typ/math/attach-09.out
+++ b/test/typ/math/attach-09.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/attach-09.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
-                                 "typ/math/attach-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/attach-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -47,11 +8,11 @@
         (Just (Text "2"))
         (Code
            "typ/math/attach-09.typ"
-           ( line 3 , column 3 )
+           ( line 2 , column 3 )
            (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "A" ] ]))
     , Code
         "typ/math/attach-09.typ"
-        ( line 3 , column 17 )
+        ( line 2 , column 17 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MAttach (Just (Text "1")) (Just (Text "2")) (Text "A")
     ]
@@ -63,26 +24,26 @@
         (Just (Text "2"))
         (Code
            "typ/math/attach-09.typ"
-           ( line 4 , column 3 )
+           ( line 3 , column 3 )
            (FuncCall
               (Ident (Identifier "scripts"))
               [ BlockArg
                   [ Code
                       "typ/math/attach-09.typ"
-                      ( line 4 , column 11 )
+                      ( line 3 , column 11 )
                       (Ident (Identifier "sum"))
                   ]
               ]))
     , Code
         "typ/math/attach-09.typ"
-        ( line 4 , column 20 )
+        ( line 3 , column 20 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MAttach
         (Just (Text "1"))
         (Just (Text "2"))
         (Code
            "typ/math/attach-09.typ"
-           ( line 4 , column 23 )
+           ( line 3 , column 23 )
            (Ident (Identifier "sum")))
     ]
 , SoftBreak
@@ -93,26 +54,26 @@
         (Just (Text "b"))
         (Code
            "typ/math/attach-09.typ"
-           ( line 5 , column 3 )
+           ( line 4 , column 3 )
            (FuncCall
               (Ident (Identifier "limits"))
               [ BlockArg
                   [ Code
                       "typ/math/attach-09.typ"
-                      ( line 5 , column 10 )
+                      ( line 4 , column 10 )
                       (Ident (Identifier "integral"))
                   ]
               ]))
     , Code
         "typ/math/attach-09.typ"
-        ( line 5 , column 24 )
+        ( line 4 , column 24 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MAttach
         (Just (Text "a"))
         (Just (Text "b"))
         (Code
            "typ/math/attach-09.typ"
-           ( line 5 , column 27 )
+           ( line 4 , column 27 )
            (Ident (Identifier "integral")))
     ]
 , ParBreak
diff --git a/test/typ/math/cancel-00.out b/test/typ/math/cancel-00.out
--- a/test/typ/math/cancel-00.out
+++ b/test/typ/math/cancel-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/cancel-00.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
-                                 "typ/math/cancel-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cancel-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "a"
@@ -48,17 +9,17 @@
     , Text "+"
     , Code
         "typ/math/cancel-00.typ"
-        ( line 3 , column 10 )
+        ( line 2 , column 10 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "x" ] ])
     , Text "+"
     , Text "b"
     , Code
         "typ/math/cancel-00.typ"
-        ( line 3 , column 24 )
+        ( line 2 , column 24 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-00.typ"
-        ( line 3 , column 26 )
+        ( line 2 , column 26 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "x" ] ])
     ]
 , ParBreak
@@ -73,18 +34,18 @@
            [ Text "a"
            , Code
                "typ/math/cancel-00.typ"
-               ( line 5 , column 9 )
+               ( line 4 , column 9 )
                (FieldAccess (Ident (Identifier "c")) (Ident (Identifier "dot")))
            , Code
                "typ/math/cancel-00.typ"
-               ( line 5 , column 15 )
+               ( line 4 , column 15 )
                (FuncCall
                   (Ident (Identifier "cancel"))
                   [ BlockArg
                       [ Text "b"
                       , Code
                           "typ/math/cancel-00.typ"
-                          ( line 5 , column 24 )
+                          ( line 4 , column 24 )
                           (FieldAccess (Ident (Identifier "c")) (Ident (Identifier "dot")))
                       , Text "c"
                       ]
@@ -95,14 +56,14 @@
            Nothing
            [ Code
                "typ/math/cancel-00.typ"
-               ( line 5 , column 35 )
+               ( line 4 , column 35 )
                (FuncCall
                   (Ident (Identifier "cancel"))
                   [ BlockArg
                       [ Text "b"
                       , Code
                           "typ/math/cancel-00.typ"
-                          ( line 5 , column 44 )
+                          ( line 4 , column 44 )
                           (FieldAccess (Ident (Identifier "c")) (Ident (Identifier "dot")))
                       , Text "c"
                       ]
diff --git a/test/typ/math/cancel-01.out b/test/typ/math/cancel-01.out
--- a/test/typ/math/cancel-01.out
+++ b/test/typ/math/cancel-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/cancel-01.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
-                                 "typ/math/cancel-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cancel-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/cancel-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
@@ -55,43 +16,43 @@
     , Text "+"
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 11 )
+        ( line 3 , column 11 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "b" , Text "+" , Text "c" ] ])
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 25 )
+        ( line 3 , column 25 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 27 )
+        ( line 3 , column 27 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "b" ] ])
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 37 )
+        ( line 3 , column 37 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 39 )
+        ( line 3 , column 39 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "c" ] ])
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 49 )
+        ( line 3 , column 49 )
         (Ident (Identifier "minus"))
     , Text "5"
     , Text "+"
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 55 )
+        ( line 3 , column 55 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "6" ] ])
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 65 )
+        ( line 3 , column 65 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-01.typ"
-        ( line 4 , column 67 )
+        ( line 3 , column 67 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "6" ] ])
     ]
 , SoftBreak
@@ -106,11 +67,11 @@
            [ Text "a"
            , Code
                "typ/math/cancel-01.typ"
-               ( line 5 , column 10 )
+               ( line 4 , column 10 )
                (FieldAccess (Ident (Identifier "c")) (Ident (Identifier "dot")))
            , Code
                "typ/math/cancel-01.typ"
-               ( line 5 , column 16 )
+               ( line 4 , column 16 )
                (FuncCall
                   (Ident (Identifier "cancel"))
                   [ BlockArg
@@ -126,7 +87,7 @@
            Nothing
            [ Code
                "typ/math/cancel-01.typ"
-               ( line 5 , column 38 )
+               ( line 4 , column 38 )
                (FuncCall
                   (Ident (Identifier "cancel"))
                   [ BlockArg [ Text "b" , Text "+" , Text "c" , Text "+" , Text "d" ]
diff --git a/test/typ/math/cancel-02.out b/test/typ/math/cancel-02.out
--- a/test/typ/math/cancel-02.out
+++ b/test/typ/math/cancel-02.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/cancel-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
-                                 "typ/math/cancel-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cancel-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "a"
     , Text "+"
     , Code
         "typ/math/cancel-02.typ"
-        ( line 3 , column 6 )
+        ( line 2 , column 6 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "x" ]
@@ -54,11 +15,11 @@
            ])
     , Code
         "typ/math/cancel-02.typ"
-        ( line 3 , column 33 )
+        ( line 2 , column 33 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-02.typ"
-        ( line 3 , column 35 )
+        ( line 2 , column 35 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "x" ]
@@ -69,15 +30,15 @@
     , Text "+"
     , Code
         "typ/math/cancel-02.typ"
-        ( line 3 , column 69 )
+        ( line 2 , column 69 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "y" ] ])
     , Code
         "typ/math/cancel-02.typ"
-        ( line 3 , column 79 )
+        ( line 2 , column 79 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-02.typ"
-        ( line 3 , column 81 )
+        ( line 2 , column 81 )
         (FuncCall (Ident (Identifier "cancel")) [ BlockArg [ Text "y" ] ])
     ]
 , SoftBreak
@@ -87,7 +48,7 @@
     , Text "+"
     , Code
         "typ/math/cancel-02.typ"
-        ( line 4 , column 7 )
+        ( line 3 , column 7 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "abcdefg" ]
diff --git a/test/typ/math/cancel-03.out b/test/typ/math/cancel-03.out
--- a/test/typ/math/cancel-03.out
+++ b/test/typ/math/cancel-03.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/cancel-03.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
-                                 "typ/math/cancel-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cancel-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "a"
     , Text "+"
     , Code
         "typ/math/cancel-03.typ"
-        ( line 3 , column 6 )
+        ( line 2 , column 6 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "b" , Text "+" , Text "c" , Text "+" , Text "d" ]
@@ -63,7 +24,7 @@
     , Text "+"
     , Code
         "typ/math/cancel-03.typ"
-        ( line 4 , column 7 )
+        ( line 3 , column 7 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "b" , Text "+" , Text "c" , Text "+" , Text "d" ]
diff --git a/test/typ/math/cancel-04.out b/test/typ/math/cancel-04.out
--- a/test/typ/math/cancel-04.out
+++ b/test/typ/math/cancel-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/cancel-04.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
-                                 "typ/math/cancel-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cancel-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/cancel-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 200.0 Pt))
@@ -55,7 +16,7 @@
     , Text "+"
     , Code
         "typ/math/cancel-04.typ"
-        ( line 4 , column 6 )
+        ( line 3 , column 6 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "x" ]
@@ -63,11 +24,11 @@
            ])
     , Code
         "typ/math/cancel-04.typ"
-        ( line 4 , column 31 )
+        ( line 3 , column 31 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-04.typ"
-        ( line 4 , column 33 )
+        ( line 3 , column 33 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "x" ]
@@ -86,7 +47,7 @@
     , Text "+"
     , Code
         "typ/math/cancel-04.typ"
-        ( line 5 , column 7 )
+        ( line 4 , column 7 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "x" ]
@@ -94,11 +55,11 @@
            ])
     , Code
         "typ/math/cancel-04.typ"
-        ( line 5 , column 32 )
+        ( line 4 , column 32 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-04.typ"
-        ( line 5 , column 34 )
+        ( line 4 , column 34 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "a" , Text "+" , Text "b" , Text "+" , Text "c" ]
diff --git a/test/typ/math/cancel-05.out b/test/typ/math/cancel-05.out
--- a/test/typ/math/cancel-05.out
+++ b/test/typ/math/cancel-05.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/cancel-05.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
-                                 "typ/math/cancel-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cancel-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "x"
     , Text "+"
     , Code
         "typ/math/cancel-05.typ"
-        ( line 3 , column 6 )
+        ( line 2 , column 6 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "y" ]
@@ -54,11 +15,11 @@
            ])
     , Code
         "typ/math/cancel-05.typ"
-        ( line 3 , column 34 )
+        ( line 2 , column 34 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-05.typ"
-        ( line 3 , column 36 )
+        ( line 2 , column 36 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg [ Text "z" ]
@@ -72,7 +33,7 @@
     , Text "+"
     , Code
         "typ/math/cancel-05.typ"
-        ( line 4 , column 7 )
+        ( line 3 , column 7 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg
@@ -83,11 +44,11 @@
            ])
     , Code
         "typ/math/cancel-05.typ"
-        ( line 4 , column 31 )
+        ( line 3 , column 31 )
         (Ident (Identifier "minus"))
     , Code
         "typ/math/cancel-05.typ"
-        ( line 4 , column 33 )
+        ( line 3 , column 33 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg
diff --git a/test/typ/math/cases-00.out b/test/typ/math/cases-00.out
--- a/test/typ/math/cases-00.out
+++ b/test/typ/math/cases-00.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/math/cases-00.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
-                                 "typ/math/cases-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/cases-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ MGroup
         Nothing
@@ -49,19 +9,19 @@
         ]
     , Code
         "typ/math/cases-00.typ"
-        ( line 2 , column 11 )
+        ( line 1 , column 11 )
         (FieldAccess
            (Ident (Identifier "eq")) (Ident (Identifier "colon")))
     , Code
         "typ/math/cases-00.typ"
-        ( line 2 , column 14 )
+        ( line 1 , column 14 )
         (FuncCall
            (Ident (Identifier "cases"))
            [ BlockArg
                [ Text "1"
                , Code
                    "typ/math/cases-00.typ"
-                   ( line 3 , column 5 )
+                   ( line 2 , column 5 )
                    (Ident (Identifier "quad"))
                , MAlignPoint
                , Text "if "
@@ -72,14 +32,14 @@
                       [ Text "x"
                       , Code
                           "typ/math/cases-00.typ"
-                          ( line 3 , column 19 )
+                          ( line 2 , column 19 )
                           (Ident (Identifier "dot"))
                       , Text "y"
                       ])
                    (Text "2")
                , Code
                    "typ/math/cases-00.typ"
-                   ( line 3 , column 28 )
+                   ( line 2 , column 28 )
                    (FieldAccess (Ident (Identifier "eq")) (Ident (Identifier "lt")))
                , Text "0"
                ]
@@ -90,7 +50,7 @@
                , Text "x"
                , Code
                    "typ/math/cases-00.typ"
-                   ( line 4 , column 13 )
+                   ( line 3 , column 13 )
                    (Ident (Identifier "divides"))
                , Text "2"
                ]
@@ -101,11 +61,11 @@
                , Text "x"
                , Code
                    "typ/math/cases-00.typ"
-                   ( line 5 , column 13 )
+                   ( line 4 , column 13 )
                    (Ident (Identifier "in"))
                , Code
                    "typ/math/cases-00.typ"
-                   ( line 5 , column 16 )
+                   ( line 4 , column 16 )
                    (Ident (Identifier "NN"))
                ]
            , BlockArg [ Text "4" , MAlignPoint , Text "else" ]
@@ -114,9 +74,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: { text(body: [f]), 
                                        math.lr(body: ({ [(], 
                                                         text(body: [x]), 
diff --git a/test/typ/math/content-00.out b/test/typ/math/content-00.out
--- a/test/typ/math/content-00.out
+++ b/test/typ/math/content-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/content-00.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
-                                 "typ/math/content-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/content-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/content-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "monkey")))
        (FuncCall
@@ -67,28 +28,28 @@
               , Text "="
               , Code
                   "typ/math/content-00.typ"
-                  ( line 4 , column 11 )
+                  ( line 3 , column 11 )
                   (FieldAccess
                      (Ident (Identifier "apple")) (Ident (Identifier "emoji")))
               ]))
         (Just
            (Code
               "typ/math/content-00.typ"
-              ( line 4 , column 25 )
+              ( line 3 , column 25 )
               (FieldAccess
                  (Ident (Identifier "red"))
                  (FieldAccess
                     (Ident (Identifier "apple")) (Ident (Identifier "emoji"))))))
         (Code
            "typ/math/content-00.typ"
-           ( line 4 , column 3 )
+           ( line 3 , column 3 )
            (Ident (Identifier "sum")))
     , Text "i"
     , Text "+"
     , MFrac
         (Code
            "typ/math/content-00.typ"
-           ( line 4 , column 45 )
+           ( line 3 , column 45 )
            (Ident (Identifier "monkey")))
         (Text "2")
     ]
diff --git a/test/typ/math/content-01.out b/test/typ/math/content-01.out
--- a/test/typ/math/content-01.out
+++ b/test/typ/math/content-01.out
@@ -1,57 +1,18 @@
 --- parse tree ---
-[ Code
-    "typ/math/content-01.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
-                                 "typ/math/content-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/content-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
     , Code
         "typ/math/content-01.typ"
-        ( line 3 , column 5 )
+        ( line 2 , column 5 )
         (FieldAccess
            (Ident (Identifier "eq")) (Ident (Identifier "colon")))
     , MFrac
         (Code
            "typ/math/content-01.typ"
-           ( line 3 , column 9 )
+           ( line 2 , column 9 )
            (FuncCall
               (Ident (Identifier "table"))
               [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -60,7 +21,7 @@
               ]))
         (Code
            "typ/math/content-01.typ"
-           ( line 3 , column 33 )
+           ( line 2 , column 33 )
            (FuncCall
               (Ident (Identifier "mat"))
               [ BlockArg [ Text "1" ]
@@ -70,7 +31,7 @@
     , Text "="
     , Code
         "typ/math/content-01.typ"
-        ( line 4 , column 9 )
+        ( line 3 , column 9 )
         (FuncCall
            (Ident (Identifier "table"))
            [ BlockArg [ Text "A" ]
diff --git a/test/typ/math/content-02.out b/test/typ/math/content-02.out
--- a/test/typ/math/content-02.out
+++ b/test/typ/math/content-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/content-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
-                                 "typ/math/content-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/content-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/content-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "attach")) (Ident (Identifier "math")))
diff --git a/test/typ/math/content-03.out b/test/typ/math/content-03.out
--- a/test/typ/math/content-03.out
+++ b/test/typ/math/content-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/content-03.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
-                                 "typ/math/content-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/content-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/content-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "here")))
        (FuncCall
@@ -54,16 +15,16 @@
     False
     [ Code
         "typ/math/content-03.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall (Ident (Identifier "here")) [ BlockArg [ Text "f" ] ])
     , Code
         "typ/math/content-03.typ"
-        ( line 4 , column 11 )
+        ( line 3 , column 11 )
         (FieldAccess
            (Ident (Identifier "eq")) (Ident (Identifier "colon")))
     , Code
         "typ/math/content-03.typ"
-        ( line 4 , column 15 )
+        ( line 3 , column 15 )
         (FuncCall
            (Ident (Identifier "here"))
            [ BlockArg [ Text "Hi" , Space , Text "there" ] ])
diff --git a/test/typ/math/delimited-00.out b/test/typ/math/delimited-00.out
--- a/test/typ/math/delimited-00.out
+++ b/test/typ/math/delimited-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-00.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
-                                 "typ/math/delimited-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MGroup (Just "(") (Just ")") [ Text "a" ]
@@ -64,7 +25,7 @@
     , Text "<"
     , Code
         "typ/math/delimited-00.typ"
-        ( line 4 , column 11 )
+        ( line 3 , column 11 )
         (FuncCall
            (Ident (Identifier "zeta"))
            [ BlockArg
diff --git a/test/typ/math/delimited-01.out b/test/typ/math/delimited-01.out
--- a/test/typ/math/delimited-01.out
+++ b/test/typ/math/delimited-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-01.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
-                                 "typ/math/delimited-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ MGroup
@@ -61,11 +22,11 @@
                 , Text ")"
                 , Code
                     "typ/math/delimited-01.typ"
-                    ( line 3 , column 16 )
+                    ( line 2 , column 16 )
                     (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
                 , Code
                     "typ/math/delimited-01.typ"
-                    ( line 3 , column 19 )
+                    ( line 2 , column 19 )
                     (Ident (Identifier "zeta"))
                 , Text "("
                 , MFrac (Text "x") (Text "2")
diff --git a/test/typ/math/delimited-02.out b/test/typ/math/delimited-02.out
--- a/test/typ/math/delimited-02.out
+++ b/test/typ/math/delimited-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "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
-                                 "typ/math/delimited-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/delimited-02.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FieldAccess
            (Ident (Identifier "l"))
            (FieldAccess
@@ -52,24 +13,24 @@
     , MFrac (Text "a") (Text "b")
     , Code
         "typ/math/delimited-02.typ"
-        ( line 3 , column 8 )
+        ( line 2 , column 8 )
         (FieldAccess
            (Ident (Identifier "r"))
            (FieldAccess
               (Ident (Identifier "stroked")) (Ident (Identifier "bracket"))))
     , Code
         "typ/math/delimited-02.typ"
-        ( line 3 , column 11 )
+        ( line 2 , column 11 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , Code
         "typ/math/delimited-02.typ"
-        ( line 3 , column 14 )
+        ( line 2 , column 14 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg
                [ Code
                    "typ/math/delimited-02.typ"
-                   ( line 3 , column 17 )
+                   ( line 2 , column 17 )
                    (FieldAccess
                       (Ident (Identifier "r"))
                       (FieldAccess
@@ -77,7 +38,7 @@
                , MFrac (Text "a") (Text "b")
                , Code
                    "typ/math/delimited-02.typ"
-                   ( line 3 , column 22 )
+                   ( line 2 , column 22 )
                    (FieldAccess
                       (Ident (Identifier "r"))
                       (FieldAccess
@@ -86,7 +47,7 @@
            ])
     , Code
         "typ/math/delimited-02.typ"
-        ( line 3 , column 26 )
+        ( line 2 , column 26 )
         (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
     , MGroup
         (Just "[") Nothing [ MFrac (Text "a") (Text "b") , Text ")" ]
@@ -96,7 +57,7 @@
     True
     [ Code
         "typ/math/delimited-02.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg [ Text "|" , Text "]" , Text "1" ]
diff --git a/test/typ/math/delimited-03.out b/test/typ/math/delimited-03.out
--- a/test/typ/math/delimited-03.out
+++ b/test/typ/math/delimited-03.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-03.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
-                                 "typ/math/delimited-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "|"
@@ -57,7 +18,7 @@
     , Text "+"
     , Code
         "typ/math/delimited-03.typ"
-        ( line 4 , column 8 )
+        ( line 3 , column 8 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg [ Text "|" , Text "y" , Text "|" ] ])
diff --git a/test/typ/math/delimited-04.out b/test/typ/math/delimited-04.out
--- a/test/typ/math/delimited-04.out
+++ b/test/typ/math/delimited-04.out
@@ -1,74 +1,35 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-04.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
-                                 "typ/math/delimited-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/delimited-04.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FieldAccess
            (Ident (Identifier "l")) (Ident (Identifier "bracket")))
     , MFrac (Text "a") (Text "b")
     , Code
         "typ/math/delimited-04.typ"
-        ( line 3 , column 17 )
+        ( line 2 , column 17 )
         (FieldAccess
            (Ident (Identifier "r")) (Ident (Identifier "bracket")))
     , Text "="
     , Code
         "typ/math/delimited-04.typ"
-        ( line 4 , column 5 )
+        ( line 3 , column 5 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg
                [ Code
                    "typ/math/delimited-04.typ"
-                   ( line 4 , column 8 )
+                   ( line 3 , column 8 )
                    (FieldAccess
                       (Ident (Identifier "l")) (Ident (Identifier "bracket")))
                , MFrac (Text "a") (Text "b")
                , Code
                    "typ/math/delimited-04.typ"
-                   ( line 4 , column 22 )
+                   ( line 3 , column 22 )
                    (FieldAccess
                       (Ident (Identifier "r")) (Ident (Identifier "bracket")))
                ]
diff --git a/test/typ/math/delimited-05.out b/test/typ/math/delimited-05.out
--- a/test/typ/math/delimited-05.out
+++ b/test/typ/math/delimited-05.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-05.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
-                                 "typ/math/delimited-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/delimited-05.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg [ MFrac (Text "a") (Text "b") , Text "]" ] ])
@@ -53,7 +14,7 @@
     , Text "="
     , Code
         "typ/math/delimited-05.typ"
-        ( line 3 , column 19 )
+        ( line 2 , column 19 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg [ Text "{" , MFrac (Text "a") (Text "b") ] ])
diff --git a/test/typ/math/delimited-06.out b/test/typ/math/delimited-06.out
--- a/test/typ/math/delimited-06.out
+++ b/test/typ/math/delimited-06.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-06.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
-                                 "typ/math/delimited-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/delimited-06.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg
@@ -54,7 +15,7 @@
                    (Just (Text "n"))
                    (Code
                       "typ/math/delimited-06.typ"
-                      ( line 3 , column 7 )
+                      ( line 2 , column 7 )
                       (Ident (Identifier "sum")))
                , Text "x"
                , Text "]"
@@ -64,7 +25,7 @@
     , Text "<"
     , Code
         "typ/math/delimited-06.typ"
-        ( line 4 , column 5 )
+        ( line 3 , column 5 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg
diff --git a/test/typ/math/delimited-07.out b/test/typ/math/delimited-07.out
--- a/test/typ/math/delimited-07.out
+++ b/test/typ/math/delimited-07.out
@@ -1,69 +1,30 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-07.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
-                                 "typ/math/delimited-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Code
         "typ/math/delimited-07.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FuncCall
            (Ident (Identifier "floor"))
            [ BlockArg [ MFrac (Text "x") (Text "2") ] ])
     , Text ","
     , Code
         "typ/math/delimited-07.typ"
-        ( line 3 , column 14 )
+        ( line 2 , column 14 )
         (FuncCall
            (Ident (Identifier "ceil"))
            [ BlockArg [ MFrac (Text "x") (Text "2") ] ])
     , Text ","
     , Code
         "typ/math/delimited-07.typ"
-        ( line 3 , column 25 )
+        ( line 2 , column 25 )
         (FuncCall (Ident (Identifier "abs")) [ BlockArg [ Text "x" ] ])
     , Text ","
     , Code
         "typ/math/delimited-07.typ"
-        ( line 3 , column 33 )
+        ( line 2 , column 33 )
         (FuncCall (Ident (Identifier "norm")) [ BlockArg [ Text "x" ] ])
     ]
 , ParBreak
diff --git a/test/typ/math/delimited-08.out b/test/typ/math/delimited-08.out
--- a/test/typ/math/delimited-08.out
+++ b/test/typ/math/delimited-08.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/math/delimited-08.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
-                                 "typ/math/delimited-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/delimited-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/delimited-08.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg
                [ Code
                    "typ/math/delimited-08.typ"
-                   ( line 4 , column 5 )
+                   ( line 3 , column 5 )
                    (FuncCall
                       (Ident (Identifier "text"))
                       [ BlockArg [ Text "(" ]
@@ -59,7 +20,7 @@
                , MFrac (Text "a") (Text "b")
                , Code
                    "typ/math/delimited-08.typ"
-                   ( line 5 , column 5 )
+                   ( line 4 , column 5 )
                    (FuncCall
                       (Ident (Identifier "text"))
                       [ BlockArg [ Text ")" ]
diff --git a/test/typ/math/frac-00.out b/test/typ/math/frac-00.out
--- a/test/typ/math/frac-00.out
+++ b/test/typ/math/frac-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/frac-00.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
-                                 "typ/math/frac-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/frac-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
diff --git a/test/typ/math/frac-01.out b/test/typ/math/frac-01.out
--- a/test/typ/math/frac-01.out
+++ b/test/typ/math/frac-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/frac-01.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
-                                 "typ/math/frac-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/frac-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MFrac
diff --git a/test/typ/math/frac-02.out b/test/typ/math/frac-02.out
--- a/test/typ/math/frac-02.out
+++ b/test/typ/math/frac-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/frac-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
-                                 "typ/math/frac-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/frac-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
@@ -50,24 +11,24 @@
            (Just ")")
            [ Code
                "typ/math/frac-02.typ"
-               ( line 3 , column 8 )
+               ( line 2 , column 8 )
                (Ident (Identifier "minus"))
            , Text "b"
            , Code
                "typ/math/frac-02.typ"
-               ( line 3 , column 11 )
+               ( line 2 , column 11 )
                (FieldAccess
                   (Ident (Identifier "minus")) (Ident (Identifier "plus")))
            , Code
                "typ/math/frac-02.typ"
-               ( line 3 , column 22 )
+               ( line 2 , column 22 )
                (FuncCall
                   (Ident (Identifier "sqrt"))
                   [ BlockArg
                       [ MAttach Nothing (Just (Text "2")) (Text "b")
                       , Code
                           "typ/math/frac-02.typ"
-                          ( line 3 , column 31 )
+                          ( line 2 , column 31 )
                           (Ident (Identifier "minus"))
                       , Text "4"
                       , Text "a"
diff --git a/test/typ/math/frac-03.out b/test/typ/math/frac-03.out
--- a/test/typ/math/frac-03.out
+++ b/test/typ/math/frac-03.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/math/frac-03.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
-                                 "typ/math/frac-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/frac-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/frac-03.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "binom"))
            [ BlockArg
                [ Code
                    "typ/math/frac-03.typ"
-                   ( line 3 , column 9 )
+                   ( line 2 , column 9 )
                    (Ident (Identifier "circle"))
                ]
            , BlockArg
                [ Code
                    "typ/math/frac-03.typ"
-                   ( line 3 , column 17 )
+                   ( line 2 , column 17 )
                    (Ident (Identifier "square"))
                ]
            ])
diff --git a/test/typ/math/frac-05.out b/test/typ/math/frac-05.out
--- a/test/typ/math/frac-05.out
+++ b/test/typ/math/frac-05.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/frac-05.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
-                                 "typ/math/frac-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/frac-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MFrac (MFrac (Text "1") (Text "2")) (Text "3")
diff --git a/test/typ/math/frac-06.out b/test/typ/math/frac-06.out
--- a/test/typ/math/frac-06.out
+++ b/test/typ/math/frac-06.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/frac-06.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
-                                 "typ/math/frac-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/frac-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MFrac
@@ -56,14 +17,14 @@
     , MFrac
         (Code
            "typ/math/frac-06.typ"
-           ( line 3 , column 20 )
+           ( line 2 , column 20 )
            (FuncCall (Ident (Identifier "zeta")) [ BlockArg [ Text "x" ] ]))
         (Text "2")
     , Text ","
     , Text " foo"
     , Code
         "typ/math/frac-06.typ"
-        ( line 3 , column 36 )
+        ( line 2 , column 36 )
         (FieldAccess
            (Ident (Identifier "l"))
            (FieldAccess
@@ -72,7 +33,7 @@
     , MFrac
         (Code
            "typ/math/frac-06.typ"
-           ( line 3 , column 39 )
+           ( line 2 , column 39 )
            (FieldAccess
               (Ident (Identifier "r"))
               (FieldAccess
@@ -94,7 +55,7 @@
     , Text ","
     , Code
         "typ/math/frac-06.typ"
-        ( line 5 , column 23 )
+        ( line 4 , column 23 )
         (Ident (Identifier "phi"))
     , MFrac (MGroup (Just "[") (Just "]") [ Text "x" ]) (Text "2")
     , Text ","
diff --git a/test/typ/math/matrix-00.out b/test/typ/math/matrix-00.out
--- a/test/typ/math/matrix-00.out
+++ b/test/typ/math/matrix-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-00.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
-                                 "typ/math/matrix-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/matrix-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
@@ -51,62 +12,62 @@
     False
     [ Code
         "typ/math/matrix-00.typ"
-        ( line 4 , column 2 )
+        ( line 3 , column 2 )
         (FuncCall (Ident (Identifier "mat")) [])
     , Code
         "typ/math/matrix-00.typ"
-        ( line 4 , column 8 )
+        ( line 3 , column 8 )
         (Ident (Identifier "dot"))
     , Code
         "typ/math/matrix-00.typ"
-        ( line 5 , column 2 )
+        ( line 4 , column 2 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg [ [ MGroup Nothing Nothing [] ] ] ])
     , Code
         "typ/math/matrix-00.typ"
-        ( line 5 , column 9 )
+        ( line 4 , column 9 )
         (Ident (Identifier "dot"))
     , Code
         "typ/math/matrix-00.typ"
-        ( line 6 , column 2 )
+        ( line 5 , column 2 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ BlockArg [ Text "1" ] , BlockArg [ Text "2" ] ])
     , Code
         "typ/math/matrix-00.typ"
-        ( line 6 , column 12 )
+        ( line 5 , column 12 )
         (Ident (Identifier "dot"))
     , Code
         "typ/math/matrix-00.typ"
-        ( line 7 , column 2 )
+        ( line 6 , column 2 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg [ [ Text "1" , Text "2" ] ] ])
     , HardBreak
     , Code
         "typ/math/matrix-00.typ"
-        ( line 8 , column 2 )
+        ( line 7 , column 2 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg [ [ Text "1" ] , [ Text "2" ] ] ])
     , Code
         "typ/math/matrix-00.typ"
-        ( line 8 , column 12 )
+        ( line 7 , column 12 )
         (Ident (Identifier "dot"))
     , Code
         "typ/math/matrix-00.typ"
-        ( line 9 , column 2 )
+        ( line 8 , column 2 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg [ [ Text "1" , Text "2" ] , [ Text "3" , Text "4" ] ] ])
     , Code
         "typ/math/matrix-00.typ"
-        ( line 9 , column 18 )
+        ( line 8 , column 18 )
         (Ident (Identifier "dot"))
     , Code
         "typ/math/matrix-00.typ"
-        ( line 10 , column 2 )
+        ( line 9 , column 2 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
diff --git a/test/typ/math/matrix-01.out b/test/typ/math/matrix-01.out
--- a/test/typ/math/matrix-01.out
+++ b/test/typ/math/matrix-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-01.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
-                                 "typ/math/matrix-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-01.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -52,7 +13,7 @@
                  , Text "2"
                  , Code
                      "typ/math/matrix-01.typ"
-                     ( line 4 , column 9 )
+                     ( line 3 , column 9 )
                      (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                  , Text "10"
                  ]
@@ -60,33 +21,33 @@
                  , Text "2"
                  , Code
                      "typ/math/matrix-01.typ"
-                     ( line 5 , column 9 )
+                     ( line 4 , column 9 )
                      (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                  , Text "10"
                  ]
                , [ Code
                      "typ/math/matrix-01.typ"
-                     ( line 6 , column 3 )
+                     ( line 5 , column 3 )
                      (FieldAccess (Ident (Identifier "v")) (Ident (Identifier "dots")))
                  , Code
                      "typ/math/matrix-01.typ"
-                     ( line 6 , column 11 )
+                     ( line 5 , column 11 )
                      (FieldAccess (Ident (Identifier "v")) (Ident (Identifier "dots")))
                  , Code
                      "typ/math/matrix-01.typ"
-                     ( line 6 , column 19 )
+                     ( line 5 , column 19 )
                      (FieldAccess
                         (Ident (Identifier "down")) (Ident (Identifier "dots")))
                  , Code
                      "typ/math/matrix-01.typ"
-                     ( line 6 , column 30 )
+                     ( line 5 , column 30 )
                      (FieldAccess (Ident (Identifier "v")) (Ident (Identifier "dots")))
                  ]
                , [ Text "10"
                  , Text "10"
                  , Code
                      "typ/math/matrix-01.typ"
-                     ( line 7 , column 11 )
+                     ( line 6 , column 11 )
                      (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                  , Text "10"
                  ]
diff --git a/test/typ/math/matrix-02.out b/test/typ/math/matrix-02.out
--- a/test/typ/math/matrix-02.out
+++ b/test/typ/math/matrix-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-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
-                                 "typ/math/matrix-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-02.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -57,7 +18,7 @@
                          Nothing
                          (Code
                             "typ/math/matrix-02.typ"
-                            ( line 5 , column 3 )
+                            ( line 4 , column 3 )
                             (Ident (Identifier "sum")))
                      , Text "x"
                      ]
@@ -68,11 +29,11 @@
                  ]
                , [ Code
                      "typ/math/matrix-02.typ"
-                     ( line 6 , column 3 )
+                     ( line 5 , column 3 )
                      (Ident (Identifier "zeta"))
                  , Code
                      "typ/math/matrix-02.typ"
-                     ( line 6 , column 9 )
+                     ( line 5 , column 9 )
                      (Ident (Identifier "alpha"))
                  ]
                ]
diff --git a/test/typ/math/matrix-03.out b/test/typ/math/matrix-03.out
--- a/test/typ/math/matrix-03.out
+++ b/test/typ/math/matrix-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-03.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
-                                 "typ/math/matrix-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/matrix-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (FieldAccess
           (Ident (Identifier "mat")) (Ident (Identifier "math")))
@@ -52,7 +13,7 @@
     True
     [ Code
         "typ/math/matrix-03.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg [ [ Text "1" , Text "2" ] , [ Text "3" , Text "4" ] ] ])
@@ -64,7 +25,7 @@
     , Text "+"
     , Code
         "typ/math/matrix-03.typ"
-        ( line 5 , column 7 )
+        ( line 4 , column 7 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ KeyValArg (Identifier "delim") (Literal None)
diff --git a/test/typ/math/matrix-04.out b/test/typ/math/matrix-04.out
--- a/test/typ/math/matrix-04.out
+++ b/test/typ/math/matrix-04.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-04.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
-                                 "typ/math/matrix-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/matrix-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
 , SoftBreak
 , Code
     "typ/math/matrix-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg (Identifier "columns") (Literal (Int 3))
@@ -61,7 +22,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 8 , column 5 )
+                         ( line 7 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ BlockArg [ Text "1" ]
@@ -77,7 +38,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 9 , column 5 )
+                         ( line 8 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ ArrayArg [ [ Text "1" , Text "2" ] ]
@@ -92,7 +53,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 10 , column 5 )
+                         ( line 9 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ KeyValArg (Identifier "delim") (Block (Content [ Text "[" ]))
@@ -108,7 +69,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 12 , column 5 )
+                         ( line 11 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ ArrayArg [ [ Text "1" ] , [ Text "2" ] ]
@@ -123,7 +84,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 13 , column 5 )
+                         ( line 12 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ ArrayArg [ [ Text "1" ] ]
@@ -139,7 +100,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 14 , column 5 )
+                         ( line 13 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ KeyValArg (Identifier "delim") (Block (Content [ Text "[" ]))
@@ -154,7 +115,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 16 , column 5 )
+                         ( line 15 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ ArrayArg [ [ Text "1" , Text "2" ] ]
@@ -171,7 +132,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 17 , column 5 )
+                         ( line 16 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ KeyValArg (Identifier "delim") (Block (Content [ Text "[" ]))
@@ -186,7 +147,7 @@
                      True
                      [ Code
                          "typ/math/matrix-04.typ"
-                         ( line 18 , column 5 )
+                         ( line 17 , column 5 )
                          (FuncCall
                             (Ident (Identifier "mat"))
                             [ ArrayArg [ [ Text "1" , Text "2" ] , [ Text "3" , Text "4" ] ]
diff --git a/test/typ/math/matrix-alignment-00.out b/test/typ/math/matrix-alignment-00.out
--- a/test/typ/math/matrix-alignment-00.out
+++ b/test/typ/math/matrix-alignment-00.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-00.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
-                                 "typ/math/matrix-alignment-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-00.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "vec"))
            [ BlockArg
diff --git a/test/typ/math/matrix-alignment-01.out b/test/typ/math/matrix-alignment-01.out
--- a/test/typ/math/matrix-alignment-01.out
+++ b/test/typ/math/matrix-alignment-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-01.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
-                                 "typ/math/matrix-alignment-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-01.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
diff --git a/test/typ/math/matrix-alignment-02.out b/test/typ/math/matrix-alignment-02.out
--- a/test/typ/math/matrix-alignment-02.out
+++ b/test/typ/math/matrix-alignment-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-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
-                                 "typ/math/matrix-alignment-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-02.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
diff --git a/test/typ/math/matrix-alignment-03.out b/test/typ/math/matrix-alignment-03.out
--- a/test/typ/math/matrix-alignment-03.out
+++ b/test/typ/math/matrix-alignment-03.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-03.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
-                                 "typ/math/matrix-alignment-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-03.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
diff --git a/test/typ/math/matrix-alignment-04.out b/test/typ/math/matrix-alignment-04.out
--- a/test/typ/math/matrix-alignment-04.out
+++ b/test/typ/math/matrix-alignment-04.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-04.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
-                                 "typ/math/matrix-alignment-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-04.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
diff --git a/test/typ/math/matrix-alignment-05.out b/test/typ/math/matrix-alignment-05.out
--- a/test/typ/math/matrix-alignment-05.out
+++ b/test/typ/math/matrix-alignment-05.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-05.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
-                                 "typ/math/matrix-alignment-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-05.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -61,7 +22,7 @@
     True
     [ Code
         "typ/math/matrix-alignment-05.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -82,7 +43,7 @@
     True
     [ Code
         "typ/math/matrix-alignment-05.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -112,7 +73,7 @@
     True
     [ Code
         "typ/math/matrix-alignment-05.typ"
-        ( line 6 , column 3 )
+        ( line 5 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -134,7 +95,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-05.typ"
-                         ( line 6 , column 17 )
+                         ( line 5 , column 17 )
                          (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                      , Text "."
                      , Text "."
@@ -143,7 +104,7 @@
                      , MAlignPoint
                      , Code
                          "typ/math/matrix-alignment-05.typ"
-                         ( line 6 , column 25 )
+                         ( line 5 , column 25 )
                          (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                      , Text "."
                      , Text "."
diff --git a/test/typ/math/matrix-alignment-06.out b/test/typ/math/matrix-alignment-06.out
--- a/test/typ/math/matrix-alignment-06.out
+++ b/test/typ/math/matrix-alignment-06.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/matrix-alignment-06.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
-                                 "typ/math/matrix-alignment-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/matrix-alignment-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/matrix-alignment-06.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -53,7 +14,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 3 , column 7 )
+                         ( line 2 , column 7 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -66,7 +27,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 3 , column 20 )
+                         ( line 2 , column 20 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -79,7 +40,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 3 , column 33 )
+                         ( line 2 , column 33 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -92,7 +53,7 @@
     True
     [ Code
         "typ/math/matrix-alignment-06.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -101,7 +62,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 4 , column 7 )
+                         ( line 3 , column 7 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      , MAlignPoint
@@ -115,7 +76,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 4 , column 24 )
+                         ( line 3 , column 24 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      , MAlignPoint
@@ -129,7 +90,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 4 , column 41 )
+                         ( line 3 , column 41 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      , MAlignPoint
@@ -143,7 +104,7 @@
     True
     [ Code
         "typ/math/matrix-alignment-06.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -152,7 +113,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 5 , column 7 )
+                         ( line 4 , column 7 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      , MAlignPoint
@@ -166,7 +127,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 5 , column 23 )
+                         ( line 4 , column 23 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -179,7 +140,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 5 , column 36 )
+                         ( line 4 , column 36 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -192,7 +153,7 @@
     True
     [ Code
         "typ/math/matrix-alignment-06.typ"
-        ( line 6 , column 3 )
+        ( line 5 , column 3 )
         (FuncCall
            (Ident (Identifier "mat"))
            [ ArrayArg
@@ -202,7 +163,7 @@
                      [ MAlignPoint
                      , Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 6 , column 8 )
+                         ( line 5 , column 8 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -215,7 +176,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 6 , column 23 )
+                         ( line 5 , column 23 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
@@ -228,7 +189,7 @@
                      Nothing
                      [ Code
                          "typ/math/matrix-alignment-06.typ"
-                         ( line 6 , column 36 )
+                         ( line 5 , column 36 )
                          (Ident (Identifier "minus"))
                      , Text "1"
                      ]
diff --git a/test/typ/math/multiline-00.out b/test/typ/math/multiline-00.out
--- a/test/typ/math/multiline-00.out
+++ b/test/typ/math/multiline-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-00.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
-                                 "typ/math/multiline-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
@@ -60,12 +21,12 @@
     , Text "="
     , Code
         "typ/math/multiline-00.typ"
-        ( line 5 , column 8 )
+        ( line 4 , column 8 )
         (Ident (Identifier "sum"))
     , Text "x"
     , Code
         "typ/math/multiline-00.typ"
-        ( line 5 , column 14 )
+        ( line 4 , column 14 )
         (Ident (Identifier "dot"))
     , Text "2"
     , Text "z"
diff --git a/test/typ/math/multiline-01.out b/test/typ/math/multiline-01.out
--- a/test/typ/math/multiline-01.out
+++ b/test/typ/math/multiline-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-01.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
-                                 "typ/math/multiline-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
@@ -63,15 +24,15 @@
     , Text "="
     , Code
         "typ/math/multiline-01.typ"
-        ( line 5 , column 12 )
+        ( line 4 , column 12 )
         (Ident (Identifier "alpha"))
     , Code
         "typ/math/multiline-01.typ"
-        ( line 5 , column 18 )
+        ( line 4 , column 18 )
         (Ident (Identifier "dot"))
     , Code
         "typ/math/multiline-01.typ"
-        ( line 5 , column 22 )
+        ( line 4 , column 22 )
         (Ident (Identifier "beta"))
     ]
 , ParBreak
diff --git a/test/typ/math/multiline-02.out b/test/typ/math/multiline-02.out
--- a/test/typ/math/multiline-02.out
+++ b/test/typ/math/multiline-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-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
-                                 "typ/math/multiline-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "a"
diff --git a/test/typ/math/multiline-03.out b/test/typ/math/multiline-03.out
--- a/test/typ/math/multiline-03.out
+++ b/test/typ/math/multiline-03.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-03.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
-                                 "typ/math/multiline-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "f"
     , Code
         "typ/math/multiline-03.typ"
-        ( line 3 , column 5 )
+        ( line 2 , column 5 )
         (FieldAccess
            (Ident (Identifier "eq")) (Ident (Identifier "colon")))
     , Code
         "typ/math/multiline-03.typ"
-        ( line 3 , column 8 )
+        ( line 2 , column 8 )
         (FuncCall
            (Ident (Identifier "cases"))
            [ BlockArg
diff --git a/test/typ/math/multiline-04.out b/test/typ/math/multiline-04.out
--- a/test/typ/math/multiline-04.out
+++ b/test/typ/math/multiline-04.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-04.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
-                                 "typ/math/multiline-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text " abc "
diff --git a/test/typ/math/multiline-05.out b/test/typ/math/multiline-05.out
--- a/test/typ/math/multiline-05.out
+++ b/test/typ/math/multiline-05.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-05.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
-                                 "typ/math/multiline-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -50,24 +11,24 @@
               [ Text "n"
               , Code
                   "typ/math/multiline-05.typ"
-                  ( line 3 , column 10 )
+                  ( line 2 , column 10 )
                   (Ident (Identifier "in"))
               , Code
                   "typ/math/multiline-05.typ"
-                  ( line 3 , column 13 )
+                  ( line 2 , column 13 )
                   (Ident (Identifier "NN"))
               , HardBreak
               , Text "n"
               , Code
                   "typ/math/multiline-05.typ"
-                  ( line 3 , column 20 )
+                  ( line 2 , column 20 )
                   (FieldAccess (Ident (Identifier "eq")) (Ident (Identifier "lt")))
               , Text "5"
               ]))
         Nothing
         (Code
            "typ/math/multiline-05.typ"
-           ( line 3 , column 3 )
+           ( line 2 , column 3 )
            (Ident (Identifier "sum")))
     , Text "n"
     , Text "="
diff --git a/test/typ/math/multiline-06.out b/test/typ/math/multiline-06.out
--- a/test/typ/math/multiline-06.out
+++ b/test/typ/math/multiline-06.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-06.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
-                                 "typ/math/multiline-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True [ Text " abc " , MAlignPoint , Text "=" , Text "c" ]
 , SoftBreak
diff --git a/test/typ/math/multiline-07.out b/test/typ/math/multiline-07.out
--- a/test/typ/math/multiline-07.out
+++ b/test/typ/math/multiline-07.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-07.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
-                                 "typ/math/multiline-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text " abc " , MAlignPoint , Text "=" , Text "c" , HardBreak ]
diff --git a/test/typ/math/multiline-08.out b/test/typ/math/multiline-08.out
--- a/test/typ/math/multiline-08.out
+++ b/test/typ/math/multiline-08.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/multiline-08.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
-                                 "typ/math/multiline-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/multiline-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text " abc "
diff --git a/test/typ/math/numbering-00.out b/test/typ/math/numbering-00.out
--- a/test/typ/math/numbering-00.out
+++ b/test/typ/math/numbering-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/math/numbering-00.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
-                                 "typ/math/numbering-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/numbering-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/math/numbering-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 150.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/math/numbering-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (FieldAccess
           (Ident (Identifier "equation")) (Ident (Identifier "math")))
@@ -73,11 +33,11 @@
     True
     [ Code
         "typ/math/numbering-00.typ"
-        ( line 6 , column 3 )
+        ( line 5 , column 3 )
         (FieldAccess (Ident (Identifier "alt")) (Ident (Identifier "phi")))
     , Code
         "typ/math/numbering-00.typ"
-        ( line 6 , column 11 )
+        ( line 5 , column 11 )
         (FieldAccess
            (Ident (Identifier "eq")) (Ident (Identifier "colon")))
     , MFrac
@@ -88,14 +48,14 @@
            , Text "+"
            , Code
                "typ/math/numbering-00.typ"
-               ( line 6 , column 19 )
+               ( line 5 , column 19 )
                (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "5" ] ])
            ])
         (Text "2")
     ]
 , Space
 , Code
-    "typ/math/numbering-00.typ" ( line 6 , column 34 ) (Label "ratio")
+    "typ/math/numbering-00.typ" ( line 5 , column 34 ) (Label "ratio")
 , ParBreak
 , Text "With"
 , Space
@@ -112,7 +72,7 @@
     , Text "="
     , Code
         "typ/math/numbering-00.typ"
-        ( line 9 , column 9 )
+        ( line 8 , column 9 )
         (FuncCall
            (Ident (Identifier "round"))
            [ BlockArg
@@ -120,14 +80,14 @@
                    (Text "1")
                    (Code
                       "typ/math/numbering-00.typ"
-                      ( line 9 , column 19 )
+                      ( line 8 , column 19 )
                       (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "5" ] ]))
                , MAttach
                    Nothing
                    (Just (Text "n"))
                    (Code
                       "typ/math/numbering-00.typ"
-                      ( line 9 , column 27 )
+                      ( line 8 , column 27 )
                       (FieldAccess
                          (Ident (Identifier "alt")) (Ident (Identifier "phi"))))
                ]
@@ -135,13 +95,11 @@
     ]
 , Space
 , Code
-    "typ/math/numbering-00.typ" ( line 9 , column 40 ) (Label "fib")
+    "typ/math/numbering-00.typ" ( line 8 , column 40 ) (Label "fib")
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  text(body: [We define ]), 
diff --git a/test/typ/math/op-00.out b/test/typ/math/op-00.out
--- a/test/typ/math/op-00.out
+++ b/test/typ/math/op-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/op-00.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
-                                 "typ/math/op-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/op-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -50,19 +11,19 @@
               [ Text "1"
               , Code
                   "typ/math/op-00.typ"
-                  ( line 3 , column 9 )
+                  ( line 2 , column 9 )
                   (FieldAccess (Ident (Identifier "eq")) (Ident (Identifier "lt")))
               , Text "n"
               , Code
                   "typ/math/op-00.typ"
-                  ( line 3 , column 12 )
+                  ( line 2 , column 12 )
                   (FieldAccess (Ident (Identifier "eq")) (Ident (Identifier "lt")))
               , Text "m"
               ]))
         Nothing
         (Code
            "typ/math/op-00.typ"
-           ( line 3 , column 3 )
+           ( line 2 , column 3 )
            (Ident (Identifier "max")))
     , Text "n"
     ]
diff --git a/test/typ/math/op-01.out b/test/typ/math/op-01.out
--- a/test/typ/math/op-01.out
+++ b/test/typ/math/op-01.out
@@ -1,51 +1,12 @@
 --- parse tree ---
-[ Code
-    "typ/math/op-01.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
-                                 "typ/math/op-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/op-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAlignPoint
     , Code
         "typ/math/op-01.typ"
-        ( line 3 , column 5 )
+        ( line 2 , column 5 )
         (Ident (Identifier "sin"))
     , Text "x"
     , Text "+"
@@ -54,7 +15,7 @@
         Nothing
         (Code
            "typ/math/op-01.typ"
-           ( line 3 , column 13 )
+           ( line 2 , column 13 )
            (Ident (Identifier "log")))
     , Text "x"
     , HardBreak
@@ -62,7 +23,7 @@
     , MAlignPoint
     , Code
         "typ/math/op-01.typ"
-        ( line 4 , column 5 )
+        ( line 3 , column 5 )
         (FuncCall (Ident (Identifier "sin")) [ BlockArg [ Text "x" ] ])
     , Text "+"
     , MAttach
@@ -70,7 +31,7 @@
         Nothing
         (Code
            "typ/math/op-01.typ"
-           ( line 4 , column 14 )
+           ( line 3 , column 14 )
            (Ident (Identifier "log")))
     , MGroup (Just "(") (Just ")") [ Text "x" ]
     ]
diff --git a/test/typ/math/op-02.out b/test/typ/math/op-02.out
--- a/test/typ/math/op-02.out
+++ b/test/typ/math/op-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/op-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
-                                 "typ/math/op-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/op-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/op-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -61,17 +22,17 @@
               [ Text "n"
               , Code
                   "typ/math/op-02.typ"
-                  ( line 4 , column 16 )
+                  ( line 3 , column 16 )
                   (FieldAccess (Ident (Identifier "r")) (Ident (Identifier "arrow")))
               , Code
                   "typ/math/op-02.typ"
-                  ( line 4 , column 18 )
+                  ( line 3 , column 18 )
                   (Ident (Identifier "oo"))
               ]))
         Nothing
         (Code
            "typ/math/op-02.typ"
-           ( line 4 , column 10 )
+           ( line 3 , column 10 )
            (Ident (Identifier "lim")))
     , MFrac (Text "1") (Text "n")
     ]
@@ -89,17 +50,17 @@
               [ Text "n"
               , Code
                   "typ/math/op-02.typ"
-                  ( line 5 , column 9 )
+                  ( line 4 , column 9 )
                   (FieldAccess (Ident (Identifier "r")) (Ident (Identifier "arrow")))
               , Code
                   "typ/math/op-02.typ"
-                  ( line 5 , column 11 )
+                  ( line 4 , column 11 )
                   (Ident (Identifier "infinity"))
               ]))
         Nothing
         (Code
            "typ/math/op-02.typ"
-           ( line 5 , column 3 )
+           ( line 4 , column 3 )
            (Ident (Identifier "lim")))
     , MFrac (Text "1") (Text "n")
     , Text "="
diff --git a/test/typ/math/op-03.out b/test/typ/math/op-03.out
--- a/test/typ/math/op-03.out
+++ b/test/typ/math/op-03.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/op-03.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
-                                 "typ/math/op-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/op-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -50,7 +11,7 @@
               [ Text "x"
               , Code
                   "typ/math/op-03.typ"
-                  ( line 3 , column 32 )
+                  ( line 2 , column 32 )
                   (FieldAccess
                      (Ident (Identifier "eq")) (Ident (Identifier "colon")))
               , Text "1"
@@ -58,7 +19,7 @@
         Nothing
         (Code
            "typ/math/op-03.typ"
-           ( line 3 , column 3 )
+           ( line 2 , column 3 )
            (FuncCall
               (Ident (Identifier "op"))
               [ BlockArg [ Text "myop" ]
@@ -74,7 +35,7 @@
               [ Text "x"
               , Code
                   "typ/math/op-03.typ"
-                  ( line 4 , column 31 )
+                  ( line 3 , column 31 )
                   (FieldAccess
                      (Ident (Identifier "eq")) (Ident (Identifier "colon")))
               , Text "1"
@@ -82,7 +43,7 @@
         Nothing
         (Code
            "typ/math/op-03.typ"
-           ( line 4 , column 3 )
+           ( line 3 , column 3 )
            (FuncCall
               (Ident (Identifier "op"))
               [ BlockArg [ Text "myop" ]
diff --git a/test/typ/math/op-04.out b/test/typ/math/op-04.out
--- a/test/typ/math/op-04.out
+++ b/test/typ/math/op-04.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/op-04.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
-                                 "typ/math/op-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/op-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -47,13 +8,13 @@
         Nothing
         (Code
            "typ/math/op-04.typ"
-           ( line 3 , column 3 )
+           ( line 2 , column 3 )
            (FuncCall
               (Ident (Identifier "bold"))
               [ BlockArg
                   [ Code
                       "typ/math/op-04.typ"
-                      ( line 3 , column 8 )
+                      ( line 2 , column 8 )
                       (FuncCall
                          (Ident (Identifier "op"))
                          [ BlockArg [ Text "bold" ]
diff --git a/test/typ/math/root-00.out b/test/typ/math/root-00.out
--- a/test/typ/math/root-00.out
+++ b/test/typ/math/root-00.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/root-00.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
-                                 "typ/math/root-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/root-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "A"
     , Text "="
     , Code
         "typ/math/root-00.typ"
-        ( line 3 , column 6 )
+        ( line 2 , column 6 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg [ Text "x" , Text "+" , Text "y" ] ])
diff --git a/test/typ/math/root-01.out b/test/typ/math/root-01.out
--- a/test/typ/math/root-01.out
+++ b/test/typ/math/root-01.out
@@ -1,91 +1,52 @@
 --- parse tree ---
-[ Code
-    "typ/math/root-01.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
-                                 "typ/math/root-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/root-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/root-01.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "a" ] ])
     , Code
         "typ/math/root-01.typ"
-        ( line 3 , column 11 )
+        ( line 2 , column 11 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-01.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "f" ] ])
     , Code
         "typ/math/root-01.typ"
-        ( line 4 , column 11 )
+        ( line 3 , column 11 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-01.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "q" ] ])
     , Code
         "typ/math/root-01.typ"
-        ( line 5 , column 11 )
+        ( line 4 , column 11 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-01.typ"
-        ( line 6 , column 3 )
+        ( line 5 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg [ MAttach Nothing (Just (Text "2")) (Text "a") ] ])
     , HardBreak
     , Code
         "typ/math/root-01.typ"
-        ( line 7 , column 3 )
+        ( line 6 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg [ MAttach (Just (Text "0")) Nothing (Text "n") ] ])
     , Code
         "typ/math/root-01.typ"
-        ( line 7 , column 13 )
+        ( line 6 , column 13 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-01.typ"
-        ( line 8 , column 3 )
+        ( line 7 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
@@ -93,21 +54,21 @@
            ])
     , Code
         "typ/math/root-01.typ"
-        ( line 8 , column 14 )
+        ( line 7 , column 14 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-01.typ"
-        ( line 9 , column 3 )
+        ( line 8 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg [ MAttach Nothing (Just (Text "2")) (Text "b") ] ])
     , Code
         "typ/math/root-01.typ"
-        ( line 9 , column 13 )
+        ( line 8 , column 13 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-01.typ"
-        ( line 10 , column 3 )
+        ( line 9 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
diff --git a/test/typ/math/root-02.out b/test/typ/math/root-02.out
--- a/test/typ/math/root-02.out
+++ b/test/typ/math/root-02.out
@@ -1,51 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/root-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
-                                 "typ/math/root-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/root-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Equation
     False
     [ Code
         "typ/math/root-02.typ"
-        ( line 4 , column 2 )
+        ( line 3 , column 2 )
         (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "x" ] ])
     ]
 , SoftBreak
@@ -53,7 +15,7 @@
     False
     [ Code
         "typ/math/root-02.typ"
-        ( line 5 , column 2 )
+        ( line 4 , column 2 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "2" ] , BlockArg [ Text "x" ] ])
@@ -63,7 +25,7 @@
     False
     [ Code
         "typ/math/root-02.typ"
-        ( line 6 , column 2 )
+        ( line 5 , column 2 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "3" ] , BlockArg [ Text "x" ] ])
@@ -73,7 +35,7 @@
     False
     [ Code
         "typ/math/root-02.typ"
-        ( line 7 , column 2 )
+        ( line 6 , column 2 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "4" ] , BlockArg [ Text "x" ] ])
@@ -83,7 +45,7 @@
     False
     [ Code
         "typ/math/root-02.typ"
-        ( line 8 , column 2 )
+        ( line 7 , column 2 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "5" ] , BlockArg [ Text "x" ] ])
@@ -92,6 +54,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  math.equation(block: false, 
                                body: math.sqrt(radicand: text(body: [x])), 
diff --git a/test/typ/math/root-03.out b/test/typ/math/root-03.out
--- a/test/typ/math/root-03.out
+++ b/test/typ/math/root-03.out
@@ -1,56 +1,17 @@
 --- parse tree ---
-[ Code
-    "typ/math/root-03.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
-                                 "typ/math/root-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/root-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/root-03.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
                [ Code
                    "typ/math/root-03.typ"
-                   ( line 3 , column 8 )
+                   ( line 2 , column 8 )
                    (FieldAccess
                       (Ident (Identifier "l"))
                       (FieldAccess
@@ -61,7 +22,7 @@
                    (Just (Text "2"))
                    (Code
                       "typ/math/root-03.typ"
-                      ( line 3 , column 11 )
+                      ( line 2 , column 11 )
                       (FieldAccess
                          (Ident (Identifier "r"))
                          (FieldAccess
@@ -69,7 +30,7 @@
                , Text "+"
                , Code
                    "typ/math/root-03.typ"
-                   ( line 3 , column 18 )
+                   ( line 2 , column 18 )
                    (FieldAccess
                       (Ident (Identifier "l"))
                       (FieldAccess
@@ -80,7 +41,7 @@
                    (Just (Text "2"))
                    (Code
                       "typ/math/root-03.typ"
-                      ( line 3 , column 21 )
+                      ( line 2 , column 21 )
                       (FieldAccess
                          (Ident (Identifier "r"))
                          (FieldAccess
@@ -90,7 +51,7 @@
     , Text "<"
     , Code
         "typ/math/root-03.typ"
-        ( line 3 , column 29 )
+        ( line 2 , column 29 )
         (FieldAccess
            (Ident (Identifier "l"))
            (FieldAccess
@@ -98,7 +59,7 @@
     , Text "z"
     , Code
         "typ/math/root-03.typ"
-        ( line 3 , column 32 )
+        ( line 2 , column 32 )
         (FieldAccess
            (Ident (Identifier "r"))
            (FieldAccess
@@ -111,7 +72,7 @@
     , Text "="
     , Code
         "typ/math/root-03.typ"
-        ( line 4 , column 7 )
+        ( line 3 , column 7 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg
@@ -123,7 +84,7 @@
     , Text "="
     , Code
         "typ/math/root-03.typ"
-        ( line 5 , column 6 )
+        ( line 4 , column 6 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "3" ]
@@ -140,7 +101,7 @@
     , Text "="
     , Code
         "typ/math/root-03.typ"
-        ( line 6 , column 6 )
+        ( line 5 , column 6 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "4" ]
diff --git a/test/typ/math/root-04.out b/test/typ/math/root-04.out
--- a/test/typ/math/root-04.out
+++ b/test/typ/math/root-04.out
@@ -1,60 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/math/root-04.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
-                                 "typ/math/root-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/root-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/root-04.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ Text "2" ] , BlockArg [ Text "x" ] ])
     , Code
         "typ/math/root-04.typ"
-        ( line 3 , column 14 )
+        ( line 2 , column 14 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-04.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg
@@ -65,11 +26,11 @@
            ])
     , Code
         "typ/math/root-04.typ"
-        ( line 4 , column 20 )
+        ( line 3 , column 20 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-04.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ MFrac (Text "1") (Text "11") ]
@@ -77,11 +38,11 @@
            ])
     , Code
         "typ/math/root-04.typ"
-        ( line 5 , column 17 )
+        ( line 4 , column 17 )
         (Ident (Identifier "quad"))
     , Code
         "typ/math/root-04.typ"
-        ( line 6 , column 3 )
+        ( line 5 , column 3 )
         (FuncCall
            (Ident (Identifier "root"))
            [ BlockArg [ MFrac (MFrac (Text "1") (Text "2")) (Text "3") ]
diff --git a/test/typ/math/root-05.out b/test/typ/math/root-05.out
--- a/test/typ/math/root-05.out
+++ b/test/typ/math/root-05.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/root-05.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
-                                 "typ/math/root-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/root-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/root-05.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "root"))
            [ NormalArg
@@ -53,7 +14,7 @@
     , Text "="
     , Code
         "typ/math/root-05.typ"
-        ( line 3 , column 10 )
+        ( line 2 , column 10 )
         (FuncCall
            (Ident (Identifier "sqrt"))
            [ BlockArg [ MAttach Nothing (Just (Text "3")) (Text "2") ] ])
@@ -63,18 +24,18 @@
     True
     [ Code
         "typ/math/root-05.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (Ident (Identifier "root"))
     , MGroup (Just "(") (Just ")") [ Text "x" , Text "+" , Text "y" ]
     , Code
         "typ/math/root-05.typ"
-        ( line 4 , column 10 )
+        ( line 3 , column 10 )
         (Ident (Identifier "quad"))
     , Text "\8731"
     , Text "x"
     , Code
         "typ/math/root-05.typ"
-        ( line 4 , column 18 )
+        ( line 3 , column 18 )
         (Ident (Identifier "quad"))
     , Text "\8732"
     , Text "x"
@@ -87,7 +48,7 @@
         (Just ")")
         [ Code
             "typ/math/root-05.typ"
-            ( line 5 , column 4 )
+            ( line 4 , column 4 )
             (FuncCall
                (Ident (Identifier "root"))
                [ NormalArg (Block (Content [ Text "2" ])) ])
@@ -100,7 +61,7 @@
         (Just ")")
         [ Code
             "typ/math/root-05.typ"
-            ( line 5 , column 13 )
+            ( line 4 , column 13 )
             (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "2" ] ])
         , Text "+"
         , Text "3"
diff --git a/test/typ/math/spacing-00.out b/test/typ/math/spacing-00.out
--- a/test/typ/math/spacing-00.out
+++ b/test/typ/math/spacing-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/spacing-00.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
-                                 "typ/math/spacing-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/spacing-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "\228"
@@ -64,7 +25,7 @@
         (Just "}")
         [ Code
             "typ/math/spacing-00.typ"
-            ( line 4 , column 12 )
+            ( line 3 , column 12 )
             (Ident (Identifier "times"))
         ]
     ]
@@ -78,7 +39,7 @@
     , Text "|"
     , Code
         "typ/math/spacing-00.typ"
-        ( line 5 , column 8 )
+        ( line 4 , column 8 )
         (Ident (Identifier "minus"))
     , Text "|"
     , Text ","
@@ -103,7 +64,7 @@
     False
     [ Code
         "typ/math/spacing-00.typ"
-        ( line 7 , column 2 )
+        ( line 6 , column 2 )
         (Ident (Identifier "minus"))
     , Text "a"
     , Text ","
@@ -117,7 +78,7 @@
     [ Text "a"
     , Code
         "typ/math/spacing-00.typ"
-        ( line 8 , column 4 )
+        ( line 7 , column 4 )
         (Ident (Identifier "not"))
     , Text "b"
     ]
@@ -132,7 +93,7 @@
     , Text "a"
     , Code
         "typ/math/spacing-00.typ"
-        ( line 9 , column 8 )
+        ( line 8 , column 8 )
         (FieldAccess (Ident (Identifier "op")) (Ident (Identifier "ast")))
     , Text "b"
     ]
@@ -142,13 +103,13 @@
     False
     [ Code
         "typ/math/spacing-00.typ"
-        ( line 10 , column 2 )
+        ( line 9 , column 2 )
         (Ident (Identifier "sum"))
     , Text "x"
     , Text ","
     , Code
         "typ/math/spacing-00.typ"
-        ( line 10 , column 9 )
+        ( line 9 , column 9 )
         (FuncCall (Ident (Identifier "sum")) [ BlockArg [ Text "x" ] ])
     ]
 , Space
@@ -157,11 +118,11 @@
     False
     [ Code
         "typ/math/spacing-00.typ"
-        ( line 11 , column 2 )
+        ( line 10 , column 2 )
         (Ident (Identifier "sum"))
     , Code
         "typ/math/spacing-00.typ"
-        ( line 11 , column 6 )
+        ( line 10 , column 6 )
         (Ident (Identifier "product"))
     , Text "x"
     ]
@@ -176,7 +137,7 @@
     , Text ","
     , Code
         "typ/math/spacing-00.typ"
-        ( line 12 , column 8 )
+        ( line 11 , column 8 )
         (FuncCall (Ident (Identifier "zeta")) [ BlockArg [ Text "x" ] ])
     , Text ","
     , MGroup
diff --git a/test/typ/math/spacing-01.out b/test/typ/math/spacing-01.out
--- a/test/typ/math/spacing-01.out
+++ b/test/typ/math/spacing-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/spacing-01.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
-                                 "typ/math/spacing-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/spacing-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "f"
diff --git a/test/typ/math/spacing-02.out b/test/typ/math/spacing-02.out
--- a/test/typ/math/spacing-02.out
+++ b/test/typ/math/spacing-02.out
@@ -1,72 +1,33 @@
 --- parse tree ---
-[ Code
-    "typ/math/spacing-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
-                                 "typ/math/spacing-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/spacing-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "a"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 3 , column 4 )
+        ( line 2 , column 4 )
         (Ident (Identifier "thin"))
     , Text "b"
     , Text ","
     , Text "a"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 3 , column 14 )
+        ( line 2 , column 14 )
         (Ident (Identifier "med"))
     , Text "b"
     , Text ","
     , Text "a"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 3 , column 23 )
+        ( line 2 , column 23 )
         (Ident (Identifier "thick"))
     , Text "b"
     , Text ","
     , Text "a"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 3 , column 34 )
+        ( line 2 , column 34 )
         (Ident (Identifier "quad"))
     , Text "b"
     ]
@@ -78,7 +39,7 @@
     , Text "="
     , Code
         "typ/math/spacing-02.typ"
-        ( line 4 , column 6 )
+        ( line 3 , column 6 )
         (Ident (Identifier "thin"))
     , Text "b"
     ]
@@ -89,24 +50,24 @@
     [ Text "a"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 5 , column 4 )
+        ( line 4 , column 4 )
         (Ident (Identifier "minus"))
     , Text "b"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 5 , column 8 )
+        ( line 4 , column 8 )
         (Ident (Identifier "equiv"))
     , Text "c"
     , Code
         "typ/math/spacing-02.typ"
-        ( line 5 , column 16 )
+        ( line 4 , column 16 )
         (Ident (Identifier "quad"))
     , MGroup
         (Just "(")
         (Just ")")
         [ Code
             "typ/math/spacing-02.typ"
-            ( line 5 , column 22 )
+            ( line 4 , column 22 )
             (Ident (Identifier "mod"))
         , Text "2"
         ]
diff --git a/test/typ/math/spacing-03.out b/test/typ/math/spacing-03.out
--- a/test/typ/math/spacing-03.out
+++ b/test/typ/math/spacing-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/spacing-03.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
-                                 "typ/math/spacing-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/spacing-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/spacing-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
@@ -55,18 +16,18 @@
         [ Text "x"
         , Code
             "typ/math/spacing-03.typ"
-            ( line 4 , column 7 )
+            ( line 3 , column 7 )
             (Ident (Identifier "in"))
         , Code
             "typ/math/spacing-03.typ"
-            ( line 4 , column 10 )
+            ( line 3 , column 10 )
             (Ident (Identifier "RR"))
         , MGroup Nothing Nothing [ Nbsp , Text "|" , Nbsp ]
         , Text "x"
         , Text " is natural "
         , Code
             "typ/math/spacing-03.typ"
-            ( line 4 , column 30 )
+            ( line 3 , column 30 )
             (Ident (Identifier "and"))
         , Text "x"
         , Text "<"
diff --git a/test/typ/math/spacing-04.out b/test/typ/math/spacing-04.out
--- a/test/typ/math/spacing-04.out
+++ b/test/typ/math/spacing-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/spacing-04.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
-                                 "typ/math/spacing-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/spacing-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/spacing-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
@@ -52,19 +13,19 @@
     [ Text "a"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 4 , column 4 )
+        ( line 3 , column 4 )
         (Ident (Identifier "equiv"))
     , Text "b"
     , Text "+"
     , Text "c"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 4 , column 16 )
+        ( line 3 , column 16 )
         (Ident (Identifier "minus"))
     , Text "d"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 4 , column 20 )
+        ( line 3 , column 20 )
         (FieldAccess
            (Ident (Identifier "r"))
            (FieldAccess
@@ -72,12 +33,12 @@
     , Text "e"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 4 , column 25 )
+        ( line 3 , column 25 )
         (Ident (Identifier "log"))
     , Text "5"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 4 , column 31 )
+        ( line 3 , column 31 )
         (FuncCall (Ident (Identifier "op")) [ BlockArg [ Text "ln" ] ])
     , Text "6"
     ]
@@ -88,45 +49,45 @@
     [ Text "a"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 5 , column 4 )
+        ( line 4 , column 4 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 5 , column 11 )
+                   ( line 4 , column 11 )
                    (Ident (Identifier "equiv"))
                ]
            ])
     , Text "b"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 5 , column 20 )
+        ( line 4 , column 20 )
         (FuncCall
            (Ident (Identifier "overline")) [ BlockArg [ Text "+" ] ])
     , Text "c"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 5 , column 34 )
+        ( line 4 , column 34 )
         (FuncCall
            (Ident (Identifier "arrow"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 5 , column 40 )
+                   ( line 4 , column 40 )
                    (Ident (Identifier "minus"))
                ]
            ])
     , Text "d"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 5 , column 45 )
+        ( line 4 , column 45 )
         (FuncCall
            (Ident (Identifier "hat"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 5 , column 49 )
+                   ( line 4 , column 49 )
                    (FieldAccess
                       (Ident (Identifier "r"))
                       (FieldAccess
@@ -136,26 +97,26 @@
     , Text "e"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 5 , column 55 )
+        ( line 4 , column 55 )
         (FuncCall
            (Ident (Identifier "cancel"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 5 , column 62 )
+                   ( line 4 , column 62 )
                    (Ident (Identifier "log"))
                ]
            ])
     , Text "5"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 5 , column 69 )
+        ( line 4 , column 69 )
         (FuncCall
            (Ident (Identifier "dot"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 5 , column 73 )
+                   ( line 4 , column 73 )
                    (FuncCall (Ident (Identifier "op")) [ BlockArg [ Text "ln" ] ])
                ]
            ])
@@ -168,45 +129,45 @@
     [ Text "a"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 6 , column 4 )
+        ( line 5 , column 4 )
         (FuncCall
            (Ident (Identifier "overbrace"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 6 , column 14 )
+                   ( line 5 , column 14 )
                    (Ident (Identifier "equiv"))
                ]
            ])
     , Text "b"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 6 , column 23 )
+        ( line 5 , column 23 )
         (FuncCall
            (Ident (Identifier "underline")) [ BlockArg [ Text "+" ] ])
     , Text "c"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 6 , column 38 )
+        ( line 5 , column 38 )
         (FuncCall
            (Ident (Identifier "grave"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 6 , column 44 )
+                   ( line 5 , column 44 )
                    (Ident (Identifier "minus"))
                ]
            ])
     , Text "d"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 6 , column 49 )
+        ( line 5 , column 49 )
         (FuncCall
            (Ident (Identifier "underbracket"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 6 , column 62 )
+                   ( line 5 , column 62 )
                    (FieldAccess
                       (Ident (Identifier "r"))
                       (FieldAccess
@@ -216,26 +177,26 @@
     , Text "e"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 6 , column 68 )
+        ( line 5 , column 68 )
         (FuncCall
            (Ident (Identifier "circle"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 6 , column 75 )
+                   ( line 5 , column 75 )
                    (Ident (Identifier "log"))
                ]
            ])
     , Text "5"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 6 , column 82 )
+        ( line 5 , column 82 )
         (FuncCall
            (Ident (Identifier "caron"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 6 , column 88 )
+                   ( line 5 , column 88 )
                    (FuncCall (Ident (Identifier "op")) [ BlockArg [ Text "ln" ] ])
                ]
            ])
@@ -249,13 +210,13 @@
     [ Text "a"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 8 , column 4 )
+        ( line 7 , column 4 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 8 , column 11 )
+                   ( line 7 , column 11 )
                    (Ident (Identifier "equiv"))
                ]
            , KeyValArg (Identifier "tl") (Block (Content [ Text "a" ]))
@@ -264,13 +225,13 @@
     , Text "b"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 8 , column 34 )
+        ( line 7 , column 34 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 8 , column 41 )
+                   ( line 7 , column 41 )
                    (FuncCall (Ident (Identifier "limits")) [ BlockArg [ Text "+" ] ])
                ]
            , KeyValArg (Identifier "t") (Block (Content [ Text "a" ]))
@@ -279,26 +240,26 @@
     , Text "c"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 8 , column 66 )
+        ( line 7 , column 66 )
         (FuncCall
            (Ident (Identifier "tilde"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 8 , column 72 )
+                   ( line 7 , column 72 )
                    (Ident (Identifier "minus"))
                ]
            ])
     , Text "d"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 8 , column 77 )
+        ( line 7 , column 77 )
         (FuncCall
            (Ident (Identifier "breve"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 8 , column 83 )
+                   ( line 7 , column 83 )
                    (FieldAccess
                       (Ident (Identifier "r"))
                       (FieldAccess
@@ -308,19 +269,19 @@
     , Text "e"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 8 , column 89 )
+        ( line 7 , column 89 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 8 , column 96 )
+                   ( line 7 , column 96 )
                    (FuncCall
                       (Ident (Identifier "limits"))
                       [ BlockArg
                           [ Code
                               "typ/math/spacing-04.typ"
-                              ( line 8 , column 103 )
+                              ( line 7 , column 103 )
                               (Ident (Identifier "log"))
                           ]
                       ])
@@ -331,13 +292,13 @@
     , Text "5"
     , Code
         "typ/math/spacing-04.typ"
-        ( line 8 , column 123 )
+        ( line 7 , column 123 )
         (FuncCall
            (Ident (Identifier "attach"))
            [ BlockArg
                [ Code
                    "typ/math/spacing-04.typ"
-                   ( line 8 , column 130 )
+                   ( line 7 , column 130 )
                    (FuncCall (Ident (Identifier "op")) [ BlockArg [ Text "ln" ] ])
                ]
            , KeyValArg (Identifier "tr") (Block (Content [ Text "a" ]))
diff --git a/test/typ/math/style-00.out b/test/typ/math/style-00.out
--- a/test/typ/math/style-00.out
+++ b/test/typ/math/style-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-00.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
-                                 "typ/math/style-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "a"
@@ -48,19 +9,19 @@
     , Text ","
     , Code
         "typ/math/style-00.typ"
-        ( line 3 , column 8 )
+        ( line 2 , column 8 )
         (Ident (Identifier "delta"))
     , Text ","
     , Text "\1013"
     , Text ","
     , Code
         "typ/math/style-00.typ"
-        ( line 3 , column 18 )
+        ( line 2 , column 18 )
         (Ident (Identifier "diff"))
     , Text ","
     , Code
         "typ/math/style-00.typ"
-        ( line 3 , column 24 )
+        ( line 2 , column 24 )
         (Ident (Identifier "Delta"))
     , Text ","
     , Text "\1012"
diff --git a/test/typ/math/style-01.out b/test/typ/math/style-01.out
--- a/test/typ/math/style-01.out
+++ b/test/typ/math/style-01.out
@@ -1,73 +1,34 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-01.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
-                                 "typ/math/style-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "A"
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 3 , column 5 )
+        ( line 2 , column 5 )
         (FuncCall (Ident (Identifier "italic")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 3 , column 16 )
+        ( line 2 , column 16 )
         (FuncCall (Ident (Identifier "upright")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 3 , column 28 )
+        ( line 2 , column 28 )
         (FuncCall (Ident (Identifier "bold")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 3 , column 37 )
+        ( line 2 , column 37 )
         (FuncCall
            (Ident (Identifier "bold"))
            [ BlockArg
                [ Code
                    "typ/math/style-01.typ"
-                   ( line 3 , column 42 )
+                   ( line 2 , column 42 )
                    (FuncCall (Ident (Identifier "upright")) [ BlockArg [ Text "A" ] ])
                ]
            ])
@@ -75,57 +36,57 @@
     , HardBreak
     , Code
         "typ/math/style-01.typ"
-        ( line 4 , column 2 )
+        ( line 3 , column 2 )
         (FuncCall (Ident (Identifier "serif")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 4 , column 12 )
+        ( line 3 , column 12 )
         (FuncCall (Ident (Identifier "sans")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 4 , column 21 )
+        ( line 3 , column 21 )
         (FuncCall (Ident (Identifier "cal")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 4 , column 29 )
+        ( line 3 , column 29 )
         (FuncCall (Ident (Identifier "frak")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 4 , column 38 )
+        ( line 3 , column 38 )
         (FuncCall (Ident (Identifier "mono")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 4 , column 47 )
+        ( line 3 , column 47 )
         (FuncCall (Ident (Identifier "bb")) [ BlockArg [ Text "A" ] ])
     , Text ","
     , HardBreak
     , Code
         "typ/math/style-01.typ"
-        ( line 5 , column 2 )
+        ( line 4 , column 2 )
         (FuncCall
            (Ident (Identifier "italic"))
            [ BlockArg
                [ Code
                    "typ/math/style-01.typ"
-                   ( line 5 , column 9 )
+                   ( line 4 , column 9 )
                    (Ident (Identifier "diff"))
                ]
            ])
     , Text ","
     , Code
         "typ/math/style-01.typ"
-        ( line 5 , column 16 )
+        ( line 4 , column 16 )
         (FuncCall
            (Ident (Identifier "upright"))
            [ BlockArg
                [ Code
                    "typ/math/style-01.typ"
-                   ( line 5 , column 24 )
+                   ( line 4 , column 24 )
                    (Ident (Identifier "diff"))
                ]
            ])
@@ -133,18 +94,18 @@
     , HardBreak
     , Code
         "typ/math/style-01.typ"
-        ( line 6 , column 2 )
+        ( line 5 , column 2 )
         (FuncCall (Ident (Identifier "bb")) [ BlockArg [ Text "hello" ] ])
     , Text "+"
     , Code
         "typ/math/style-01.typ"
-        ( line 6 , column 16 )
+        ( line 5 , column 16 )
         (FuncCall
            (Ident (Identifier "bold"))
            [ BlockArg
                [ Code
                    "typ/math/style-01.typ"
-                   ( line 6 , column 21 )
+                   ( line 5 , column 21 )
                    (FuncCall (Ident (Identifier "cal")) [ BlockArg [ Text "world" ] ])
                ]
            ])
@@ -152,17 +113,17 @@
     , HardBreak
     , Code
         "typ/math/style-01.typ"
-        ( line 7 , column 2 )
+        ( line 6 , column 2 )
         (FuncCall
            (FuncCall (Ident (Identifier "mono")) [ BlockArg [ Text "SQRT" ] ])
            [ BlockArg [ Text "x" ] ])
     , Code
         "typ/math/style-01.typ"
-        ( line 7 , column 18 )
+        ( line 6 , column 18 )
         (Ident (Identifier "wreath"))
     , Code
         "typ/math/style-01.typ"
-        ( line 7 , column 25 )
+        ( line 6 , column 25 )
         (FuncCall
            (Ident (Identifier "mono"))
            [ BlockArg [ Text "123" , Text "+" , Text "456" ] ])
diff --git a/test/typ/math/style-02.out b/test/typ/math/style-02.out
--- a/test/typ/math/style-02.out
+++ b/test/typ/math/style-02.out
@@ -1,105 +1,66 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-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
-                                 "typ/math/style-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Text "h"
     , Text ","
     , Code
         "typ/math/style-02.typ"
-        ( line 3 , column 5 )
+        ( line 2 , column 5 )
         (FuncCall (Ident (Identifier "bb")) [ BlockArg [ Text "N" ] ])
     , Text ","
     , Code
         "typ/math/style-02.typ"
-        ( line 3 , column 12 )
+        ( line 2 , column 12 )
         (FuncCall (Ident (Identifier "cal")) [ BlockArg [ Text "R" ] ])
     , Text ","
     , Code
         "typ/math/style-02.typ"
-        ( line 3 , column 20 )
+        ( line 2 , column 20 )
         (Ident (Identifier "Theta"))
     , Text ","
     , Code
         "typ/math/style-02.typ"
-        ( line 3 , column 27 )
+        ( line 2 , column 27 )
         (FuncCall
            (Ident (Identifier "italic"))
            [ BlockArg
                [ Code
                    "typ/math/style-02.typ"
-                   ( line 3 , column 34 )
+                   ( line 2 , column 34 )
                    (Ident (Identifier "Theta"))
                ]
            ])
     , Text ","
     , Code
         "typ/math/style-02.typ"
-        ( line 3 , column 42 )
+        ( line 2 , column 42 )
         (FuncCall
            (Ident (Identifier "sans"))
            [ BlockArg
                [ Code
                    "typ/math/style-02.typ"
-                   ( line 3 , column 47 )
+                   ( line 2 , column 47 )
                    (Ident (Identifier "Theta"))
                ]
            ])
     , Text ","
     , Code
         "typ/math/style-02.typ"
-        ( line 3 , column 55 )
+        ( line 2 , column 55 )
         (FuncCall
            (Ident (Identifier "sans"))
            [ BlockArg
                [ Code
                    "typ/math/style-02.typ"
-                   ( line 3 , column 60 )
+                   ( line 2 , column 60 )
                    (FuncCall
                       (Ident (Identifier "italic"))
                       [ BlockArg
                           [ Code
                               "typ/math/style-02.typ"
-                              ( line 3 , column 67 )
+                              ( line 2 , column 67 )
                               (Ident (Identifier "Theta"))
                           ]
                       ])
diff --git a/test/typ/math/style-03.out b/test/typ/math/style-03.out
--- a/test/typ/math/style-03.out
+++ b/test/typ/math/style-03.out
@@ -1,51 +1,12 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-03.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
-                                 "typ/math/style-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "\12424"
     , Code
         "typ/math/style-03.typ"
-        ( line 3 , column 5 )
+        ( line 2 , column 5 )
         (Ident (Identifier "and"))
     , Text "\127987"
     , Text "\65039"
diff --git a/test/typ/math/style-04.out b/test/typ/math/style-04.out
--- a/test/typ/math/style-04.out
+++ b/test/typ/math/style-04.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-04.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
-                                 "typ/math/style-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     False
     [ Code
         "typ/math/style-04.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FuncCall
            (Ident (Identifier "text"))
            [ NormalArg (Ident (Identifier "red"))
@@ -53,7 +14,7 @@
     , Text "+"
     , Code
         "typ/math/style-04.typ"
-        ( line 3 , column 25 )
+        ( line 2 , column 25 )
         (FuncCall
            (Ident (Identifier "sqrt")) [ BlockArg [ Text "place" ] ])
     ]
diff --git a/test/typ/math/style-05.out b/test/typ/math/style-05.out
--- a/test/typ/math/style-05.out
+++ b/test/typ/math/style-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-05.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
-                                 "typ/math/style-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/style-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FieldAccess
@@ -56,12 +17,12 @@
     [ Text "v"
     , Code
         "typ/math/style-05.typ"
-        ( line 4 , column 5 )
+        ( line 3 , column 5 )
         (FieldAccess
            (Ident (Identifier "eq")) (Ident (Identifier "colon")))
     , Code
         "typ/math/style-05.typ"
-        ( line 4 , column 8 )
+        ( line 3 , column 8 )
         (FuncCall
            (Ident (Identifier "vec"))
            [ BlockArg [ Text "1" , Text "+" , Text "2" ]
@@ -69,20 +30,20 @@
                [ Text "2"
                , Code
                    "typ/math/style-05.typ"
-                   ( line 4 , column 21 )
+                   ( line 3 , column 21 )
                    (Ident (Identifier "minus"))
                , Text "4"
                ]
            , BlockArg
                [ Code
                    "typ/math/style-05.typ"
-                   ( line 4 , column 26 )
+                   ( line 3 , column 26 )
                    (FuncCall (Ident (Identifier "sqrt")) [ BlockArg [ Text "3" ] ])
                ]
            , BlockArg
                [ Code
                    "typ/math/style-05.typ"
-                   ( line 4 , column 35 )
+                   ( line 3 , column 35 )
                    (FuncCall (Ident (Identifier "arrow")) [ BlockArg [ Text "x" ] ])
                ]
            ])
diff --git a/test/typ/math/style-06.out b/test/typ/math/style-06.out
--- a/test/typ/math/style-06.out
+++ b/test/typ/math/style-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/style-06.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
-                                 "typ/math/style-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/style-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/style-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FieldAccess
@@ -55,16 +16,16 @@
                     False
                     [ Code
                         "typ/math/style-06.typ"
-                        ( line 3 , column 25 )
+                        ( line 2 , column 25 )
                         (FuncCall
                            (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Em)) ])
                     , Code
                         "typ/math/style-06.typ"
-                        ( line 3 , column 32 )
+                        ( line 2 , column 32 )
                         (Ident (Identifier "it"))
                     , Code
                         "typ/math/style-06.typ"
-                        ( line 3 , column 36 )
+                        ( line 2 , column 36 )
                         (FuncCall
                            (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 1.0 Em)) ])
                     ]
@@ -75,7 +36,7 @@
     [ Text "a"
     , Code
         "typ/math/style-06.typ"
-        ( line 4 , column 5 )
+        ( line 3 , column 5 )
         (Ident (Identifier "tack"))
     , Text "b"
     ]
diff --git a/test/typ/math/syntax-00.out b/test/typ/math/syntax-00.out
--- a/test/typ/math/syntax-00.out
+++ b/test/typ/math/syntax-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/math/syntax-00.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
-                                 "typ/math/syntax-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/syntax-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ MAttach
@@ -55,13 +16,13 @@
         (Just
            (Code
               "typ/math/syntax-00.typ"
-              ( line 3 , column 36 )
+              ( line 2 , column 36 )
               (Ident (Identifier "NN"))))
         (Text "\8721")
     , Text "a"
     , Code
         "typ/math/syntax-00.typ"
-        ( line 3 , column 41 )
+        ( line 2 , column 41 )
         (Ident (Identifier "compose"))
     , Text "b"
     ]
diff --git a/test/typ/math/syntax-01.out b/test/typ/math/syntax-01.out
--- a/test/typ/math/syntax-01.out
+++ b/test/typ/math/syntax-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/syntax-01.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
-                                 "typ/math/syntax-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/syntax-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/syntax-01.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "underline"))
            [ BlockArg
@@ -53,15 +14,15 @@
                , Text ":"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 3 , column 18 )
+                   ( line 2 , column 18 )
                    (Ident (Identifier "NN"))
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 3 , column 21 )
+                   ( line 2 , column 21 )
                    (FieldAccess (Ident (Identifier "r")) (Ident (Identifier "arrow")))
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 3 , column 24 )
+                   ( line 2 , column 24 )
                    (Ident (Identifier "RR"))
                ]
            ])
@@ -69,20 +30,20 @@
     , Text "n"
     , Code
         "typ/math/syntax-01.typ"
-        ( line 4 , column 5 )
+        ( line 3 , column 5 )
         (FieldAccess
            (Ident (Identifier "r"))
            (FieldAccess
               (Ident (Identifier "bar")) (Ident (Identifier "arrow"))))
     , Code
         "typ/math/syntax-01.typ"
-        ( line 4 , column 9 )
+        ( line 3 , column 9 )
         (FuncCall
            (Ident (Identifier "cases"))
            [ BlockArg
                [ Code
                    "typ/math/syntax-01.typ"
-                   ( line 5 , column 5 )
+                   ( line 4 , column 5 )
                    (FieldAccess
                       (Ident (Identifier "l"))
                       (FieldAccess
@@ -90,7 +51,7 @@
                , Text "1"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 5 , column 8 )
+                   ( line 4 , column 8 )
                    (FieldAccess
                       (Ident (Identifier "r"))
                       (FieldAccess
@@ -100,7 +61,7 @@
                , Text "n"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 5 , column 19 )
+                   ( line 4 , column 19 )
                    (FieldAccess
                       (Ident (Identifier "triple")) (Ident (Identifier "gt")))
                , Text "10"
@@ -109,7 +70,7 @@
                [ Text "2"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 6 , column 7 )
+                   ( line 5 , column 7 )
                    (FieldAccess (Ident (Identifier "op")) (Ident (Identifier "ast")))
                , Text "3"
                , MAlignPoint
@@ -117,7 +78,7 @@
                , Text "n"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 6 , column 19 )
+                   ( line 5 , column 19 )
                    (FieldAccess (Ident (Identifier "not")) (Ident (Identifier "eq")))
                , Text "5"
                ]
@@ -125,17 +86,17 @@
                [ Text "1"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 7 , column 7 )
+                   ( line 6 , column 7 )
                    (Ident (Identifier "minus"))
                , Text "0"
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 7 , column 11 )
+                   ( line 6 , column 11 )
                    (Ident (Identifier "thick"))
                , MAlignPoint
                , Code
                    "typ/math/syntax-01.typ"
-                   ( line 7 , column 18 )
+                   ( line 6 , column 18 )
                    (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                ]
            ])
diff --git a/test/typ/math/syntax-02.out b/test/typ/math/syntax-02.out
--- a/test/typ/math/syntax-02.out
+++ b/test/typ/math/syntax-02.out
@@ -1,70 +1,31 @@
 --- parse tree ---
-[ Code
-    "typ/math/syntax-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
-                                 "typ/math/syntax-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/syntax-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/syntax-02.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (Ident (Identifier "dot"))
     , HardBreak
     , Code
         "typ/math/syntax-02.typ"
-        ( line 3 , column 9 )
+        ( line 2 , column 9 )
         (Ident (Identifier "dots"))
     , HardBreak
     , Code
         "typ/math/syntax-02.typ"
-        ( line 3 , column 16 )
+        ( line 2 , column 16 )
         (Ident (Identifier "ast"))
     , HardBreak
     , Code
         "typ/math/syntax-02.typ"
-        ( line 3 , column 22 )
+        ( line 2 , column 22 )
         (Ident (Identifier "tilde"))
     , HardBreak
     , Code
         "typ/math/syntax-02.typ"
-        ( line 3 , column 30 )
+        ( line 2 , column 30 )
         (Ident (Identifier "star"))
     ]
 , ParBreak
diff --git a/test/typ/math/unbalanced-00.out b/test/typ/math/unbalanced-00.out
--- a/test/typ/math/unbalanced-00.out
+++ b/test/typ/math/unbalanced-00.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/math/unbalanced-00.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
-                                 "typ/math/unbalanced-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/unbalanced-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ MFrac
         (Text "1")
@@ -84,9 +44,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: math.frac(denom: { text(body: [(]), 
                                                         text(body: [2]), 
                                                         math.lr(body: ({ [(], 
diff --git a/test/typ/math/underover-00.out b/test/typ/math/underover-00.out
--- a/test/typ/math/underover-00.out
+++ b/test/typ/math/underover-00.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/underover-00.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
-                                 "typ/math/underover-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/underover-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
     , Text "="
     , Code
         "typ/math/underover-00.typ"
-        ( line 3 , column 7 )
+        ( line 2 , column 7 )
         (FuncCall
            (Ident (Identifier "underbrace"))
            [ BlockArg
@@ -56,7 +17,7 @@
                , Text "+"
                , Code
                    "typ/math/underover-00.typ"
-                   ( line 4 , column 11 )
+                   ( line 3 , column 11 )
                    (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                , Text "+"
                , Text "5"
@@ -64,7 +25,7 @@
            , BlockArg
                [ Code
                    "typ/math/underover-00.typ"
-                   ( line 5 , column 3 )
+                   ( line 4 , column 3 )
                    (FuncCall
                       (Ident (Identifier "underbrace"))
                       [ BlockArg [ Text "numbers" ]
diff --git a/test/typ/math/underover-01.out b/test/typ/math/underover-01.out
--- a/test/typ/math/underover-01.out
+++ b/test/typ/math/underover-01.out
@@ -1,64 +1,25 @@
 --- parse tree ---
-[ Code
-    "typ/math/underover-01.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
-                                 "typ/math/underover-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/underover-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "x"
     , Text "="
     , Code
         "typ/math/underover-01.typ"
-        ( line 3 , column 7 )
+        ( line 2 , column 7 )
         (FuncCall
            (Ident (Identifier "overbracket"))
            [ BlockArg
                [ Code
                    "typ/math/underover-01.typ"
-                   ( line 4 , column 3 )
+                   ( line 3 , column 3 )
                    (FuncCall
                       (Ident (Identifier "overline"))
                       [ BlockArg
                           [ Code
                               "typ/math/underover-01.typ"
-                              ( line 4 , column 12 )
+                              ( line 3 , column 12 )
                               (FuncCall
                                  (Ident (Identifier "underline"))
                                  [ BlockArg [ Text "x" , Text "+" , Text "y" ] ])
@@ -72,7 +33,7 @@
                , Text "+"
                , Code
                    "typ/math/underover-01.typ"
-                   ( line 5 , column 11 )
+                   ( line 4 , column 11 )
                    (FieldAccess (Ident (Identifier "h")) (Ident (Identifier "dots")))
                , Text "+"
                , Text "5"
diff --git a/test/typ/math/underover-02.out b/test/typ/math/underover-02.out
--- a/test/typ/math/underover-02.out
+++ b/test/typ/math/underover-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/math/underover-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
-                                 "typ/math/underover-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/underover-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Code
         "typ/math/underover-02.typ"
-        ( line 3 , column 3 )
+        ( line 2 , column 3 )
         (FuncCall
            (Ident (Identifier "underbracket"))
            [ BlockArg
@@ -57,7 +18,7 @@
            ])
     , Code
         "typ/math/underover-02.typ"
-        ( line 4 , column 11 )
+        ( line 3 , column 11 )
         (FieldAccess
            (Ident (Identifier "long"))
            (FieldAccess
@@ -68,7 +29,7 @@
                     (Ident (Identifier "l")) (Ident (Identifier "arrow"))))))
     , Code
         "typ/math/underover-02.typ"
-        ( line 5 , column 3 )
+        ( line 4 , column 3 )
         (FuncCall
            (Ident (Identifier "overbracket"))
            [ BlockArg
diff --git a/test/typ/math/vec-00.out b/test/typ/math/vec-00.out
--- a/test/typ/math/vec-00.out
+++ b/test/typ/math/vec-00.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/math/vec-00.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
-                                 "typ/math/vec-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/vec-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Equation
     True
     [ Text "v"
     , Text "="
     , Code
         "typ/math/vec-00.typ"
-        ( line 3 , column 7 )
+        ( line 2 , column 7 )
         (FuncCall
            (Ident (Identifier "vec"))
            [ BlockArg [ Text "1" ]
diff --git a/test/typ/math/vec-01.out b/test/typ/math/vec-01.out
--- a/test/typ/math/vec-01.out
+++ b/test/typ/math/vec-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/math/vec-01.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
-                                 "typ/math/vec-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/math/vec-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/math/vec-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (FieldAccess
           (Ident (Identifier "vec")) (Ident (Identifier "math")))
@@ -52,7 +13,7 @@
     True
     [ Code
         "typ/math/vec-01.typ"
-        ( line 4 , column 3 )
+        ( line 3 , column 3 )
         (FuncCall
            (Ident (Identifier "vec"))
            [ BlockArg [ Text "1" ] , BlockArg [ Text "2" ] ])
diff --git a/test/typ/meta/bibliography-01.out b/test/typ/meta/bibliography-01.out
--- a/test/typ/meta/bibliography-01.out
+++ b/test/typ/meta/bibliography-01.out
@@ -2,58 +2,19 @@
 [ Code
     "typ/meta/bibliography-01.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
-                                 "typ/meta/bibliography-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/bibliography-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/bibliography-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 200.0 Pt)) ])
 , SoftBreak
 , Heading 1 [ Text "Details" ]
+, SoftBreak
 , Text "See"
 , Space
 , Text "also"
 , Space
 , Code
     "typ/meta/bibliography-01.typ"
-    ( line 4 , column 11 )
+    ( line 3 , column 11 )
     (FuncCall
        (Ident (Identifier "cite"))
        [ NormalArg (Label "distress")
@@ -77,7 +38,7 @@
 , SoftBreak
 , Code
     "typ/meta/bibliography-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "bibliography"))
        [ NormalArg (Literal (String "/works.bib")) ])
@@ -85,8 +46,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  heading(body: text(body: [Details]), 
                          level: 1), 
diff --git a/test/typ/meta/bibliography-02.out b/test/typ/meta/bibliography-02.out
--- a/test/typ/meta/bibliography-02.out
+++ b/test/typ/meta/bibliography-02.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/meta/bibliography-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
-                                 "typ/meta/bibliography-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/bibliography-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/bibliography-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 200.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/meta/bibliography-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "bibliography"))
        [ NormalArg (Literal (String "/works.bib"))
@@ -71,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/meta/bibliography-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 100.0 Percent))
@@ -79,12 +40,12 @@
 , SoftBreak
 , Code
     "typ/meta/bibliography-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Block
        (Content
           [ Code
               "typ/meta/bibliography-02.typ"
-              ( line 6 , column 4 )
+              ( line 5 , column 4 )
               (Set
                  (Ident (Identifier "cite"))
                  [ KeyValArg (Identifier "brackets") (Literal (Boolean False)) ])
diff --git a/test/typ/meta/bibliography-04.out b/test/typ/meta/bibliography-04.out
--- a/test/typ/meta/bibliography-04.out
+++ b/test/typ/meta/bibliography-04.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/meta/bibliography-04.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
-                                 "typ/meta/bibliography-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/bibliography-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/bibliography-04.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 200.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/meta/bibliography-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "1.")) ])
 , SoftBreak
 , Code
     "typ/meta/bibliography-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "bibliography")))
        (Set
@@ -63,6 +23,7 @@
           [ KeyValArg (Identifier "numbering") (Literal (String "1.")) ]))
 , ParBreak
 , Heading 1 [ Text "Multiple" , Space , Text "Bibs" ]
+, SoftBreak
 , Text "Now"
 , Space
 , Text "we"
@@ -77,18 +38,18 @@
 , Space
 , Code
     "typ/meta/bibliography-04.typ"
-    ( line 7 , column 49 )
+    ( line 6 , column 49 )
     (FuncCall
        (Ident (Identifier "cite")) [ NormalArg (Label "glacier-melt") ])
 , Code
     "typ/meta/bibliography-04.typ"
-    ( line 7 , column 70 )
+    ( line 6 , column 70 )
     (FuncCall
        (Ident (Identifier "cite")) [ NormalArg (Label "keshav2007read") ])
 , SoftBreak
 , Code
     "typ/meta/bibliography-04.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "bibliography"))
        [ NormalArg
@@ -101,8 +62,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/meta/bibliography-ordering-00.out b/test/typ/meta/bibliography-ordering-00.out
--- a/test/typ/meta/bibliography-ordering-00.out
+++ b/test/typ/meta/bibliography-ordering-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/bibliography-ordering-00.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
-                                 "typ/meta/bibliography-ordering-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/bibliography-ordering-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/bibliography-ordering-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 300.0 Pt)) ])
@@ -82,16 +42,14 @@
 , ParBreak
 , Code
     "typ/meta/bibliography-ordering-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "bibliography"))
        [ NormalArg (Literal (String "/works.bib")) ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  ref(supplement: auto, 
                      target: <mcintosh_anxiety>), 
                  text(body: [, ]), 
diff --git a/test/typ/meta/cite-footnote-00.out b/test/typ/meta/cite-footnote-00.out
--- a/test/typ/meta/cite-footnote-00.out
+++ b/test/typ/meta/cite-footnote-00.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/meta/cite-footnote-00.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
-                                 "typ/meta/cite-footnote-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/cite-footnote-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "Hello"
+[ Text "Hello"
 , Space
 , Ref "netwok" (Literal Auto)
 , SoftBreak
@@ -52,12 +12,12 @@
 , ParBreak
 , Code
     "typ/meta/cite-footnote-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Code
     "typ/meta/cite-footnote-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "bibliography"))
        [ NormalArg (Literal (String "/works.bib"))
@@ -66,8 +26,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-Hello ]), 
+document(body: { text(body: [Hello ]), 
                  ref(supplement: auto, 
                      target: <netwok>), 
                  text(body: [
diff --git a/test/typ/meta/counter-00.out b/test/typ/meta/counter-00.out
--- a/test/typ/meta/counter-00.out
+++ b/test/typ/meta/counter-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/counter-00.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
-                                 "typ/meta/counter-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/counter-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/counter-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "mine")))
        (FuncCall
@@ -54,7 +15,7 @@
 , Space
 , Code
     "typ/meta/counter-00.typ"
-    ( line 5 , column 9 )
+    ( line 4 , column 9 )
     (FuncCall
        (Ident (Identifier "locate"))
        [ NormalArg
@@ -73,7 +34,7 @@
 , HardBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "step")) (Ident (Identifier "mine")))
@@ -84,7 +45,7 @@
 , Space
 , Code
     "typ/meta/counter-00.typ"
-    ( line 7 , column 9 )
+    ( line 6 , column 9 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "display")) (Ident (Identifier "mine")))
@@ -93,7 +54,7 @@
 , HardBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update")) (Ident (Identifier "mine")))
@@ -101,7 +62,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "display")) (Ident (Identifier "mine")))
@@ -112,7 +73,7 @@
 , HardBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "step")) (Ident (Identifier "mine")))
@@ -120,7 +81,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "step")) (Ident (Identifier "mine")))
@@ -131,7 +92,7 @@
 , Space
 , Code
     "typ/meta/counter-00.typ"
-    ( line 12 , column 10 )
+    ( line 11 , column 10 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "display")) (Ident (Identifier "mine")))
@@ -139,7 +100,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update")) (Ident (Identifier "mine")))
@@ -151,7 +112,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "step")) (Ident (Identifier "mine")))
diff --git a/test/typ/meta/counter-01.out b/test/typ/meta/counter-01.out
--- a/test/typ/meta/counter-01.out
+++ b/test/typ/meta/counter-01.out
@@ -1,53 +1,14 @@
 --- parse tree ---
-[ Code
-    "typ/meta/counter-01.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
-                                 "typ/meta/counter-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/counter-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/counter-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "label"))) (Label "heya"))
 , SoftBreak
 , Code
     "typ/meta/counter-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "count")))
        (FuncCall
@@ -60,7 +21,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (LetFunc
        (Identifier "elem")
        [ NormalParam (Identifier "it") ]
@@ -68,39 +29,39 @@
           (Content
              [ Code
                  "typ/meta/counter-01.typ"
-                 ( line 5 , column 19 )
+                 ( line 4 , column 19 )
                  (FuncCall
                     (Ident (Identifier "box")) [ NormalArg (Ident (Identifier "it")) ])
              , Space
              , Code
                  "typ/meta/counter-01.typ"
-                 ( line 5 , column 28 )
+                 ( line 4 , column 28 )
                  (Ident (Identifier "label"))
              ])))
 , ParBreak
 , Code
     "typ/meta/counter-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "elem"))
        [ BlockArg [ Text "hey," , Space , Text "there!" ] ])
 , Space
 , Code
     "typ/meta/counter-01.typ"
-    ( line 7 , column 21 )
+    ( line 6 , column 21 )
     (Ident (Identifier "count"))
 , Space
 , HardBreak
 , Code
     "typ/meta/counter-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "elem"))
        [ BlockArg [ Text "more" , Space , Text "here!" ] ])
 , Space
 , Code
     "typ/meta/counter-01.typ"
-    ( line 8 , column 20 )
+    ( line 7 , column 20 )
     (Ident (Identifier "count"))
 , ParBreak
 ]
diff --git a/test/typ/meta/counter-02.out b/test/typ/meta/counter-02.out
--- a/test/typ/meta/counter-02.out
+++ b/test/typ/meta/counter-02.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/meta/counter-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
-                                 "typ/meta/counter-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/counter-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/counter-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "1.a.")) ])
 , SoftBreak
 , Code
     "typ/meta/counter-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "heading")))
        (Set
@@ -58,7 +19,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "step"))
@@ -68,11 +29,12 @@
        [])
 , ParBreak
 , Heading 1 [ Text "Alpha" ]
+, SoftBreak
 , Text "In"
 , Space
 , Code
     "typ/meta/counter-02.typ"
-    ( line 8 , column 5 )
+    ( line 7 , column 5 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "display"))
@@ -82,17 +44,19 @@
        [])
 , SoftBreak
 , Heading 2 [ Text "Beta" ]
+, ParBreak
 , Code
     "typ/meta/counter-02.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal None) ])
 , SoftBreak
 , Heading 1 [ Text "Gamma" ]
+, SoftBreak
 , Code
     "typ/meta/counter-02.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "I."))
@@ -109,7 +73,7 @@
 , Space
 , Code
     "typ/meta/counter-02.typ"
-    ( line 15 , column 18 )
+    ( line 14 , column 18 )
     (FuncCall
        (Ident (Identifier "locate"))
        [ NormalArg
diff --git a/test/typ/meta/counter-03.out b/test/typ/meta/counter-03.out
--- a/test/typ/meta/counter-03.out
+++ b/test/typ/meta/counter-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/counter-03.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
-                                 "typ/meta/counter-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/counter-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/counter-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ KeyValArg (Identifier "numbering") (Literal (String "A"))
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ KeyValArg (Identifier "numbering") (Literal None)
@@ -86,7 +47,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ KeyValArg
@@ -107,7 +68,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update"))
@@ -127,7 +88,7 @@
 , SoftBreak
 , Code
     "typ/meta/counter-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ KeyValArg
diff --git a/test/typ/meta/counter-page-00.out b/test/typ/meta/counter-page-00.out
--- a/test/typ/meta/counter-page-00.out
+++ b/test/typ/meta/counter-page-00.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/counter-page-00.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
-                                 "typ/meta/counter-page-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/counter-page-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 50.0 Pt))
@@ -57,38 +17,38 @@
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 12)) ])
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "numbering") (Literal (String "(i)")) ])
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 6)) ])
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall (Ident (Identifier "pagebreak")) [])
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "numbering") (Literal (String "1 / 1")) ])
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update"))
@@ -99,16 +59,13 @@
 , SoftBreak
 , Code
     "typ/meta/counter-page-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 20)) ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor]), 
diff --git a/test/typ/meta/document-00.out b/test/typ/meta/document-00.out
--- a/test/typ/meta/document-00.out
+++ b/test/typ/meta/document-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/document-00.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
-                                 "typ/meta/document-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/document-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/document-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "document"))
        [ KeyValArg (Identifier "title") (Literal (String "Hello")) ])
diff --git a/test/typ/meta/document-01.out b/test/typ/meta/document-01.out
--- a/test/typ/meta/document-01.out
+++ b/test/typ/meta/document-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/meta/document-01.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
-                                 "typ/meta/document-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/document-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/meta/document-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "document"))
        [ KeyValArg
@@ -55,5 +17,7 @@
 --- evaluated ---
 document(author: ("A", "B"), 
          body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  parbreak() })
diff --git a/test/typ/meta/figure-00.out b/test/typ/meta/figure-00.out
--- a/test/typ/meta/figure-00.out
+++ b/test/typ/meta/figure-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/meta/figure-00.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
-                                 "typ/meta/figure-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/figure-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/figure-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 150.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/meta/figure-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "figure"))
        [ KeyValArg (Identifier "numbering") (Literal (String "I")) ])
@@ -82,7 +42,7 @@
 , ParBreak
 , Code
     "typ/meta/figure-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -106,11 +66,11 @@
        ])
 , Space
 , Code
-    "typ/meta/figure-00.typ" ( line 11 , column 3 ) (Label "tab-basic")
+    "typ/meta/figure-00.typ" ( line 10 , column 3 ) (Label "tab-basic")
 , ParBreak
 , Code
     "typ/meta/figure-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -140,12 +100,12 @@
 , Space
 , Code
     "typ/meta/figure-00.typ"
-    ( line 17 , column 3 )
+    ( line 16 , column 3 )
     (Label "fig-cylinder")
 , ParBreak
 , Code
     "typ/meta/figure-00.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -174,14 +134,12 @@
 , Space
 , Code
     "typ/meta/figure-00.typ"
-    ( line 22 , column 3 )
+    ( line 21 , column 3 )
     (Label "tab-complex")
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  text(body: [We can clearly see that ]), 
diff --git a/test/typ/meta/figure-01.out b/test/typ/meta/figure-01.out
--- a/test/typ/meta/figure-01.out
+++ b/test/typ/meta/figure-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/figure-01.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
-                                 "typ/meta/figure-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/figure-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, ParBreak
-, Comment
+[ Comment
+, SoftBreak
 , Code
     "typ/meta/figure-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -63,12 +24,13 @@
 , Space
 , Code
     "typ/meta/figure-01.typ"
-    ( line 11 , column 3 )
+    ( line 10 , column 3 )
     (Label "fig-image-in-table")
 , ParBreak
 ]
 --- evaluated ---
-document(body: { parbreak(), 
+document(body: { text(body: [
+]), 
                  figure(body: table(children: (text(body: [Second cylinder]), 
                                                image(source: "/assets/files/cylinder.svg")), 
                                     columns: 2), 
diff --git a/test/typ/meta/figure-02.out b/test/typ/meta/figure-02.out
--- a/test/typ/meta/figure-02.out
+++ b/test/typ/meta/figure-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/figure-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
-                                 "typ/meta/figure-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/figure-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, ParBreak
-, Comment
+[ Comment
+, SoftBreak
 , Code
     "typ/meta/figure-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -69,7 +30,7 @@
                                        [ Space
                                        , Code
                                            "typ/meta/figure-02.typ"
-                                           ( line 7 , column 15 )
+                                           ( line 6 , column 15 )
                                            (FuncCall
                                               (Ident (Identifier "emph"))
                                               [ NormalArg
@@ -161,33 +122,33 @@
                                   (Content
                                      [ Code
                                          "typ/meta/figure-02.typ"
-                                         ( line 29 , column 9 )
+                                         ( line 28 , column 9 )
                                          (Ident (Identifier "title"))
                                      , Code
                                          "typ/meta/figure-02.typ"
-                                         ( line 29 , column 15 )
+                                         ( line 28 , column 15 )
                                          (Ident (Identifier "name"))
                                      , Code
                                          "typ/meta/figure-02.typ"
-                                         ( line 29 , column 20 )
+                                         ( line 28 , column 20 )
                                          (FuncCall
                                             (Ident (Identifier "h"))
                                             [ NormalArg (Literal (Numeric 0.1 Em)) ])
                                      , Text ":"
                                      , Code
                                          "typ/meta/figure-02.typ"
-                                         ( line 29 , column 30 )
+                                         ( line 28 , column 30 )
                                          (FuncCall
                                             (Ident (Identifier "h"))
                                             [ NormalArg (Literal (Numeric 0.2 Em)) ])
                                      , Code
                                          "typ/meta/figure-02.typ"
-                                         ( line 29 , column 39 )
+                                         ( line 28 , column 39 )
                                          (FieldAccess
                                             (Ident (Identifier "body")) (Ident (Identifier "it")))
                                      , Code
                                          "typ/meta/figure-02.typ"
-                                         ( line 29 , column 47 )
+                                         ( line 28 , column 47 )
                                          (FuncCall
                                             (Ident (Identifier "v"))
                                             [ NormalArg (Literal (Numeric 0.5 Em)) ])
@@ -198,14 +159,14 @@
 , ParBreak
 , Code
     "typ/meta/figure-02.typ"
-    ( line 34 , column 2 )
+    ( line 33 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 150.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/meta/figure-02.typ"
-    ( line 35 , column 2 )
+    ( line 34 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -229,12 +190,12 @@
 , Space
 , Code
     "typ/meta/figure-02.typ"
-    ( line 41 , column 3 )
+    ( line 40 , column 3 )
     (Label "fig-formula")
 , ParBreak
 , Code
     "typ/meta/figure-02.typ"
-    ( line 43 , column 2 )
+    ( line 42 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -259,19 +220,18 @@
 , Space
 , Code
     "typ/meta/figure-02.typ"
-    ( line 49 , column 3 )
+    ( line 48 , column 3 )
     (Label "fig-formula")
 , ParBreak
 , Code
     "typ/meta/figure-02.typ"
-    ( line 51 , column 2 )
+    ( line 50 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
            (Block
               (Content
-                 [ RawBlock "rust" "fn main() {\n    println!(\"Hello!\");\n  }\n  "
-                 ]))
+                 [ RawBlock "rust" "fn main() {\n  println!(\"Hello!\");\n}" ]))
        , KeyValArg
            (Identifier "caption")
            (Block
@@ -287,5 +247,5 @@
        ])
 , ParBreak
 ]
-"typ/meta/figure-02.typ" (line 35, column 2):
+"typ/meta/figure-02.typ" (line 34, column 2):
 Content does not have a method "counter" or FieldAccess requires a dictionary
diff --git a/test/typ/meta/figure-03.out b/test/typ/meta/figure-03.out
--- a/test/typ/meta/figure-03.out
+++ b/test/typ/meta/figure-03.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/meta/figure-03.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
-                                 "typ/meta/figure-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/figure-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/figure-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 6.0 Em)) ])
 , SoftBreak
 , Code
     "typ/meta/figure-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just (Ident (Identifier "figure")))
        (Set
@@ -58,7 +19,7 @@
 , ParBreak
 , Code
     "typ/meta/figure-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
diff --git a/test/typ/meta/footnote-00.out b/test/typ/meta/footnote-00.out
--- a/test/typ/meta/footnote-00.out
+++ b/test/typ/meta/footnote-00.out
@@ -2,52 +2,10 @@
 [ Code
     "typ/meta/footnote-00.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
-                                 "typ/meta/footnote-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/footnote-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "footnote")) [ BlockArg [ Text "Hi" ] ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 footnote(body: text(body: [Hi])), 
+document(body: { footnote(body: text(body: [Hi])), 
                  parbreak() })
diff --git a/test/typ/meta/footnote-01.out b/test/typ/meta/footnote-01.out
--- a/test/typ/meta/footnote-01.out
+++ b/test/typ/meta/footnote-01.out
@@ -1,49 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/meta/footnote-01.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
-                                 "typ/meta/footnote-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Code
     "typ/meta/footnote-01.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (FuncCall
        (Ident (Identifier "footnote")) [ BlockArg [ Text "A" ] ])
 , Space
@@ -52,15 +13,14 @@
 , Space
 , Code
     "typ/meta/footnote-01.typ"
-    ( line 4 , column 4 )
+    ( line 3 , column 4 )
     (FuncCall
        (Ident (Identifier "footnote")) [ BlockArg [ Text "A" ] ])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
+A]), 
                  footnote(body: text(body: [A])), 
                  text(body: [ ]), 
                  linebreak(), 
diff --git a/test/typ/meta/footnote-02.out b/test/typ/meta/footnote-02.out
--- a/test/typ/meta/footnote-02.out
+++ b/test/typ/meta/footnote-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/meta/footnote-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
-                                 "typ/meta/footnote-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "First"
 , Space
 , HardBreak
@@ -47,7 +8,7 @@
 , Space
 , Code
     "typ/meta/footnote-02.typ"
-    ( line 4 , column 9 )
+    ( line 3 , column 9 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -55,7 +16,7 @@
            , Space
            , Code
                "typ/meta/footnote-02.typ"
-               ( line 4 , column 22 )
+               ( line 3 , column 22 )
                (FuncCall
                   (Ident (Identifier "footnote"))
                   [ BlockArg
@@ -63,7 +24,7 @@
                       , Space
                       , Code
                           "typ/meta/footnote-02.typ"
-                          ( line 4 , column 35 )
+                          ( line 3 , column 35 )
                           (FuncCall
                              (Ident (Identifier "footnote")) [ BlockArg [ Text "C" ] ])
                       ]
@@ -76,7 +37,7 @@
 , Space
 , Code
     "typ/meta/footnote-02.typ"
-    ( line 5 , column 8 )
+    ( line 4 , column 8 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -84,7 +45,7 @@
            , Space
            , Code
                "typ/meta/footnote-02.typ"
-               ( line 5 , column 21 )
+               ( line 4 , column 21 )
                (FuncCall
                   (Ident (Identifier "footnote")) [ BlockArg [ Text "E" ] ])
            ]
@@ -96,8 +57,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [First ]), 
+First ]), 
                  linebreak(), 
                  text(body: [Second ]), 
                  footnote(body: { text(body: [A, ]), 
diff --git a/test/typ/meta/footnote-03.out b/test/typ/meta/footnote-03.out
--- a/test/typ/meta/footnote-03.out
+++ b/test/typ/meta/footnote-03.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/meta/footnote-03.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
-                                 "typ/meta/footnote-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/meta/footnote-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -51,7 +13,7 @@
            , Space
            , Code
                "typ/meta/footnote-03.typ"
-               ( line 4 , column 15 )
+               ( line 3 , column 15 )
                (FuncCall
                   (Ident (Identifier "footnote")) [ BlockArg [ Text "B" ] ])
            ]
@@ -60,13 +22,15 @@
 , Space
 , Code
     "typ/meta/footnote-03.typ"
-    ( line 4 , column 30 )
+    ( line 3 , column 30 )
     (FuncCall
        (Ident (Identifier "footnote")) [ BlockArg [ Text "C" ] ])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  footnote(body: { text(body: [A, ]), 
                                   footnote(body: text(body: [B])) }), 
diff --git a/test/typ/meta/footnote-04.out b/test/typ/meta/footnote-04.out
--- a/test/typ/meta/footnote-04.out
+++ b/test/typ/meta/footnote-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/footnote-04.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
-                                 "typ/meta/footnote-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/footnote-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "footnote")))
        (Set
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/meta/footnote-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just
           (FieldAccess
@@ -64,7 +25,7 @@
 , SoftBreak
 , Code
     "typ/meta/footnote-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (FieldAccess
           (Ident (Identifier "entry")) (Ident (Identifier "footnote")))
@@ -83,7 +44,7 @@
 , Space
 , Code
     "typ/meta/footnote-04.typ"
-    ( line 12 , column 23 )
+    ( line 11 , column 23 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
diff --git a/test/typ/meta/footnote-break-00.out b/test/typ/meta/footnote-break-00.out
--- a/test/typ/meta/footnote-break-00.out
+++ b/test/typ/meta/footnote-break-00.out
@@ -2,65 +2,25 @@
 [ Code
     "typ/meta/footnote-break-00.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
-                                 "typ/meta/footnote-break-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-break-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/footnote-break-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 200.0 Pt)) ])
 , ParBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 5)) ])
 , SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
            [ Space
            , Comment
-           , Space
+           , SoftBreak
            , Text "A"
            , Space
            , Text "simple"
@@ -70,7 +30,7 @@
            , SoftBreak
            , Code
                "typ/meta/footnote-break-00.typ"
-               ( line 7 , column 4 )
+               ( line 6 , column 4 )
                (FuncCall
                   (Ident (Identifier "footnote"))
                   [ BlockArg
@@ -87,18 +47,19 @@
                   ])
            , Space
            , Comment
+           , ParBreak
            ]
        ])
 , SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 15)) ])
 , SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -109,22 +70,23 @@
            , Space
            , Code
                "typ/meta/footnote-break-00.typ"
-               ( line 10 , column 30 )
+               ( line 9 , column 30 )
                (FuncCall
                   (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 30)) ])
            ]
        ])
 , Space
 , Comment
+, SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 15)) ])
 , SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -137,22 +99,23 @@
            , Space
            , Code
                "typ/meta/footnote-break-00.typ"
-               ( line 12 , column 32 )
+               ( line 11 , column 32 )
                (FuncCall
                   (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 50)) ])
            ]
        ])
 , Space
 , Comment
+, SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 15)) ])
 , SoftBreak
 , Code
     "typ/meta/footnote-break-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -168,19 +131,20 @@
        ])
 , Space
 , Comment
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [Lorem ipsum dolor sit amet,]), 
                  text(body: [
 ]), 
                  footnote(body: { text(body: [ ]), 
-                                  text(body: [ A simple footnote.
+                                  text(body: [
+A simple footnote.
 ]), 
                                   footnote(body: text(body: [Well, not that simple …])), 
-                                  text(body: [ ]) }), 
+                                  text(body: [ ]), 
+                                  parbreak() }), 
                  text(body: [
 ]), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore]), 
@@ -189,14 +153,19 @@
                  footnote(body: { text(body: [Another footnote: ]), 
                                   text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi]) }), 
                  text(body: [ ]), 
+                 text(body: [
+]), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore]), 
                  text(body: [
 ]), 
                  footnote(body: { text(body: [My fourth footnote: ]), 
                                   text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat]) }), 
                  text(body: [ ]), 
+                 text(body: [
+]), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore]), 
                  text(body: [
 ]), 
                  footnote(body: text(body: [And a final footnote.])), 
-                 text(body: [ ]) })
+                 text(body: [ ]), 
+                 parbreak() })
diff --git a/test/typ/meta/footnote-container-00.out b/test/typ/meta/footnote-container-00.out
--- a/test/typ/meta/footnote-container-00.out
+++ b/test/typ/meta/footnote-container-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/meta/footnote-container-00.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
-                                 "typ/meta/footnote-container-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-container-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Read"
 , Space
 , Text "the"
@@ -48,7 +9,7 @@
 , Space
 , Code
     "typ/meta/footnote-container-00.typ"
-    ( line 3 , column 16 )
+    ( line 2 , column 16 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg [ Url "https://typst.app/docs" ] ])
@@ -56,7 +17,7 @@
 , SoftBreak
 , Code
     "typ/meta/footnote-container-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -76,7 +37,7 @@
                  , Space
                  , Code
                      "typ/meta/footnote-container-00.typ"
-                     ( line 7 , column 14 )
+                     ( line 6 , column 14 )
                      (FuncCall
                         (Ident (Identifier "footnote"))
                         [ BlockArg
@@ -108,7 +69,7 @@
 , Space
 , Code
     "typ/meta/footnote-container-00.typ"
-    ( line 10 , column 7 )
+    ( line 9 , column 7 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg [ Text "just" , Space , Text "for" , Space , Ellipsis ]
@@ -118,7 +79,7 @@
 , Space
 , Code
     "typ/meta/footnote-container-00.typ"
-    ( line 10 , column 41 )
+    ( line 9 , column 41 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ BlockArg
@@ -135,8 +96,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Read the docs ]), 
+Read the docs ]), 
                  footnote(body: link(body: [https://typst.app/docs], 
                                      dest: "https://typst.app/docs")), 
                  text(body: [!
diff --git a/test/typ/meta/footnote-container-01.out b/test/typ/meta/footnote-container-01.out
--- a/test/typ/meta/footnote-container-01.out
+++ b/test/typ/meta/footnote-container-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/footnote-container-01.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
-                                 "typ/meta/footnote-container-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-container-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/footnote-container-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "lang")))
        (FuncCall
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/meta/footnote-container-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "nums")))
        (FuncCall
@@ -66,7 +27,7 @@
     , Space
     , Code
         "typ/meta/footnote-container-01.typ"
-        ( line 6 , column 20 )
+        ( line 5 , column 20 )
         (Ident (Identifier "lang"))
     ]
 , SoftBreak
@@ -78,11 +39,10 @@
     , Space
     , Code
         "typ/meta/footnote-container-01.typ"
-        ( line 7 , column 20 )
+        ( line 6 , column 20 )
         (Ident (Identifier "nums"))
-    , SoftBreak
     ]
-, SoftBreak
+, ParBreak
 , BulletListItem
     [ Quote '"'
     , Text "Hello"
@@ -90,7 +50,7 @@
     , Space
     , Code
         "typ/meta/footnote-container-01.typ"
-        ( line 9 , column 12 )
+        ( line 8 , column 12 )
         (Ident (Identifier "lang"))
     ]
 , SoftBreak
@@ -101,11 +61,10 @@
     , Space
     , Code
         "typ/meta/footnote-container-01.typ"
-        ( line 10 , column 10 )
+        ( line 9 , column 10 )
         (Ident (Identifier "nums"))
-    , SoftBreak
     ]
-, SoftBreak
+, ParBreak
 , EnumListItem
     Nothing
     [ Quote '"'
@@ -114,7 +73,7 @@
     , Space
     , Code
         "typ/meta/footnote-container-01.typ"
-        ( line 12 , column 12 )
+        ( line 11 , column 12 )
         (Ident (Identifier "lang"))
     ]
 , SoftBreak
@@ -126,14 +85,13 @@
     , Space
     , Code
         "typ/meta/footnote-container-01.typ"
-        ( line 13 , column 10 )
+        ( line 12 , column 10 )
         (Ident (Identifier "nums"))
-    , SoftBreak
     ]
-, SoftBreak
+, ParBreak
 , Code
     "typ/meta/footnote-container-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -147,7 +105,7 @@
                  , Space
                  , Code
                      "typ/meta/footnote-container-01.typ"
-                     ( line 17 , column 21 )
+                     ( line 16 , column 21 )
                      (Ident (Identifier "lang"))
                  ]))
        , NormalArg (Block (Content [ Text "123" ]))
@@ -160,7 +118,7 @@
                  , Space
                  , Code
                      "typ/meta/footnote-container-01.typ"
-                     ( line 18 , column 21 )
+                     ( line 17 , column 21 )
                      (Ident (Identifier "nums"))
                  ]))
        ])
@@ -177,21 +135,15 @@
                                      footnote(body: text(body: [Languages.])) }), 
                                   (text(body: [“123”]), 
                                    { text(body: [A number ]), 
-                                     footnote(body: text(body: [Numbers.])), 
-                                     text(body: [
-]) }))), 
+                                     footnote(body: text(body: [Numbers.])) }))), 
                  list(children: ({ text(body: [“Hello” ]), 
                                    footnote(body: text(body: [Languages.])) }, 
                                  { text(body: [“123” ]), 
-                                   footnote(body: text(body: [Numbers.])), 
-                                   text(body: [
-]) })), 
+                                   footnote(body: text(body: [Numbers.])) })), 
                  enum(children: ({ text(body: [“Hello” ]), 
                                    footnote(body: text(body: [Languages.])) }, 
                                  { text(body: [“123” ]), 
-                                   footnote(body: text(body: [Numbers.])), 
-                                   text(body: [
-]) })), 
+                                   footnote(body: text(body: [Numbers.])) })), 
                  table(children: (text(body: [Hello]), 
                                   { text(body: [A word ]), 
                                     footnote(body: text(body: [Languages.])) }, 
diff --git a/test/typ/meta/footnote-invariant-00.out b/test/typ/meta/footnote-invariant-00.out
--- a/test/typ/meta/footnote-invariant-00.out
+++ b/test/typ/meta/footnote-invariant-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/meta/footnote-invariant-00.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
-                                 "typ/meta/footnote-invariant-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/footnote-invariant-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/footnote-invariant-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 120.0 Pt)) ])
 , ParBreak
 , Code
     "typ/meta/footnote-invariant-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 13)) ])
 , ParBreak
@@ -56,7 +16,7 @@
 , Space
 , Code
     "typ/meta/footnote-invariant-00.typ"
-    ( line 6 , column 8 )
+    ( line 5 , column 8 )
     (FuncCall
        (Ident (Identifier "footnote"))
        [ NormalArg
@@ -66,9 +26,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt]), 
                  parbreak(), 
                  text(body: [There ]), 
diff --git a/test/typ/meta/heading-00.out b/test/typ/meta/heading-00.out
--- a/test/typ/meta/heading-00.out
+++ b/test/typ/meta/heading-00.out
@@ -1,62 +1,26 @@
 --- parse tree ---
-[ Code
-    "typ/meta/heading-00.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
-                                 "typ/meta/heading-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/heading-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Heading 1 [ Text "Level" , Space , Text "1" ]
+, SoftBreak
 , Heading 2 [ Text "Level" , Space , Text "2" ]
+, SoftBreak
 , Heading 3 [ Text "Level" , Space , Text "3" ]
+, ParBreak
 , Comment
+, SoftBreak
 , Heading 11 [ Text "Level" , Space , Text "11" ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  heading(body: text(body: [Level 1]), 
                          level: 1), 
                  heading(body: text(body: [Level 2]), 
                          level: 2), 
                  heading(body: text(body: [Level 3]), 
                          level: 3), 
+                 text(body: [
+]), 
                  heading(body: text(body: [Level 11]), 
                          level: 11) })
diff --git a/test/typ/meta/heading-01.out b/test/typ/meta/heading-01.out
--- a/test/typ/meta/heading-01.out
+++ b/test/typ/meta/heading-01.out
@@ -1,68 +1,26 @@
 --- parse tree ---
-[ Code
-    "typ/meta/heading-01.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
-                                 "typ/meta/heading-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/heading-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
 , Comment
-, Comment
 , Space
-, Text "="
-, Space
-, Text "Level"
-, Space
-, Text "1"
+, Heading 1 [ Text "Level" , Space , Text "1" ]
 , SoftBreak
 , Code
     "typ/meta/heading-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Block (Content [ Heading 2 [ Text "Level" , Space , Text "2" ] ]))
 , SoftBreak
 , Code
     "typ/meta/heading-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ BlockArg [ Heading 3 [ Text "Level" , Space , Text "3" ] ] ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "No"
 , Space
 , Text "="
@@ -70,6 +28,7 @@
 , Text "heading"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "="
 , Space
 , Text "No"
@@ -78,12 +37,12 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
-                 text(body: [ = Level 1
-]), 
+                 text(body: [ ]), 
+                 heading(body: text(body: [Level 1]), 
+                         level: 1), 
                  heading(body: text(body: [Level 2]), 
                          level: 2), 
                  text(body: [
@@ -91,7 +50,9 @@
                  box(body: heading(body: text(body: [Level 3]), 
                                    level: 3)), 
                  parbreak(), 
-                 text(body: [No = heading]), 
+                 text(body: [
+No = heading]), 
                  parbreak(), 
-                 text(body: [= No heading]), 
+                 text(body: [
+= No heading]), 
                  parbreak() })
diff --git a/test/typ/meta/heading-02.out b/test/typ/meta/heading-02.out
--- a/test/typ/meta/heading-02.out
+++ b/test/typ/meta/heading-02.out
@@ -1,51 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/meta/heading-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
-                                 "typ/meta/heading-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/heading-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Heading
     1
     [ Code
         "typ/meta/heading-02.typ"
-        ( line 4 , column 4 )
+        ( line 3 , column 4 )
         (Block
            (Content
               [ Text "This"
@@ -57,7 +17,9 @@
               , ParBreak
               ]))
     ]
+, ParBreak
 , Heading 1 [ Text "This" ]
+, SoftBreak
 , Text "is"
 , Space
 , Text "not"
@@ -65,10 +27,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  heading(body: { text(body: [This
 is
 multiline.]), 
diff --git a/test/typ/meta/heading-03.out b/test/typ/meta/heading-03.out
--- a/test/typ/meta/heading-03.out
+++ b/test/typ/meta/heading-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/heading-03.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
-                                 "typ/meta/heading-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/heading-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/heading-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -66,10 +27,12 @@
              ])))
 , ParBreak
 , Heading 1 [ Text "Heading" ]
+, SoftBreak
 , Heading 5 [ Text "Heading" , Space , Text "\127757" ]
+, SoftBreak
 , Code
     "typ/meta/heading-03.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "level") (Literal (Int 5))
diff --git a/test/typ/meta/heading-04.out b/test/typ/meta/heading-04.out
--- a/test/typ/meta/heading-04.out
+++ b/test/typ/meta/heading-04.out
@@ -1,53 +1,15 @@
 --- parse tree ---
-[ Code
-    "typ/meta/heading-04.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
-                                 "typ/meta/heading-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/heading-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/heading-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "1.")) ])
 , SoftBreak
 , Heading 1 []
+, SoftBreak
 , Text "Not"
 , Space
 , Text "in"
diff --git a/test/typ/meta/link-00.out b/test/typ/meta/link-00.out
--- a/test/typ/meta/link-00.out
+++ b/test/typ/meta/link-00.out
@@ -1,51 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-00.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
-                                 "typ/meta/link-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Url "https://example.com/"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/meta/link-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Literal (String "https://typst.org/"))
@@ -61,6 +23,7 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "This"
 , Space
 , Text "link"
@@ -69,7 +32,7 @@
 , Space
 , Code
     "typ/meta/link-00.typ"
-    ( line 9 , column 20 )
+    ( line 8 , column 20 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Literal (String "https://google.com/"))
@@ -90,11 +53,12 @@
 , Text "."
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Contact"
 , Space
 , Code
     "typ/meta/link-00.typ"
-    ( line 12 , column 10 )
+    ( line 11 , column 10 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Literal (String "mailto:hi@typst.app")) ])
@@ -105,7 +69,7 @@
 , Space
 , Code
     "typ/meta/link-00.typ"
-    ( line 13 , column 7 )
+    ( line 12 , column 7 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Literal (String "tel:123")) ])
@@ -124,15 +88,19 @@
                  link(body: [https://example.com/], 
                       dest: "https://example.com/"), 
                  parbreak(), 
+                 text(body: [
+]), 
                  link(body: text(body: [Some text text text]), 
                       dest: "https://typst.org/"), 
                  parbreak(), 
-                 text(body: [This link appears ]), 
+                 text(body: [
+This link appears ]), 
                  link(body: text(body: [in the middle of]), 
                       dest: "https://google.com/"), 
                  text(body: [ a paragraph.]), 
                  parbreak(), 
-                 text(body: [Contact ]), 
+                 text(body: [
+Contact ]), 
                  link(dest: "mailto:hi@typst.app"), 
                  text(body: [ or
 call ]), 
diff --git a/test/typ/meta/link-01.out b/test/typ/meta/link-01.out
--- a/test/typ/meta/link-01.out
+++ b/test/typ/meta/link-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-01.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
-                                 "typ/meta/link-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/link-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "link")))
        (Ident (Identifier "underline")))
@@ -53,6 +14,7 @@
 , Text "Wahttp"
 , Text ":"
 , Comment
+, SoftBreak
 , Text "Nohttps"
 , Text ":"
 , Text "/"
@@ -75,7 +37,8 @@
                  text(body: [ ]), 
                  linebreak(), 
                  text(body: [Wahttp:]), 
-                 text(body: [Nohttps://link ]), 
+                 text(body: [
+Nohttps://link ]), 
                  linebreak(), 
                  text(body: [Nohttp:]), 
                  parbreak() })
diff --git a/test/typ/meta/link-02.out b/test/typ/meta/link-02.out
--- a/test/typ/meta/link-02.out
+++ b/test/typ/meta/link-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-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
-                                 "typ/meta/link-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Url "https://[::1]:8080/"
 , Space
 , HardBreak
diff --git a/test/typ/meta/link-03.out b/test/typ/meta/link-03.out
--- a/test/typ/meta/link-03.out
+++ b/test/typ/meta/link-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-03.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
-                                 "typ/meta/link-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/link-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block (Content [ Url "https://example.com/" ]))
 , Space
 , HardBreak
diff --git a/test/typ/meta/link-05.out b/test/typ/meta/link-05.out
--- a/test/typ/meta/link-05.out
+++ b/test/typ/meta/link-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-05.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
-                                 "typ/meta/link-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/link-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "link")))
        (FuncExpr
@@ -73,7 +34,7 @@
 , SoftBreak
 , Code
     "typ/meta/link-05.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Literal (String "https://html5zombo.com/"))
diff --git a/test/typ/meta/link-06.out b/test/typ/meta/link-06.out
--- a/test/typ/meta/link-06.out
+++ b/test/typ/meta/link-06.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-06.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
-                                 "typ/meta/link-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/link-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/meta/link-06.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let
        (BasicBind (Just (Identifier "mylink")))
        (FuncCall
@@ -64,7 +25,7 @@
 , Space
 , Code
     "typ/meta/link-06.typ"
-    ( line 5 , column 10 )
+    ( line 4 , column 10 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/meta/link-07.out b/test/typ/meta/link-07.out
--- a/test/typ/meta/link-07.out
+++ b/test/typ/meta/link-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-07.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
-                                 "typ/meta/link-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/link-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Literal (String "https://example.com/"))
@@ -59,7 +20,7 @@
                   , SoftBreak
                   , Code
                       "typ/meta/link-07.typ"
-                      ( line 5 , column 4 )
+                      ( line 4 , column 4 )
                       (FuncCall
                          (Ident (Identifier "box"))
                          [ NormalArg
diff --git a/test/typ/meta/link-08.out b/test/typ/meta/link-08.out
--- a/test/typ/meta/link-08.out
+++ b/test/typ/meta/link-08.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-08.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
-                                 "typ/meta/link-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/meta/link-08.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg
diff --git a/test/typ/meta/link-09.out b/test/typ/meta/link-09.out
--- a/test/typ/meta/link-09.out
+++ b/test/typ/meta/link-09.out
@@ -1,52 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/meta/link-09.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
-                                 "typ/meta/link-09.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/link-09.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Text"
 , Space
-, Code "typ/meta/link-09.typ" ( line 3 , column 6 ) (Label "hey")
+, Code "typ/meta/link-09.typ" ( line 2 , column 6 ) (Label "hey")
 , SoftBreak
 , Code
     "typ/meta/link-09.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "link"))
        [ NormalArg (Label "hey")
@@ -57,8 +18,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Text ]), 
+Text ]), 
                  <hey>, 
                  text(body: [
 ]), 
diff --git a/test/typ/meta/numbering-00.out b/test/typ/meta/numbering-00.out
--- a/test/typ/meta/numbering-00.out
+++ b/test/typ/meta/numbering-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/numbering-00.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
-                                 "typ/meta/numbering-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/numbering-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/numbering-00.typ"
-    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -68,7 +28,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-00.typ"
-                        ( line 6 , column 10 )
+                        ( line 5 , column 10 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -77,9 +37,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 numbering(numbering: "*", 
+document(body: { numbering(numbering: "*", 
                            numbers: (0)), 
                  text(body: [ and ]), 
                  numbering(numbering: "I.a", 
diff --git a/test/typ/meta/numbering-01.out b/test/typ/meta/numbering-01.out
--- a/test/typ/meta/numbering-01.out
+++ b/test/typ/meta/numbering-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/numbering-01.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
-                                 "typ/meta/numbering-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/numbering-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/numbering-01.typ"
-    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -61,7 +21,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-01.typ"
-                        ( line 4 , column 10 )
+                        ( line 3 , column 10 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -73,7 +33,7 @@
 , HardBreak
 , Code
     "typ/meta/numbering-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -93,7 +53,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-01.typ"
-                        ( line 9 , column 10 )
+                        ( line 8 , column 10 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -105,7 +65,7 @@
 , HardBreak
 , Code
     "typ/meta/numbering-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -125,7 +85,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-01.typ"
-                        ( line 14 , column 10 )
+                        ( line 13 , column 10 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -134,9 +94,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 numbering(numbering: "A", 
+document(body: { numbering(numbering: "A", 
                            numbers: (0)), 
                  text(body: [ for ]), 
                  text(body: [0]), 
diff --git a/test/typ/meta/numbering-02.out b/test/typ/meta/numbering-02.out
--- a/test/typ/meta/numbering-02.out
+++ b/test/typ/meta/numbering-02.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/meta/numbering-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
-                                 "typ/meta/numbering-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/numbering-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/numbering-02.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "he")) ])
 , SoftBreak
 , Code
     "typ/meta/numbering-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -71,7 +31,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-02.typ"
-                        ( line 5 , column 11 )
+                        ( line 4 , column 11 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -81,9 +41,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
-], lang: "he"), 
+], 
+                      lang: "he"), 
                  numbering(numbering: "א.", 
                            numbers: (9)), 
                  text(body: [ עבור ], 
diff --git a/test/typ/meta/numbering-03.out b/test/typ/meta/numbering-03.out
--- a/test/typ/meta/numbering-03.out
+++ b/test/typ/meta/numbering-03.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/meta/numbering-03.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
-                                 "typ/meta/numbering-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/numbering-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/numbering-03.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "zh")) ])
 , SoftBreak
 , Code
     "typ/meta/numbering-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -77,7 +37,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-03.typ"
-                        ( line 7 , column 10 )
+                        ( line 6 , column 10 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -87,9 +47,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
-], lang: "zh"), 
+], 
+                      lang: "zh"), 
                  numbering(numbering: "一", 
                            numbers: (9)), 
                  text(body: [ and ], 
diff --git a/test/typ/meta/numbering-04.out b/test/typ/meta/numbering-04.out
--- a/test/typ/meta/numbering-04.out
+++ b/test/typ/meta/numbering-04.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/numbering-04.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
-                                 "typ/meta/numbering-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/numbering-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/numbering-04.typ"
-    ( line 2 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -68,7 +28,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-04.typ"
-                        ( line 6 , column 11 )
+                        ( line 5 , column 11 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -80,7 +40,7 @@
 , HardBreak
 , Code
     "typ/meta/numbering-04.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -107,7 +67,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-04.typ"
-                        ( line 13 , column 11 )
+                        ( line 12 , column 11 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -119,7 +79,7 @@
 , HardBreak
 , Code
     "typ/meta/numbering-04.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (For
        (BasicBind (Just (Identifier "i")))
        (FuncCall
@@ -141,7 +101,7 @@
                     , Space
                     , Code
                         "typ/meta/numbering-04.typ"
-                        ( line 18 , column 10 )
+                        ( line 17 , column 10 )
                         (Ident (Identifier "i"))
                     , Space
                     , HardBreak
@@ -150,9 +110,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 numbering(numbering: "イ", 
+document(body: { numbering(numbering: "イ", 
                            numbers: (0)), 
                  text(body: [ (or ]), 
                  numbering(numbering: "い", 
diff --git a/test/typ/meta/outline-00.out b/test/typ/meta/outline-00.out
--- a/test/typ/meta/outline-00.out
+++ b/test/typ/meta/outline-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/outline-00.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
-                                 "typ/meta/outline-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/outline-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/outline-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ NormalArg (Literal (String "a7"))
@@ -51,14 +11,14 @@
 , SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "(1/a)")) ])
 , SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -71,7 +31,7 @@
 , SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -84,63 +44,69 @@
 , ParBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall (Ident (Identifier "outline")) [])
 , ParBreak
 , Heading 1 [ Text "Einleitung" ]
+, SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 12)) ])
 , ParBreak
 , Heading 1 [ Text "Analyse" ]
+, SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 10)) ])
 , ParBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (Block
        (Content
           [ SoftBreak
           , Code
               "typ/meta/outline-00.typ"
-              ( line 16 , column 4 )
+              ( line 15 , column 4 )
               (Set
                  (Ident (Identifier "heading"))
                  [ KeyValArg (Identifier "outlined") (Literal (Boolean False)) ])
           , SoftBreak
           , Heading 2 [ Text "Methodik" ]
+          , SoftBreak
           , Code
               "typ/meta/outline-00.typ"
-              ( line 18 , column 4 )
+              ( line 17 , column 4 )
               (FuncCall
                  (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 6)) ])
           , ParBreak
           ]))
 , ParBreak
 , Heading 2 [ Text "Verarbeitung" ]
+, SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 4)) ])
 , ParBreak
 , Heading 2 [ Text "Programmierung" ]
-, RawBlock "rust" "fn main() {\n  panic!(\"in the disco\");\n}\n"
+, SoftBreak
+, RawBlock "rust" "fn main() {\n  panic!(\"in the disco\");\n}"
 , ParBreak
 , Heading 4 [ Text "Deep" , Space , Text "Stuff" ]
+, SoftBreak
 , Text "Ok"
 , Space
 , Ellipsis
 , ParBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 34 , column 2 )
+    ( line 33 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "(I)")) ])
@@ -149,7 +115,7 @@
     1
     [ Code
         "typ/meta/outline-00.typ"
-        ( line 36 , column 4 )
+        ( line 35 , column 4 )
         (FuncCall
            (Ident (Identifier "text"))
            [ NormalArg (Ident (Identifier "blue"))
@@ -157,9 +123,10 @@
            ])
     , Text "fassung"
     ]
+, SoftBreak
 , Code
     "typ/meta/outline-00.typ"
-    ( line 37 , column 2 )
+    ( line 36 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 10)) ])
 , ParBreak
@@ -171,8 +138,6 @@
 ]), 
                  text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  outline(), 
                  parbreak(), 
@@ -209,7 +174,7 @@
                          outlined: false), 
                  raw(block: true, 
                      lang: "rust", 
-                     text: "fn main() {\n  panic!(\"in the disco\");\n}\n"), 
+                     text: "fn main() {\n  panic!(\"in the disco\");\n}"), 
                  parbreak(), 
                  heading(body: text(body: [Deep Stuff]), 
                          level: 4, 
diff --git a/test/typ/meta/query-before-after-00.out b/test/typ/meta/query-before-after-00.out
--- a/test/typ/meta/query-before-after-00.out
+++ b/test/typ/meta/query-before-after-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/query-before-after-00.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
-                                 "typ/meta/query-before-after-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/query-before-after-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/query-before-after-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "paper") (Literal (String "a7"))
@@ -56,7 +16,7 @@
 , ParBreak
 , Code
     "typ/meta/query-before-after-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Show
        (Just
           (FuncCall
@@ -72,12 +32,12 @@
                 [ SoftBreak
                 , Code
                     "typ/meta/query-before-after-00.typ"
-                    ( line 9 , column 4 )
+                    ( line 8 , column 4 )
                     (Ident (Identifier "it"))
                 , ParBreak
                 , Code
                     "typ/meta/query-before-after-00.typ"
-                    ( line 11 , column 4 )
+                    ( line 10 , column 4 )
                     (Set
                        (Ident (Identifier "text"))
                        [ KeyValArg (Identifier "size") (Literal (Numeric 12.0 Pt))
@@ -86,7 +46,7 @@
                 , SoftBreak
                 , Code
                     "typ/meta/query-before-after-00.typ"
-                    ( line 12 , column 4 )
+                    ( line 11 , column 4 )
                     (FuncCall
                        (Ident (Identifier "outline"))
                        [ KeyValArg
@@ -153,7 +113,7 @@
 , ParBreak
 , Code
     "typ/meta/query-before-after-00.typ"
-    ( line 28 , column 2 )
+    ( line 27 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "outlined") (Literal (Boolean True))
@@ -161,21 +121,37 @@
        ])
 , ParBreak
 , Heading 1 [ Text "Section" , Space , Text "1" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "1" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "2" ]
+, SoftBreak
 , Heading 3 [ Text "Subsubsection" , Space , Text "1" ]
+, SoftBreak
 , Heading 3 [ Text "Subsubsection" , Space , Text "2" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "3" ]
+, ParBreak
 , Heading 1 [ Text "Section" , Space , Text "2" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "1" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "2" ]
+, ParBreak
 , Heading 1 [ Text "Section" , Space , Text "3" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "1" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "2" ]
+, SoftBreak
 , Heading 3 [ Text "Subsubsection" , Space , Text "1" ]
+, SoftBreak
 , Heading 3 [ Text "Subsubsection" , Space , Text "2" ]
+, SoftBreak
 , Heading 3 [ Text "Subsubsection" , Space , Text "3" ]
+, SoftBreak
 , Heading 2 [ Text "Subsection" , Space , Text "3" ]
+, ParBreak
 ]
-"typ/meta/query-before-after-00.typ" (line 12, column 4):
+"typ/meta/query-before-after-00.typ" (line 11, column 4):
 Method "location" is not yet implemented or FieldAccess requires a dictionary
diff --git a/test/typ/meta/query-before-after-01.out b/test/typ/meta/query-before-after-01.out
--- a/test/typ/meta/query-before-after-01.out
+++ b/test/typ/meta/query-before-after-01.out
@@ -1,47 +1,7 @@
 --- parse tree ---
 [ Code
     "typ/meta/query-before-after-01.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
-                                 "typ/meta/query-before-after-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/query-before-after-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, ParBreak
-, Code
-    "typ/meta/query-before-after-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "paper") (Literal (String "a7"))
@@ -56,7 +16,7 @@
 , ParBreak
 , Code
     "typ/meta/query-before-after-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "outlined") (Literal (Boolean True))
@@ -64,9 +24,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/meta/query-before-after-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "locate"))
        [ NormalArg
@@ -84,7 +45,7 @@
                     , SoftBreak
                     , Code
                         "typ/meta/query-before-after-01.typ"
-                        ( line 14 , column 4 )
+                        ( line 13 , column 4 )
                         (FuncCall
                            (FieldAccess
                               (Ident (Identifier "join"))
@@ -125,7 +86,7 @@
 , ParBreak
 , Code
     "typ/meta/query-before-after-01.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "heading"))
        [ NormalArg (Literal (String "A"))
@@ -134,7 +95,7 @@
 , SoftBreak
 , Code
     "typ/meta/query-before-after-01.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "heading"))
        [ NormalArg (Literal (String "B"))
@@ -143,7 +104,7 @@
 , SoftBreak
 , Code
     "typ/meta/query-before-after-01.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "heading"))
        [ NormalArg (Literal (String "C"))
@@ -152,7 +113,7 @@
 , SoftBreak
 , Code
     "typ/meta/query-before-after-01.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "heading"))
        [ NormalArg (Literal (String "D"))
@@ -163,7 +124,8 @@
 --- evaluated ---
 document(body: { parbreak(), 
                  parbreak(), 
-                 parbreak(), 
+                 text(body: [
+]), 
                  locate(func: ), 
                  parbreak(), 
                  heading(body: [A], 
diff --git a/test/typ/meta/query-figure-00.out b/test/typ/meta/query-figure-00.out
--- a/test/typ/meta/query-figure-00.out
+++ b/test/typ/meta/query-figure-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/query-figure-00.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
-                                 "typ/meta/query-figure-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/query-figure-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/query-figure-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "paper") (Literal (String "a7"))
@@ -56,14 +16,14 @@
 , ParBreak
 , Code
     "typ/meta/query-figure-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Set
        (Ident (Identifier "figure"))
        [ KeyValArg (Identifier "numbering") (Literal (String "I")) ])
 , SoftBreak
 , Code
     "typ/meta/query-figure-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Show
        (Just (Ident (Identifier "figure")))
        (Set
@@ -73,9 +33,10 @@
 , ParBreak
 , Heading
     1 [ Text "List" , Space , Text "of" , Space , Text "Figures" ]
+, SoftBreak
 , Code
     "typ/meta/query-figure-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "locate"))
        [ NormalArg
@@ -107,7 +68,7 @@
                               , SoftBreak
                               , Code
                                   "typ/meta/query-figure-00.typ"
-                                  ( line 16 , column 6 )
+                                  ( line 15 , column 6 )
                                   (FuncCall
                                      (Ident (Identifier "numbering"))
                                      [ NormalArg
@@ -133,13 +94,13 @@
                               , SoftBreak
                               , Code
                                   "typ/meta/query-figure-00.typ"
-                                  ( line 18 , column 6 )
+                                  ( line 17 , column 6 )
                                   (FieldAccess
                                      (Ident (Identifier "caption")) (Ident (Identifier "it")))
                               , SoftBreak
                               , Code
                                   "typ/meta/query-figure-00.typ"
-                                  ( line 19 , column 6 )
+                                  ( line 18 , column 6 )
                                   (FuncCall
                                      (Ident (Identifier "box"))
                                      [ KeyValArg (Identifier "width") (Literal (Numeric 1.0 Fr))
@@ -150,7 +111,7 @@
                               , SoftBreak
                               , Code
                                   "typ/meta/query-figure-00.typ"
-                                  ( line 20 , column 6 )
+                                  ( line 19 , column 6 )
                                   (FuncCall
                                      (FieldAccess
                                         (Ident (Identifier "first"))
@@ -176,7 +137,7 @@
 , ParBreak
 , Code
     "typ/meta/query-figure-00.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -190,7 +151,7 @@
 , ParBreak
 , Code
     "typ/meta/query-figure-00.typ"
-    ( line 29 , column 2 )
+    ( line 28 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -219,7 +180,7 @@
 , ParBreak
 , Code
     "typ/meta/query-figure-00.typ"
-    ( line 36 , column 2 )
+    ( line 35 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -233,9 +194,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
diff --git a/test/typ/meta/query-header-00.out b/test/typ/meta/query-header-00.out
--- a/test/typ/meta/query-header-00.out
+++ b/test/typ/meta/query-header-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/query-header-00.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
-                                 "typ/meta/query-header-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/query-header-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/query-header-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "paper") (Literal (String "a7"))
@@ -147,35 +107,36 @@
 , ParBreak
 , Code
     "typ/meta/query-header-00.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall (Ident (Identifier "outline")) [])
 , ParBreak
 , Heading 1 [ Text "Introduction" ]
+, SoftBreak
 , Code
     "typ/meta/query-header-00.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 35)) ])
 , ParBreak
 , Heading 1 [ Text "Background" ]
+, SoftBreak
 , Code
     "typ/meta/query-header-00.typ"
-    ( line 27 , column 2 )
+    ( line 26 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 35)) ])
 , ParBreak
 , Heading 1 [ Text "Approach" ]
+, SoftBreak
 , Code
     "typ/meta/query-header-00.typ"
-    ( line 30 , column 2 )
+    ( line 29 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 60)) ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  outline(), 
                  parbreak(), 
                  heading(body: text(body: [Introduction]), 
diff --git a/test/typ/meta/ref-00.out b/test/typ/meta/ref-00.out
--- a/test/typ/meta/ref-00.out
+++ b/test/typ/meta/ref-00.out
@@ -2,52 +2,13 @@
 [ Code
     "typ/meta/ref-00.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
-                                 "typ/meta/ref-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/ref-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/ref-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg (Identifier "numbering") (Literal (String "1.")) ])
 , ParBreak
 , Heading 1 [ Text "Introduction" ]
-, Code "typ/meta/ref-00.typ" ( line 4 , column 16 ) (Label "intro")
+, Space
+, Code "typ/meta/ref-00.typ" ( line 3 , column 16 ) (Label "intro")
 , SoftBreak
 , Text "See"
 , Space
@@ -55,7 +16,8 @@
 , Text "."
 , ParBreak
 , Heading 2 [ Text "Setup" ]
-, Code "typ/meta/ref-00.typ" ( line 7 , column 10 ) (Label "setup")
+, Space
+, Code "typ/meta/ref-00.typ" ( line 6 , column 10 ) (Label "setup")
 , SoftBreak
 , Text "As"
 , Space
@@ -73,12 +35,11 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  heading(body: text(body: [Introduction]), 
                          level: 1, 
                          numbering: "1."), 
+                 text(body: [ ]), 
                  <intro>, 
                  text(body: [
 See ]), 
@@ -89,6 +50,7 @@
                  heading(body: text(body: [Setup]), 
                          level: 2, 
                          numbering: "1."), 
+                 text(body: [ ]), 
                  <setup>, 
                  text(body: [
 As seen in ]), 
diff --git a/test/typ/meta/ref-03.out b/test/typ/meta/ref-03.out
--- a/test/typ/meta/ref-03.out
+++ b/test/typ/meta/ref-03.out
@@ -1,47 +1,7 @@
 --- parse tree ---
 [ Code
     "typ/meta/ref-03.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
-                                 "typ/meta/ref-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/ref-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, ParBreak
-, Code
-    "typ/meta/ref-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "ref")))
        (FuncExpr
@@ -105,7 +65,7 @@
 , ParBreak
 , Code
     "typ/meta/ref-03.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -120,11 +80,11 @@
        , KeyValArg (Identifier "supplement") (Literal (String "Fig"))
        ])
 , Space
-, Code "typ/meta/ref-03.typ" ( line 21 , column 3 ) (Label "fig1")
+, Code "typ/meta/ref-03.typ" ( line 20 , column 3 ) (Label "fig1")
 , ParBreak
 , Code
     "typ/meta/ref-03.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -139,11 +99,11 @@
        , KeyValArg (Identifier "supplement") (Literal (String "Figg"))
        ])
 , Space
-, Code "typ/meta/ref-03.typ" ( line 27 , column 3 ) (Label "fig2")
+, Code "typ/meta/ref-03.typ" ( line 26 , column 3 ) (Label "fig2")
 , ParBreak
 , Code
     "typ/meta/ref-03.typ"
-    ( line 29 , column 2 )
+    ( line 28 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -153,7 +113,7 @@
        , KeyValArg (Identifier "supplement") (Literal (String "Equa"))
        ])
 , Space
-, Code "typ/meta/ref-03.typ" ( line 34 , column 3 ) (Label "eq1")
+, Code "typ/meta/ref-03.typ" ( line 33 , column 3 ) (Label "eq1")
 , SoftBreak
 , Ref "fig1" (Literal Auto)
 , ParBreak
@@ -162,5 +122,5 @@
 , Ref "eq1" (Literal Auto)
 , ParBreak
 ]
-"typ/meta/ref-03.typ" (line 34, column 3):
+"typ/meta/ref-03.typ" (line 33, column 3):
 Content does not have a method "element" or FieldAccess requires a dictionary
diff --git a/test/typ/meta/ref-04.out b/test/typ/meta/ref-04.out
--- a/test/typ/meta/ref-04.out
+++ b/test/typ/meta/ref-04.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/meta/ref-04.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
-                                 "typ/meta/ref-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/ref-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/ref-04.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "heading"))
        [ KeyValArg
@@ -69,7 +29,7 @@
 , ParBreak
 , Code
     "typ/meta/ref-04.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Show
        (Just (Ident (Identifier "ref")))
        (FuncExpr
@@ -137,14 +97,17 @@
                 ]))))
 , ParBreak
 , Heading 1 [ Text "Introduction" ]
+, Space
 , Code
-    "typ/meta/ref-04.typ" ( line 19 , column 16 ) (Label "intro")
+    "typ/meta/ref-04.typ" ( line 18 , column 16 ) (Label "intro")
 , ParBreak
 , Heading 1 [ Text "Summary" ]
-, Code "typ/meta/ref-04.typ" ( line 21 , column 11 ) (Label "sum")
+, Space
+, Code "typ/meta/ref-04.typ" ( line 20 , column 11 ) (Label "sum")
 , ParBreak
 , Heading 2 [ Text "Subsection" ]
-, Code "typ/meta/ref-04.typ" ( line 23 , column 15 ) (Label "sub")
+, Space
+, Code "typ/meta/ref-04.typ" ( line 22 , column 15 ) (Label "sub")
 , ParBreak
 , Ref "intro" (Literal Auto)
 , ParBreak
@@ -153,5 +116,5 @@
 , Ref "sub" (Literal Auto)
 , ParBreak
 ]
-"typ/meta/ref-04.typ" (line 23, column 15):
+"typ/meta/ref-04.typ" (line 22, column 15):
 Content does not have a method "element" or FieldAccess requires a dictionary
diff --git a/test/typ/meta/ref-05.out b/test/typ/meta/ref-05.out
--- a/test/typ/meta/ref-05.out
+++ b/test/typ/meta/ref-05.out
@@ -1,47 +1,7 @@
 --- parse tree ---
 [ Code
     "typ/meta/ref-05.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
-                                 "typ/meta/ref-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/ref-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, ParBreak
-, Code
-    "typ/meta/ref-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "ref")))
        (FuncExpr
@@ -119,13 +79,13 @@
 , Space
 , Text "unreferable"
 , Space
-, Code "typ/meta/ref-05.typ" ( line 25 , column 27 ) (Label "txt")
+, Code "typ/meta/ref-05.typ" ( line 24 , column 27 ) (Label "txt")
 , ParBreak
 , Ref "under" (Literal Auto)
 , SoftBreak
 , Code
     "typ/meta/ref-05.typ"
-    ( line 28 , column 2 )
+    ( line 27 , column 2 )
     (FuncCall
        (Ident (Identifier "underline"))
        [ BlockArg
@@ -140,8 +100,8 @@
            ]
        ])
 , Space
-, Code "typ/meta/ref-05.typ" ( line 30 , column 3 ) (Label "under")
+, Code "typ/meta/ref-05.typ" ( line 29 , column 3 ) (Label "under")
 , ParBreak
 ]
-"typ/meta/ref-05.typ" (line 3, column 2):
+"typ/meta/ref-05.typ" (line 2, column 2):
 Content does not have a method "element" or FieldAccess requires a dictionary
diff --git a/test/typ/meta/state-00.out b/test/typ/meta/state-00.out
--- a/test/typ/meta/state-00.out
+++ b/test/typ/meta/state-00.out
@@ -3,46 +3,6 @@
     "typ/meta/state-00.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
-                                 "typ/meta/state-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/state-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/state-00.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "s")))
        (FuncCall
           (Ident (Identifier "state"))
@@ -52,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/meta/state-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "double")
        [ NormalParam (Identifier "it") ]
@@ -60,7 +20,7 @@
 , ParBreak
 , Code
     "typ/meta/state-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update")) (Ident (Identifier "s")))
@@ -68,7 +28,7 @@
 , SoftBreak
 , Code
     "typ/meta/state-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update")) (Ident (Identifier "s")))
@@ -78,7 +38,7 @@
 , SoftBreak
 , Code
     "typ/meta/state-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "update")) (Ident (Identifier "s")))
@@ -89,7 +49,7 @@
 , Space
 , Code
     "typ/meta/state-00.typ"
-    ( line 10 , column 6 )
+    ( line 9 , column 6 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "display")) (Ident (Identifier "s")))
@@ -101,7 +61,7 @@
 , Space
 , Code
     "typ/meta/state-00.typ"
-    ( line 11 , column 7 )
+    ( line 10 , column 7 )
     (FuncCall
        (Ident (Identifier "locate"))
        [ NormalArg
@@ -135,5 +95,5 @@
 , Text "."
 , ParBreak
 ]
-"typ/meta/state-00.typ" (line 5, column 2):
+"typ/meta/state-00.typ" (line 4, column 2):
 Content does not have a method "update" or FieldAccess requires a dictionary
diff --git a/test/typ/meta/state-01.out b/test/typ/meta/state-01.out
--- a/test/typ/meta/state-01.out
+++ b/test/typ/meta/state-01.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/meta/state-01.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
-                                 "typ/meta/state-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/meta/state-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/meta/state-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 200.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt)) ])
 , ParBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "ls")))
        (FuncCall
@@ -72,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (LetFunc
        (Identifier "loremum")
        [ NormalParam (Identifier "count") ]
@@ -117,7 +77,7 @@
 , ParBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Let
        (BasicBind (Just (Identifier "fs")))
        (FuncCall
@@ -128,7 +88,7 @@
 , SoftBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (LetFunc
        (Identifier "trait")
        [ NormalParam (Identifier "title") ]
@@ -138,7 +98,7 @@
               [ SoftBreak
               , Code
                   "typ/meta/state-01.typ"
-                  ( line 13 , column 4 )
+                  ( line 12 , column 4 )
                   (FuncCall
                      (FieldAccess
                         (Ident (Identifier "display")) (Ident (Identifier "fs")))
@@ -153,14 +113,14 @@
                                    , Strong
                                        [ Code
                                            "typ/meta/state-01.typ"
-                                           ( line 14 , column 7 )
+                                           ( line 13 , column 7 )
                                            (Ident (Identifier "title"))
                                        , Text ":"
                                        ]
                                    , Space
                                    , Code
                                        "typ/meta/state-01.typ"
-                                       ( line 14 , column 16 )
+                                       ( line 13 , column 16 )
                                        (FuncCall
                                           (Ident (Identifier "loremum"))
                                           [ NormalArg (Literal (Int 1)) ])
@@ -171,7 +131,7 @@
               , SoftBreak
               , Code
                   "typ/meta/state-01.typ"
-                  ( line 16 , column 4 )
+                  ( line 15 , column 4 )
                   (FuncCall
                      (FieldAccess
                         (Ident (Identifier "update")) (Ident (Identifier "fs")))
@@ -189,28 +149,28 @@
 , ParBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 19 , column 2 )
+    ( line 18 , column 2 )
     (FuncCall
        (Ident (Identifier "trait")) [ BlockArg [ Text "Boldness" ] ])
 , SoftBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "trait")) [ BlockArg [ Text "Adventure" ] ])
 , SoftBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 21 , column 2 )
+    ( line 20 , column 2 )
     (FuncCall
        (Ident (Identifier "trait")) [ BlockArg [ Text "Fear" ] ])
 , SoftBreak
 , Code
     "typ/meta/state-01.typ"
-    ( line 22 , column 2 )
+    ( line 21 , column 2 )
     (FuncCall
        (Ident (Identifier "trait")) [ BlockArg [ Text "Anger" ] ])
 , ParBreak
 ]
-"typ/meta/state-01.typ" (line 13, column 4):
+"typ/meta/state-01.typ" (line 12, column 4):
 Content does not have a method "display" or FieldAccess requires a dictionary
diff --git a/test/typ/regression/addons/example.out b/test/typ/regression/addons/example.out
--- a/test/typ/regression/addons/example.out
+++ b/test/typ/regression/addons/example.out
@@ -3,46 +3,6 @@
     "typ/regression/addons/example.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
-                                 "typ/regression/addons/example.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/addons/example.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/addons/example.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "utf8string")))
        (FuncCall
           (Ident (Identifier "read"))
@@ -50,6 +10,4 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak() })
+document(body: parbreak())
diff --git a/test/typ/regression/issue1.out b/test/typ/regression/issue1.out
--- a/test/typ/regression/issue1.out
+++ b/test/typ/regression/issue1.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/regression/issue1.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
-                                 "typ/regression/issue1.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue1.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue1.typ"
-    ( line 2 , column 2 )
     (LetFunc
        (Identifier "foo")
        [ NormalParam (Identifier "x") ]
@@ -54,7 +14,7 @@
 , SoftBreak
 , Code
     "typ/regression/issue1.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "foo"))
        [ NormalArg
@@ -64,8 +24,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [(3, 4, 5)]), 
                  parbreak() })
diff --git a/test/typ/regression/issue12.out b/test/typ/regression/issue12.out
--- a/test/typ/regression/issue12.out
+++ b/test/typ/regression/issue12.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue12.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
-                                 "typ/regression/issue12.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue12.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "he"
+[ Text "he"
 , Quote '\''
 , Strong [ Text "llo" , Space , Text "World" ]
 , ParBreak
@@ -50,8 +10,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-he’]), 
+document(body: { text(body: [he’]), 
                  strong(body: text(body: [llo World])), 
                  parbreak(), 
                  text(body: [l’]), 
diff --git a/test/typ/regression/issue15.out b/test/typ/regression/issue15.out
--- a/test/typ/regression/issue15.out
+++ b/test/typ/regression/issue15.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue15.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
-                                 "typ/regression/issue15.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue15.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     False
     [ Code
         "typ/regression/issue15.typ"
-        ( line 2 , column 2 )
+        ( line 1 , column 2 )
         (Ident (Identifier "dots"))
     ]
 , SoftBreak
@@ -51,15 +11,13 @@
     False
     [ Code
         "typ/regression/issue15.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (FieldAccess (Ident (Identifier "l")) (Ident (Identifier "quote")))
     ]
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: false, 
+document(body: { math.equation(block: false, 
                                body: text(body: […]), 
                                numbering: none), 
                  text(body: [
diff --git a/test/typ/regression/issue17.out b/test/typ/regression/issue17.out
--- a/test/typ/regression/issue17.out
+++ b/test/typ/regression/issue17.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue17.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
-                                 "typ/regression/issue17.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue17.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     False
     [ MAttach
         Nothing
@@ -75,7 +35,7 @@
         (Just (Text "3"))
         (Code
            "typ/regression/issue17.typ"
-           ( line 8 , column 2 )
+           ( line 7 , column 2 )
            (Ident (Identifier "sum")))
     ]
 , ParBreak
@@ -86,7 +46,7 @@
         (Just (Text "3"))
         (Code
            "typ/regression/issue17.typ"
-           ( line 10 , column 2 )
+           ( line 9 , column 2 )
            (Ident (Identifier "sum")))
     ]
 , ParBreak
@@ -97,7 +57,7 @@
         (Just (MGroup Nothing Nothing [ Text "j" , Text "=" , Text "0" ]))
         (Code
            "typ/regression/issue17.typ"
-           ( line 12 , column 2 )
+           ( line 11 , column 2 )
            (Ident (Identifier "sum")))
     ]
 , ParBreak
@@ -108,7 +68,7 @@
         (Just (MGroup Nothing Nothing [ Text "j" , Text "=" , Text "0" ]))
         (Code
            "typ/regression/issue17.typ"
-           ( line 14 , column 2 )
+           ( line 13 , column 2 )
            (Ident (Identifier "sum")))
     ]
 , ParBreak
@@ -119,11 +79,11 @@
         (Just
            (Code
               "typ/regression/issue17.typ"
-              ( line 16 , column 12 )
+              ( line 15 , column 12 )
               (Ident (Identifier "pi"))))
         (Code
            "typ/regression/issue17.typ"
-           ( line 16 , column 2 )
+           ( line 15 , column 2 )
            (Ident (Identifier "sum")))
     ]
 , ParBreak
@@ -134,19 +94,17 @@
         (Just
            (Code
               "typ/regression/issue17.typ"
-              ( line 18 , column 6 )
+              ( line 17 , column 6 )
               (Ident (Identifier "pi"))))
         (Code
            "typ/regression/issue17.typ"
-           ( line 18 , column 2 )
+           ( line 17 , column 2 )
            (Ident (Identifier "sum")))
     ]
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: false, 
+document(body: { math.equation(block: false, 
                                body: math.attach(b: none, 
                                                  base: { text(body: [n]), 
                                                          math.lr(body: ({ [(], 
diff --git a/test/typ/regression/issue19.out b/test/typ/regression/issue19.out
--- a/test/typ/regression/issue19.out
+++ b/test/typ/regression/issue19.out
@@ -3,46 +3,6 @@
     "typ/regression/issue19.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
-                                 "typ/regression/issue19.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue19.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue19.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "nums")))
        (Array
           [ Reg (Literal (Int 1))
@@ -52,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/regression/issue19.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "map")) (Ident (Identifier "nums")))
@@ -82,8 +42,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [((1: 1), 1, (2: 1))]), 
                  parbreak() })
diff --git a/test/typ/regression/issue2.out b/test/typ/regression/issue2.out
--- a/test/typ/regression/issue2.out
+++ b/test/typ/regression/issue2.out
@@ -1,60 +1,20 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue2.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
-                                 "typ/regression/issue2.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue2.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     False
     [ Code
         "typ/regression/issue2.typ"
-        ( line 2 , column 2 )
+        ( line 1 , column 2 )
         (FuncCall
            (Ident (Identifier "lr"))
            [ BlockArg
                [ Code
                    "typ/regression/issue2.typ"
-                   ( line 2 , column 6 )
+                   ( line 1 , column 6 )
                    (FieldAccess
                       (Ident (Identifier "alpha")) (Ident (Identifier "sym")))
                , Code
                    "typ/regression/issue2.typ"
-                   ( line 2 , column 16 )
+                   ( line 1 , column 16 )
                    (FieldAccess
                       (Ident (Identifier "beta")) (Ident (Identifier "sym")))
                ]
@@ -63,9 +23,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: false, 
+document(body: { math.equation(block: false, 
                                body: math.lr(body: ({ text(body: [α]), 
                                                       text(body: [β]) })), 
                                numbering: none), 
diff --git a/test/typ/regression/issue20.out b/test/typ/regression/issue20.out
--- a/test/typ/regression/issue20.out
+++ b/test/typ/regression/issue20.out
@@ -3,52 +3,12 @@
     "typ/regression/issue20.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
-                                 "typ/regression/issue20.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue20.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue20.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "a")))
        (Literal (String "\nThis is a\nmultiline string\n")))
 , SoftBreak
 , Code
     "typ/regression/issue20.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (FieldAccess (Ident (Identifier "len")) (Ident (Identifier "a")))
        [])
@@ -56,8 +16,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [28]), 
                  parbreak() })
diff --git a/test/typ/regression/issue21.out b/test/typ/regression/issue21.out
--- a/test/typ/regression/issue21.out
+++ b/test/typ/regression/issue21.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/regression/issue21.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
-                                 "typ/regression/issue21.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue21.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue21.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "version"))
        [ NormalArg (Literal (Int 1)) , NormalArg (Literal (Int 2)) ])
 , SoftBreak
 , Code
     "typ/regression/issue21.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (FieldAccess
           (Ident (Identifier "at"))
@@ -59,9 +19,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [1.2]), 
+document(body: { text(body: [1.2]), 
                  text(body: [
 ]), 
                  text(body: [0]), 
diff --git a/test/typ/regression/issue21b.out b/test/typ/regression/issue21b.out
--- a/test/typ/regression/issue21b.out
+++ b/test/typ/regression/issue21b.out
@@ -2,59 +2,19 @@
 [ Code
     "typ/regression/issue21b.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
-                                 "typ/regression/issue21b.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue21b.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue21b.typ"
-    ( line 2 , column 2 )
     (Import
        (Literal (String "issue19.typ"))
        (NoIdentifiers (Just (Identifier "zeke"))))
 , SoftBreak
 , Code
     "typ/regression/issue21b.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FieldAccess
        (Ident (Identifier "nums")) (Ident (Identifier "zeke")))
 , SoftBreak
 , Code
     "typ/regression/issue21b.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Import
        (Literal (String "issue20.typ"))
        (SomeIdentifiers
@@ -62,14 +22,12 @@
 , SoftBreak
 , Code
     "typ/regression/issue21b.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Ident (Identifier "multiline"))
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [(1, none, 2)]), 
                  text(body: [
diff --git a/test/typ/regression/issue23.out b/test/typ/regression/issue23.out
--- a/test/typ/regression/issue23.out
+++ b/test/typ/regression/issue23.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/regression/issue23.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
-                                 "typ/regression/issue23.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue23.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue23.typ"
-    ( line 2 , column 2 )
     (LetFunc
        (Identifier "fn")
        []
@@ -62,14 +22,12 @@
 , ParBreak
 , Code
     "typ/regression/issue23.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall (Ident (Identifier "fn")) [])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [
 test], 
                       fill: rgb(100%,25%,21%,100%)), 
diff --git a/test/typ/regression/issue25.out b/test/typ/regression/issue25.out
--- a/test/typ/regression/issue25.out
+++ b/test/typ/regression/issue25.out
@@ -3,57 +3,17 @@
     "typ/regression/issue25.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
-                                 "typ/regression/issue25.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue25.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue25.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "x")))
        (Dict [ Reg ( Ident (Identifier "a") , Literal (Int 5) ) ]))
 , SoftBreak
 , Code
     "typ/regression/issue25.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let (BasicBind (Just (Identifier "key"))) (Literal (String "a")))
 , SoftBreak
 , Code
     "typ/regression/issue25.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Block
        (CodeBlock
           [ Assign
@@ -65,14 +25,12 @@
 , SoftBreak
 , Code
     "typ/regression/issue25.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Ident (Identifier "x"))
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/regression/issue26.out b/test/typ/regression/issue26.out
--- a/test/typ/regression/issue26.out
+++ b/test/typ/regression/issue26.out
@@ -3,52 +3,12 @@
     "typ/regression/issue26.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
-                                 "typ/regression/issue26.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue26.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue26.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "x")))
        (Dict [ Reg ( Ident (Identifier "a") , Literal (Int 4) ) ]))
 , SoftBreak
 , Code
     "typ/regression/issue26.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Block
        (CodeBlock
           [ Assign
@@ -60,9 +20,9 @@
 , SoftBreak
 , Code
     "typ/regression/issue26.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Ident (Identifier "x"))
 , ParBreak
 ]
-"typ/regression/issue26.typ" (line 3, column 2):
+"typ/regression/issue26.typ" (line 2, column 2):
 Dictionary does not contain key "b"
diff --git a/test/typ/regression/issue3.out b/test/typ/regression/issue3.out
--- a/test/typ/regression/issue3.out
+++ b/test/typ/regression/issue3.out
@@ -3,46 +3,6 @@
     "typ/regression/issue3.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
-                                 "typ/regression/issue3.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue3.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue3.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "alpha")))
        (Dict
           [ Reg
@@ -56,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/regression/issue3.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Dict
        [ Spr
            (FieldAccess
@@ -67,8 +27,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [(a: 1, b: 2, c: 3)]), 
                  parbreak() })
diff --git a/test/typ/regression/issue41.out b/test/typ/regression/issue41.out
--- a/test/typ/regression/issue41.out
+++ b/test/typ/regression/issue41.out
@@ -1,61 +1,19 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue41.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
-                                 "typ/regression/issue41.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue41.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     False
     [ MAttach
         (Just (Text "2"))
         Nothing
         (Code
            "typ/regression/issue41.typ"
-           ( line 2 , column 2 )
+           ( line 1 , column 2 )
            (FieldAccess
               (Ident (Identifier "circle")) (Ident (Identifier "plus"))))
     ]
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: false, 
+document(body: { math.equation(block: false, 
                                body: math.attach(b: text(body: [2]), 
                                                  base: text(body: [⊕]), 
                                                  t: none), 
diff --git a/test/typ/regression/issue43.out b/test/typ/regression/issue43.out
--- a/test/typ/regression/issue43.out
+++ b/test/typ/regression/issue43.out
@@ -1,57 +1,17 @@
 --- parse tree ---
 [ Code
     "typ/regression/issue43.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
-                                 "typ/regression/issue43.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue43.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue43.typ"
-    ( line 2 , column 1 )
+    ( line 1 , column 1 )
     (Label "foo:bar")
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Let (BasicBind (Just (Identifier "a"))) (Literal (String "a")))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "w")))
        (FuncExpr
@@ -62,56 +22,54 @@
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Let
        (BasicBind (Just (Identifier "x")))
        (Block (Content [ RawInline "hello" ])))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (Let
        (BasicBind (Just (Identifier "a")))
        (Dict [ Reg ( Ident (Identifier "a") , Literal (Int 1) ) ]))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Let
        (BasicBind (Just (Identifier "b")))
        (Dict [ Reg ( Ident (Identifier "b") , Literal (Int 2) ) ]))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (Let
        (BasicBind (Just (Identifier "c")))
        (Dict [ Reg ( Ident (Identifier "c") , Literal (Int 3) ) ]))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (Let
        (BasicBind (Just (Identifier "d")))
        (Dict [ Spr (Ident (Identifier "a")) ]))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (Let
        (BasicBind (Just (Identifier "e")))
        (Dict [ Spr (Ident (Identifier "b")) ]))
 , ParBreak
 , Code
     "typ/regression/issue43.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (Let (BasicBind (Just (Identifier "f"))) (Dict []))
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 <foo:bar>, 
+document(body: { <foo:bar>, 
                  parbreak(), 
                  parbreak(), 
                  parbreak(), 
diff --git a/test/typ/regression/issue49.out b/test/typ/regression/issue49.out
--- a/test/typ/regression/issue49.out
+++ b/test/typ/regression/issue49.out
@@ -1,52 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue49.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
-                                 "typ/regression/issue49.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue49.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "\27979\35797\25991\26412"
+[ Text "\27979\35797\25991\26412"
 , Strong [ Text "\21152\31895" ]
 , Text "\12290"
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-测试文本]), 
+document(body: { text(body: [测试文本]), 
                  strong(body: text(body: [加粗])), 
                  text(body: [。]), 
                  parbreak() })
diff --git a/test/typ/regression/issue5.out b/test/typ/regression/issue5.out
--- a/test/typ/regression/issue5.out
+++ b/test/typ/regression/issue5.out
@@ -1,51 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue5.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
-                                 "typ/regression/issue5.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue5.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation True [ MGroup Nothing Nothing [ Text "3" , Text "!" ] ]
+[ Equation True [ MGroup Nothing Nothing [ Text "3" , Text "!" ] ]
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: { text(body: [3]), 
                                        text(body: [!]) }, 
                                numbering: none), 
diff --git a/test/typ/regression/issue50.out b/test/typ/regression/issue50.out
--- a/test/typ/regression/issue50.out
+++ b/test/typ/regression/issue50.out
@@ -1,51 +1,7 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue50.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
-                                 "typ/regression/issue50.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue50.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation False [ Text "1." ]
-, ParBreak
-]
+[ Equation False [ Text "1." ] , ParBreak ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: false, 
+document(body: { math.equation(block: false, 
                                body: text(body: [1.]), 
                                numbering: none), 
                  parbreak() })
diff --git a/test/typ/regression/issue54.out b/test/typ/regression/issue54.out
--- a/test/typ/regression/issue54.out
+++ b/test/typ/regression/issue54.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue54.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
-                                 "typ/regression/issue54.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue54.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ MAttach
         (Just
@@ -75,9 +35,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: { math.attach(b: { text(body: [a]), 
                                                         math.lr(body: ({ [(], 
                                                                          text(body: [b]), 
diff --git a/test/typ/regression/issue55.out b/test/typ/regression/issue55.out
--- a/test/typ/regression/issue55.out
+++ b/test/typ/regression/issue55.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue55.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
-                                 "typ/regression/issue55.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue55.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ MGroup (Just "(") (Just ")") [ Text "b" ]
     , MFrac
@@ -57,9 +17,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: { math.lr(body: ({ [(], 
                                                         text(body: [b]), 
                                                         [)] })), 
diff --git a/test/typ/regression/issue57.out b/test/typ/regression/issue57.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue57.out
@@ -0,0 +1,35 @@
+--- parse tree ---
+[ Code
+    "typ/regression/issue57.typ"
+    ( line 1 , column 2 )
+    (FuncCall
+       (FuncCall
+          (FieldAccess
+             (Ident (Identifier "func"))
+             (FieldAccess
+                (Ident (Identifier "body"))
+                (Block
+                   (Content
+                      [ Equation
+                          False
+                          [ MAttach
+                              Nothing
+                              (Just
+                                 (Code
+                                    "typ/regression/issue57.typ"
+                                    ( line 1 , column 5 )
+                                    (FieldAccess
+                                       (Ident (Identifier "op")) (Ident (Identifier "ast")))))
+                              (Text "b")
+                          ]
+                      ]))))
+          [])
+       [ NormalArg (Block (Content [ Text "1" ]))
+       , KeyValArg (Identifier "t") (Block (Content [ Text "2" ]))
+       ])
+, ParBreak
+]
+--- evaluated ---
+document(body: { math.attach(base: text(body: [1]), 
+                             t: text(body: [2])), 
+                 parbreak() })
diff --git a/test/typ/regression/issue57.typ b/test/typ/regression/issue57.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue57.typ
@@ -0,0 +1,1 @@
+#$b^*$.body.func()([1], t: [2])
diff --git a/test/typ/regression/issue58-break-continue.out b/test/typ/regression/issue58-break-continue.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue58-break-continue.out
@@ -0,0 +1,232 @@
+--- parse tree ---
+[ Comment
+, SoftBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 2 , column 2 )
+    (LetFunc
+       (Identifier "f")
+       []
+       (Block
+          (CodeBlock
+             [ For
+                 (BasicBind (Just (Identifier "i")))
+                 (FuncCall
+                    (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                 (Block
+                    (CodeBlock
+                       [ For
+                           (BasicBind (Just (Identifier "j")))
+                           (FuncCall
+                              (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Break
+                                 , Array [ Reg (Times (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 13 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "f")) [])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 0)) ])
+              , Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 0)) ])
+              , Reg (Negated (Literal (Int 1)))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 15 , column 2 )
+    (LetFunc
+       (Identifier "g")
+       []
+       (Block
+          (CodeBlock
+             [ For
+                 (BasicBind (Just (Identifier "i")))
+                 (FuncCall
+                    (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                 (Block
+                    (CodeBlock
+                       [ For
+                           (BasicBind (Just (Identifier "j")))
+                           (FuncCall
+                              (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Continue
+                                 , Array [ Reg (Plus (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       , Array [ Reg (Plus (Literal (Int 100)) (Ident (Identifier "i"))) ]
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 27 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "g")) [])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 0)) ])
+              , Reg (Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 1)) ])
+              , Reg (Literal (Int 100))
+              , Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 0)) ])
+              , Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 1)) ])
+              , Reg (Literal (Int 101))
+              , Reg (Negated (Literal (Int 1)))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 29 , column 2 )
+    (LetFunc
+       (Identifier "f")
+       []
+       (Block
+          (CodeBlock
+             [ Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0))
+             , While
+                 (LessThan (Ident (Identifier "i")) (Literal (Int 2)))
+                 (Block
+                    (CodeBlock
+                       [ Assign
+                           (Ident (Identifier "i"))
+                           (Plus (Ident (Identifier "i")) (Literal (Int 1)))
+                       , Let (BasicBind (Just (Identifier "j"))) (Literal (Int 0))
+                       , While
+                           (LessThan (Ident (Identifier "j")) (Literal (Int 2)))
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Assign
+                                     (Ident (Identifier "j"))
+                                     (Plus (Ident (Identifier "j")) (Literal (Int 1)))
+                                 , Break
+                                 , Array [ Reg (Times (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       , Array [ Reg (Plus (Literal (Int 100)) (Ident (Identifier "i"))) ]
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 45 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "f")) [])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 0)) ])
+              , Reg (Literal (Int 101))
+              , Reg (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 0)) ])
+              , Reg (Literal (Int 102))
+              , Reg (Negated (Literal (Int 1)))
+              ])
+       ])
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 47 , column 2 )
+    (LetFunc
+       (Identifier "g")
+       []
+       (Block
+          (CodeBlock
+             [ Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0))
+             , While
+                 (LessThan (Ident (Identifier "i")) (Literal (Int 2)))
+                 (Block
+                    (CodeBlock
+                       [ Assign
+                           (Ident (Identifier "i"))
+                           (Plus (Ident (Identifier "i")) (Literal (Int 1)))
+                       , Let (BasicBind (Just (Identifier "j"))) (Literal (Int 0))
+                       , While
+                           (LessThan (Ident (Identifier "j")) (Literal (Int 2)))
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Assign
+                                     (Ident (Identifier "j"))
+                                     (Plus (Ident (Identifier "j")) (Literal (Int 1)))
+                                 , Continue
+                                 , Array [ Reg (Plus (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       , Array [ Reg (Plus (Literal (Int 100)) (Ident (Identifier "i"))) ]
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-break-continue.typ"
+    ( line 63 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "g")) [])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 0)) ])
+              , Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 1)) ])
+              , Reg (Literal (Int 101))
+              , Reg (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 0)) ])
+              , Reg (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 1)) ])
+              , Reg (Literal (Int 102))
+              , Reg (Negated (Literal (Int 1)))
+              ])
+       ])
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [
+]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak() })
diff --git a/test/typ/regression/issue58-break-continue.typ b/test/typ/regression/issue58-break-continue.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue58-break-continue.typ
@@ -0,0 +1,63 @@
+// Test that `break` and `continue` only affect the innermost loop
+#let f() = {
+  for i in range(2) {
+    for j in range(2) {
+      ((i, j), )
+      break
+      (10 * j,)
+    }
+  }
+  (-1,)
+}
+
+#test(f(), ((0, 0), (1, 0), -1))
+
+#let g() = {
+  for i in range(2) {
+    for j in range(2) {
+      ((i, j), )
+      continue
+      (10 + j,)
+    }
+    (100 + i,)
+  }
+  (-1,)
+}
+
+#test(g(), ((0, 0), (0, 1), 100, (1, 0), (1, 1), 101, -1))
+
+#let f() = {
+  let i = 0
+  while i < 2 {
+    i += 1
+    let j = 0
+    while j < 2 {
+      ((i, j), )
+      j += 1
+      break
+      (10 * j,)
+    }
+    (100 + i,)
+  }
+  (-1,)
+}
+
+#test(f(), ((1, 0), 101, (2, 0), 102, -1))
+
+#let g() = {
+  let i = 0
+  while i < 2 {
+    i += 1
+    let j = 0
+    while j < 2 {
+      ((i, j), )
+      j += 1
+      continue
+      (10 + j,)
+    }
+    (100 + i,)
+  }
+  (-1,)
+}
+
+#test(g(), ((1, 0), (1, 1), 101, (2, 0), (2, 1), 102, -1))
diff --git a/test/typ/regression/issue58-return.out b/test/typ/regression/issue58-return.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue58-return.out
@@ -0,0 +1,209 @@
+--- parse tree ---
+[ Comment
+, SoftBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 2 , column 2 )
+    (LetFunc
+       (Identifier "h")
+       []
+       (Block
+          (CodeBlock
+             [ For
+                 (BasicBind (Just (Identifier "i")))
+                 (FuncCall
+                    (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                 (Block
+                    (CodeBlock
+                       [ For
+                           (BasicBind (Just (Identifier "j")))
+                           (FuncCall
+                              (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Return Nothing
+                                 , Array [ Reg (Times (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 13 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "h")) [])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 0)) , Reg (Literal (Int 0)) ]) ])
+       ])
+, ParBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 15 , column 2 )
+    (LetFunc
+       (Identifier "h")
+       []
+       (Block
+          (CodeBlock
+             [ Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0))
+             , While
+                 (LessThan (Ident (Identifier "i")) (Literal (Int 2)))
+                 (Block
+                    (CodeBlock
+                       [ Assign
+                           (Ident (Identifier "i"))
+                           (Plus (Ident (Identifier "i")) (Literal (Int 1)))
+                       , Let (BasicBind (Just (Identifier "j"))) (Literal (Int 0))
+                       , While
+                           (LessThan (Ident (Identifier "j")) (Literal (Int 2)))
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Assign
+                                     (Ident (Identifier "j"))
+                                     (Plus (Ident (Identifier "j")) (Literal (Int 1)))
+                                 , Return Nothing
+                                 , Array [ Reg (Times (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       , Array [ Reg (Plus (Literal (Int 100)) (Ident (Identifier "i"))) ]
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 31 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "h")) [])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 0)) ]) ])
+       ])
+, ParBreak
+, Comment
+, SoftBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 34 , column 2 )
+    (LetFunc
+       (Identifier "h")
+       []
+       (Block
+          (CodeBlock
+             [ For
+                 (BasicBind (Just (Identifier "i")))
+                 (FuncCall
+                    (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                 (Block
+                    (CodeBlock
+                       [ For
+                           (BasicBind (Just (Identifier "j")))
+                           (FuncCall
+                              (Ident (Identifier "range")) [ NormalArg (Literal (Int 2)) ])
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Return (Just (Block (Content [ Text "a" ])))
+                                 , Array [ Reg (Times (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 45 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "h")) [])
+       , NormalArg (Block (Content [ Text "a" ]))
+       ])
+, ParBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 47 , column 2 )
+    (LetFunc
+       (Identifier "h")
+       []
+       (Block
+          (CodeBlock
+             [ Let (BasicBind (Just (Identifier "i"))) (Literal (Int 0))
+             , While
+                 (LessThan (Ident (Identifier "i")) (Literal (Int 2)))
+                 (Block
+                    (CodeBlock
+                       [ Assign
+                           (Ident (Identifier "i"))
+                           (Plus (Ident (Identifier "i")) (Literal (Int 1)))
+                       , Let (BasicBind (Just (Identifier "j"))) (Literal (Int 0))
+                       , While
+                           (LessThan (Ident (Identifier "j")) (Literal (Int 2)))
+                           (Block
+                              (CodeBlock
+                                 [ Array
+                                     [ Reg
+                                         (Array
+                                            [ Reg (Ident (Identifier "i"))
+                                            , Reg (Ident (Identifier "j"))
+                                            ])
+                                     ]
+                                 , Assign
+                                     (Ident (Identifier "j"))
+                                     (Plus (Ident (Identifier "j")) (Literal (Int 1)))
+                                 , Return (Just (Block (Content [ Text "a" ])))
+                                 , Array [ Reg (Times (Literal (Int 10)) (Ident (Identifier "j"))) ]
+                                 ]))
+                       , Array [ Reg (Plus (Literal (Int 100)) (Ident (Identifier "i"))) ]
+                       ]))
+             , Array [ Reg (Negated (Literal (Int 1))) ]
+             ])))
+, ParBreak
+, Code
+    "typ/regression/issue58-return.typ"
+    ( line 63 , column 2 )
+    (FuncCall
+       (Ident (Identifier "test"))
+       [ NormalArg (FuncCall (Ident (Identifier "h")) [])
+       , NormalArg (Block (Content [ Text "a" ]))
+       ])
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [
+]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak(), 
+                 parbreak(), 
+                 text(body: [✅]), 
+                 parbreak() })
diff --git a/test/typ/regression/issue58-return.typ b/test/typ/regression/issue58-return.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue58-return.typ
@@ -0,0 +1,63 @@
+// Test that `return` works from inside loops
+#let h() = {
+  for i in range(2) {
+    for j in range(2) {
+      ((i, j), )
+      return
+      (10 * j,)
+    }
+  }
+  (-1,)
+}
+
+#test(h(), ((0, 0),))
+
+#let h() = {
+  let i = 0
+  while i < 2 {
+    i += 1
+    let j = 0
+    while j < 2 {
+      ((i, j), )
+      j += 1
+      return
+      (10 * j,)
+    }
+    (100 + i,)
+  }
+  (-1,)
+}
+
+#test(h(), ((1, 0),))
+
+// Test that `return val` works from inside loops
+#let h() = {
+  for i in range(2) {
+    for j in range(2) {
+      ((i, j), )
+      return [a]
+      (10 * j,)
+    }
+  }
+  (-1,)
+}
+
+#test(h(), [a])
+
+#let h() = {
+  let i = 0
+  while i < 2 {
+    i += 1
+    let j = 0
+    while j < 2 {
+      ((i, j), )
+      j += 1
+      return [a]
+      (10 * j,)
+    }
+    (100 + i,)
+  }
+  (-1,)
+}
+
+#test(h(), [a])
diff --git a/test/typ/regression/issue59.out b/test/typ/regression/issue59.out
--- a/test/typ/regression/issue59.out
+++ b/test/typ/regression/issue59.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/regression/issue59.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
-                                 "typ/regression/issue59.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue59.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue59.typ"
-    ( line 2 , column 2 )
     (If
        [ ( Not (Equals (Literal (Int 5)) (Label "foo"))
          , Block (CodeBlock [ Block (Content [ Text "a" ]) ])
@@ -50,7 +10,5 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [a]), 
+document(body: { text(body: [a]), 
                  parbreak() })
diff --git a/test/typ/regression/issue6.out b/test/typ/regression/issue6.out
--- a/test/typ/regression/issue6.out
+++ b/test/typ/regression/issue6.out
@@ -1,63 +1,21 @@
 --- parse tree ---
-[ Code
-    "typ/regression/issue6.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
-                                 "typ/regression/issue6.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue6.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Equation
+[ Equation
     True
     [ Code
         "typ/regression/issue6.typ"
-        ( line 2 , column 4 )
+        ( line 1 , column 4 )
         (Let
            (BasicBind (Just (Identifier "g")))
            (Block (Content [ Equation False [ Text "3" ] ])))
     , Code
         "typ/regression/issue6.typ"
-        ( line 3 , column 2 )
+        ( line 2 , column 2 )
         (Ident (Identifier "g"))
     ]
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 math.equation(block: true, 
+document(body: { math.equation(block: true, 
                                body: math.equation(block: false, 
                                                    body: text(body: [3]), 
                                                    numbering: none), 
diff --git a/test/typ/regression/issue60.out b/test/typ/regression/issue60.out
--- a/test/typ/regression/issue60.out
+++ b/test/typ/regression/issue60.out
@@ -2,60 +2,18 @@
 [ Code
     "typ/regression/issue60.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
-                                 "typ/regression/issue60.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue60.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue60.typ"
-    ( line 2 , column 2 )
     (Import
        (Literal (String "addons/example.typ"))
        (SomeIdentifiers [ ( Identifier "utf8string" , Nothing ) ]))
 , SoftBreak
 , Code
     "typ/regression/issue60.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Ident (Identifier "utf8string"))
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [Anything!
 ]), 
diff --git a/test/typ/regression/issue63.out b/test/typ/regression/issue63.out
--- a/test/typ/regression/issue63.out
+++ b/test/typ/regression/issue63.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/regression/issue63.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
-                                 "typ/regression/issue63.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue63.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue63.typ"
-    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "link")))
        (Ident (Identifier "underline")))
@@ -49,7 +9,7 @@
 , BulletListItem
     [ Code
         "typ/regression/issue63.typ"
-        ( line 4 , column 4 )
+        ( line 3 , column 4 )
         (FuncCall
            (Ident (Identifier "link"))
            [ NormalArg
@@ -70,7 +30,7 @@
 , BulletListItem
     [ Code
         "typ/regression/issue63.typ"
-        ( line 5 , column 4 )
+        ( line 4 , column 4 )
         (FuncCall
            (Ident (Identifier "link"))
            [ NormalArg
@@ -83,17 +43,14 @@
     , Text "Dependecy"
     , Space
     , Text "Injection"
-    , ParBreak
     ]
+, ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  list(children: ({ underline(body: link(body: text(body: [Compose Multiplatform]), 
                                                         dest: "https://www.jetbrains.com/compose-multiplatform/")), 
                                    text(body: [ as front-end framework]) }, 
                                  { underline(body: link(body: text(body: [Koin]), 
                                                         dest: "https://github.com/InsertKoinIO/koin/")), 
-                                   text(body: [ for Dependecy Injection]), 
-                                   parbreak() })) })
+                                   text(body: [ for Dependecy Injection]) })) })
diff --git a/test/typ/regression/issue81.out b/test/typ/regression/issue81.out
--- a/test/typ/regression/issue81.out
+++ b/test/typ/regression/issue81.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/regression/issue81.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
-                                 "typ/regression/issue81.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/regression/issue81.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/regression/issue81.typ"
-    ( line 2 , column 2 )
     (LetFunc
        (Identifier "bug")
        []
@@ -70,14 +30,12 @@
 , SoftBreak
 , Code
     "typ/regression/issue81.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall (Ident (Identifier "bug")) [])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  heading(body: text(body: [1]), 
                          level: 2), 
diff --git a/test/typ/regression/issue86-brackets-00.out b/test/typ/regression/issue86-brackets-00.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue86-brackets-00.out
@@ -0,0 +1,258 @@
+--- parse tree ---
+[ Text "("
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "),"
+, Space
+, Text "("
+, Text "["
+, Text "a"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "b"
+, Text "]"
+, Text ","
+, Space
+, Text "["
+, Text "]"
+, Text "))"
+, ParBreak
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "["
+, Text "]"
+, Text "]"
+, ParBreak
+, Text "["
+, Text "outer"
+, Text "["
+, Code
+    "typ/regression/issue86-brackets-00.typ"
+    ( line 5 , column 9 )
+    (Block
+       (Content
+          [ Text "["
+          , Text "["
+          , Text "["
+          , Code
+              "typ/regression/issue86-brackets-00.typ"
+              ( line 5 , column 14 )
+              (Block
+                 (Content
+                    [ Text "["
+                    , Text "["
+                    , Code
+                        "typ/regression/issue86-brackets-00.typ"
+                        ( line 5 , column 18 )
+                        (Block
+                           (Content
+                              [ Text "inner" , Text "[" , Text "x" , Text "]" , Text "y" ]))
+                    , Text "a"
+                    , Text "]"
+                    , Text "b"
+                    , Text "]"
+                    , Text "mid"
+                    ]))
+          , Text "x"
+          , Text "]"
+          , Text "y"
+          , Text "]"
+          , Text "z"
+          , Text "]"
+          , Text "w"
+          ]))
+, Text "outer"
+, Text "]"
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [(([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []))]), 
+                 parbreak(), 
+                 text(body: [[][][][][][][][][][][][][][][][][][][][[][][][][][][][][][][][][][][][][][][][]]]), 
+                 parbreak(), 
+                 text(body: [[outer[]), 
+                 text(body: [[[[]), 
+                 text(body: [[[]), 
+                 text(body: [inner[x]y]), 
+                 text(body: [a]b]mid]), 
+                 text(body: [x]y]z]w]), 
+                 text(body: [outer]]), 
+                 parbreak() })
diff --git a/test/typ/regression/issue86-brackets-00.typ b/test/typ/regression/issue86-brackets-00.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue86-brackets-00.typ
@@ -0,0 +1,5 @@
+(([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []), ([a], [b], []))
+
+[][][][][][][][][][][][][][][][][][][][[][][][][][][][][][][][][][][][][][][][]]
+
+[outer[#[[[[#[[[#[inner[x]y]a]b]mid]x]y]z]w]outer]
diff --git a/test/typ/regression/issue86-brackets-01.out b/test/typ/regression/issue86-brackets-01.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue86-brackets-01.out
@@ -0,0 +1,62 @@
+--- parse tree ---
+[ Comment
+, SoftBreak
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, Text "["
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]), 
+                 parbreak() })
diff --git a/test/typ/regression/issue86-brackets-01.typ b/test/typ/regression/issue86-brackets-01.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue86-brackets-01.typ
@@ -0,0 +1,2 @@
+// Typst allows unclosed opening braces in markup
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
diff --git a/test/typ/regression/issue86-brackets-02.out b/test/typ/regression/issue86-brackets-02.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue86-brackets-02.out
@@ -0,0 +1,3 @@
+"typ/regression/issue86-brackets-02.typ" (line 2, column 1):
+unexpected ']'
+expecting "*/", "//", "/*", new-line, "=", "\\", "*", "_", "$", "-", "+", digit, "/", "http://", "https://", letter or digit, "```", "`", "~", ".", "'", "\"", "<", "@", "#" or end of input
diff --git a/test/typ/regression/issue86-brackets-02.typ b/test/typ/regression/issue86-brackets-02.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue86-brackets-02.typ
@@ -0,0 +1,2 @@
+// Should error: unexpected `]`
+]
diff --git a/test/typ/regression/issue90-comment-00.out b/test/typ/regression/issue90-comment-00.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comment-00.out
@@ -0,0 +1,19 @@
+--- parse tree ---
+[ Comment
+, SoftBreak
+, Text "par"
+, Space
+, Text "one"
+, Comment
+, ParBreak
+, Text "par"
+, Space
+, Text "two"
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [
+par one]), 
+                 parbreak(), 
+                 text(body: [par two]), 
+                 parbreak() })
diff --git a/test/typ/regression/issue90-comment-00.typ b/test/typ/regression/issue90-comment-00.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comment-00.typ
@@ -0,0 +1,5 @@
+// Par break should be inserted:
+par one//
+     
+par two
+
diff --git a/test/typ/regression/issue90-comment-01.out b/test/typ/regression/issue90-comment-01.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comment-01.out
@@ -0,0 +1,2 @@
+"typ/regression/issue90-comment-01.typ" (line 3, column 36):
+Unexpected end of block comment
diff --git a/test/typ/regression/issue90-comment-01.typ b/test/typ/regression/issue90-comment-01.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comment-01.typ
@@ -0,0 +1,3 @@
+/*
+// */
+unexpected end of block comment -> */
diff --git a/test/typ/regression/issue90-comments-in-listitem-pr96.out b/test/typ/regression/issue90-comments-in-listitem-pr96.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comments-in-listitem-pr96.out
@@ -0,0 +1,11 @@
+--- parse tree ---
+[ BulletListItem [ Text "one" , Space , Comment , Text "two" ]
+, SoftBreak
+, Text "three"
+, ParBreak
+]
+--- evaluated ---
+document(body: { list(children: ({ text(body: [one ]), 
+                                   text(body: [two]) })), 
+                 text(body: [three]), 
+                 parbreak() })
diff --git a/test/typ/regression/issue90-comments-in-listitem-pr96.typ b/test/typ/regression/issue90-comments-in-listitem-pr96.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comments-in-listitem-pr96.typ
@@ -0,0 +1,4 @@
+   - /*
+*/one /*
+*/two
+  three
diff --git a/test/typ/regression/issue90-comments-in-listitem.out b/test/typ/regression/issue90-comments-in-listitem.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comments-in-listitem.out
@@ -0,0 +1,49 @@
+--- parse tree ---
+[ Comment
+, SoftBreak
+, BulletListItem
+    [ Text "first" , SoftBreak , Comment , SoftBreak , Text "third" ]
+, ParBreak
+, Comment
+, SoftBreak
+, BulletListItem
+    [ Text "first" , SoftBreak , Comment , SoftBreak , Text "third" ]
+, ParBreak
+, Comment
+, SoftBreak
+, BulletListItem [ Text "first" ]
+, SoftBreak
+, Comment
+, SoftBreak
+, Text "third"
+, ParBreak
+, Comment
+, SoftBreak
+, BulletListItem
+    [ Text "first" , SoftBreak , Comment , Text "third" ]
+, ParBreak
+]
+--- evaluated ---
+document(body: { text(body: [
+]), 
+                 list(children: ({ text(body: [first
+]), 
+                                   text(body: [
+third]) })), 
+                 text(body: [
+]), 
+                 list(children: ({ text(body: [first
+]), 
+                                   text(body: [
+third]) })), 
+                 text(body: [
+]), 
+                 list(children: (text(body: [first]))), 
+                 text(body: [
+third]), 
+                 parbreak(), 
+                 text(body: [
+]), 
+                 list(children: ({ text(body: [first
+]), 
+                                   text(body: [third]) })) })
diff --git a/test/typ/regression/issue90-comments-in-listitem.typ b/test/typ/regression/issue90-comments-in-listitem.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue90-comments-in-listitem.typ
@@ -0,0 +1,19 @@
+// #90.i
+- first
+  // second
+  third
+
+// #90.ii
+- first
+// second
+  third
+
+// #90.iii
+- first
+  // second
+third
+
+// #90.iv
+- first
+/* second 
+*/third
diff --git a/test/typ/regression/issue92-terms.out b/test/typ/regression/issue92-terms.out
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue92-terms.out
@@ -0,0 +1,26 @@
+--- parse tree ---
+[ DescListItem [] []
+, SoftBreak
+, DescListItem [] [ Text "y" ]
+, SoftBreak
+, DescListItem [ Text "x" ] [ Text "y" ]
+, SoftBreak
+, DescListItem [ Text "x" ] [ Text "y" ]
+, SoftBreak
+, DescListItem [ Text "x" ] [ Text "y" ]
+, ParBreak
+, DescListItem [ Text "-" ] [ BulletListItem [ Text "x" ] ]
+, ParBreak
+]
+--- evaluated ---
+document(body: terms(children: (({  }, 
+                                 {  }), 
+                                ({  }, text(body: [y])), 
+                                (text(body: [x]), 
+                                 text(body: [y])), 
+                                (text(body: [x]), 
+                                 text(body: [y])), 
+                                (text(body: [x]), 
+                                 text(body: [y])), 
+                                (text(body: [-]), 
+                                 list(children: (text(body: [x])))))))
diff --git a/test/typ/regression/issue92-terms.typ b/test/typ/regression/issue92-terms.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue92-terms.typ
@@ -0,0 +1,7 @@
+/ :
+/ :y
+/ x:y
+/ x :y
+/ x : y
+
+/ - :- x
diff --git a/test/typ/text/baseline-00.out b/test/typ/text/baseline-00.out
--- a/test/typ/text/baseline-00.out
+++ b/test/typ/text/baseline-00.out
@@ -1,53 +1,13 @@
 --- parse tree ---
-[ Code
-    "typ/text/baseline-00.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
-                                 "typ/text/baseline-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/baseline-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , EmDash
 , SoftBreak
 , Text "Hi"
 , Space
 , Code
     "typ/text/baseline-00.typ"
-    ( line 5 , column 5 )
+    ( line 4 , column 5 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 1.5 Em)) , BlockArg [ Text "You" ] ])
@@ -55,7 +15,7 @@
 , Space
 , Code
     "typ/text/baseline-00.typ"
-    ( line 5 , column 24 )
+    ( line 4 , column 24 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 0.75 Em))
@@ -77,7 +37,7 @@
 , SoftBreak
 , Code
     "typ/text/baseline-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -85,7 +45,7 @@
        , BlockArg
            [ Code
                "typ/text/baseline-00.typ"
-               ( line 8 , column 26 )
+               ( line 7 , column 26 )
                (FuncCall
                   (Ident (Identifier "box"))
                   [ NormalArg
@@ -100,7 +60,7 @@
 , SoftBreak
 , Code
     "typ/text/baseline-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "baseline") (Literal (Numeric 0.2 Em))
@@ -109,7 +69,7 @@
            , Space
            , Code
                "typ/text/baseline-00.typ"
-               ( line 9 , column 31 )
+               ( line 8 , column 31 )
                (FuncCall
                   (Ident (Identifier "box"))
                   [ NormalArg
@@ -143,7 +103,7 @@
 , Space
 , Code
     "typ/text/baseline-00.typ"
-    ( line 13 , column 6 )
+    ( line 12 , column 6 )
     (FuncCall
        (Ident (Identifier "box"))
        [ KeyValArg
@@ -160,10 +120,8 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-—
+document(body: { parbreak(), 
+                 text(body: [—
 Hi ]), 
                  text(body: text(body: [You]), 
                       size: 1.5em), 
diff --git a/test/typ/text/case-00.out b/test/typ/text/case-00.out
--- a/test/typ/text/case-00.out
+++ b/test/typ/text/case-00.out
@@ -3,52 +3,12 @@
     "typ/text/case-00.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
-                                 "typ/text/case-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/case-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/case-00.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "memes")))
        (Literal (String "ArE mEmEs gReAt?")))
 , SoftBreak
 , Code
     "typ/text/case-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -60,7 +20,7 @@
 , SoftBreak
 , Code
     "typ/text/case-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -72,7 +32,7 @@
 , SoftBreak
 , Code
     "typ/text/case-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
@@ -85,8 +45,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  text(body: [✅]), 
                  text(body: [
diff --git a/test/typ/text/chinese-00.out b/test/typ/text/chinese-00.out
--- a/test/typ/text/chinese-00.out
+++ b/test/typ/text/chinese-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/text/chinese-00.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
-                                 "typ/text/chinese-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/chinese-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/chinese-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -62,9 +22,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  text(body: [是美国广播公司电视剧《迷失》第3季的第22和23集，也是全剧的第71集和72集
 由执行制作人戴蒙·林道夫和卡尔顿·库斯编剧，导演则是另一名执行制作人杰克·本德
 节目于2007年5月23日在美国和加拿大首播，共计吸引了1400万美国观众收看
diff --git a/test/typ/text/copy-paste-00.out b/test/typ/text/copy-paste-00.out
--- a/test/typ/text/copy-paste-00.out
+++ b/test/typ/text/copy-paste-00.out
@@ -1,45 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/text/copy-paste-00.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
-                                 "typ/text/copy-paste-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/copy-paste-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "The"
+[ Text "The"
 , Space
 , Text "after"
 , Space
@@ -49,7 +9,7 @@
 , ParBreak
 , Code
     "typ/text/copy-paste-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ar"))
@@ -61,8 +21,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-The after fira 🏳️‍🌈!]), 
+document(body: { text(body: [The after fira 🏳️‍🌈!]), 
                  parbreak(), 
                  text(body: [
 مرحبًا], 
diff --git a/test/typ/text/deco-00.out b/test/typ/text/deco-00.out
--- a/test/typ/text/deco-00.out
+++ b/test/typ/text/deco-00.out
@@ -3,55 +3,16 @@
     "typ/text/deco-00.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
-                                 "typ/text/deco-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/deco-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/deco-00.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "red")))
        (FuncCall
           (Ident (Identifier "rgb"))
           [ NormalArg (Literal (String "fc0030")) ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/deco-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "strike"))
        [ BlockArg
@@ -73,9 +34,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/deco-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "underline"))
        [ KeyValArg (Identifier "offset") (Literal (Numeric 5.0 Pt))
@@ -83,9 +45,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/deco-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "underline"))
        [ KeyValArg (Identifier "stroke") (Ident (Identifier "red"))
@@ -105,9 +68,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/deco-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -128,9 +92,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/deco-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "overline"))
        [ NormalArg
@@ -151,20 +116,28 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
+document(body: { parbreak(), 
+                 text(body: [
 ]), 
-                 parbreak(), 
                  strike(body: text(body: [Statements dreamt up by the utterly deranged.])), 
                  parbreak(), 
+                 text(body: [
+]), 
                  underline(body: text(body: [Further below.]), 
                            offset: 5.0pt), 
                  parbreak(), 
+                 text(body: [
+]), 
                  underline(body: text(body: [Critical information is conveyed here.]), 
                            evade: false, 
                            stroke: rgb(98%,0%,18%,100%)), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: underline(body: text(body: [Change with the wind.])), 
                       fill: rgb(98%,0%,18%,100%)), 
                  parbreak(), 
+                 text(body: [
+]), 
                  overline(body: underline(body: text(body: [Running amongst the wolves.]))), 
                  parbreak() })
diff --git a/test/typ/text/deco-01.out b/test/typ/text/deco-01.out
--- a/test/typ/text/deco-01.out
+++ b/test/typ/text/deco-01.out
@@ -3,46 +3,6 @@
     "typ/text/deco-01.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
-                                 "typ/text/deco-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/deco-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/deco-01.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "redact")))
        (FuncCall
           (FieldAccess
@@ -53,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/text/deco-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "highlight")))
        (FuncCall
@@ -70,6 +30,7 @@
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Sometimes,"
 , Space
 , Text "we"
@@ -78,7 +39,7 @@
 , Space
 , Code
     "typ/text/deco-01.typ"
-    ( line 6 , column 21 )
+    ( line 5 , column 21 )
     (FuncCall
        (Ident (Identifier "redact"))
        [ BlockArg [ Text "in" , Space , Text "secret" ] ])
@@ -92,7 +53,7 @@
 , Space
 , Code
     "typ/text/deco-01.typ"
-    ( line 7 , column 17 )
+    ( line 6 , column 17 )
     (FuncCall
        (Ident (Identifier "highlight")) [ BlockArg [ Text "redacted" ] ])
 , Space
@@ -107,10 +68,9 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
-                 text(body: [Sometimes, we work ]), 
+                 text(body: [
+Sometimes, we work ]), 
                  strike(body: text(body: [in secret]), 
                         extent: 5.0e-2em, 
                         stroke: 10.0pt), 
diff --git a/test/typ/text/deco-02.out b/test/typ/text/deco-02.out
--- a/test/typ/text/deco-02.out
+++ b/test/typ/text/deco-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/deco-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
-                                 "typ/text/deco-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/deco-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/deco-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "underline"))
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 2.0 Pt))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/text/deco-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "underline"))
        [ NormalArg
diff --git a/test/typ/text/edge-00.out b/test/typ/text/edge-00.out
--- a/test/typ/text/edge-00.out
+++ b/test/typ/text/edge-00.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/text/edge-00.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
-                                 "typ/text/edge-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/edge-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/edge-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 160.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "size") (Literal (Numeric 8.0 Pt)) ])
 , ParBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (LetFunc
        (Identifier "try")
        [ NormalParam (Identifier "top")
@@ -69,7 +29,7 @@
               [ SoftBreak
               , Code
                   "typ/text/edge-00.typ"
-                  ( line 6 , column 4 )
+                  ( line 5 , column 4 )
                   (Set
                      (Ident (Identifier "text"))
                      [ KeyValArg (Identifier "font") (Literal (String "IBM Plex Mono"))
@@ -82,14 +42,14 @@
               , Space
               , Code
                   "typ/text/edge-00.typ"
-                  ( line 7 , column 9 )
+                  ( line 6 , column 9 )
                   (Ident (Identifier "top"))
               , Space
               , Text "to"
               , Space
               , Code
                   "typ/text/edge-00.typ"
-                  ( line 7 , column 17 )
+                  ( line 6 , column 17 )
                   (Ident (Identifier "bottom"))
               , ParBreak
               ]
@@ -97,7 +57,7 @@
 , ParBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "try"))
        [ NormalArg (Literal (String "ascender"))
@@ -106,7 +66,7 @@
 , SoftBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "try"))
        [ NormalArg (Literal (String "ascender"))
@@ -115,7 +75,7 @@
 , SoftBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "try"))
        [ NormalArg (Literal (String "cap-height"))
@@ -124,7 +84,7 @@
 , SoftBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "try"))
        [ NormalArg (Literal (String "x-height"))
@@ -133,7 +93,7 @@
 , SoftBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "try"))
        [ NormalArg (Literal (Numeric 4.0 Pt))
@@ -142,7 +102,7 @@
 , SoftBreak
 , Code
     "typ/text/edge-00.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "try"))
        [ NormalArg
@@ -153,8 +113,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  parbreak(), 
diff --git a/test/typ/text/em-00.out b/test/typ/text/em-00.out
--- a/test/typ/text/em-00.out
+++ b/test/typ/text/em-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/text/em-00.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
-                                 "typ/text/em-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/em-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/em-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "size") (Literal (Numeric 5.0 Pt)) ])
@@ -49,15 +9,16 @@
 , Text "A"
 , Space
 , Comment
+, SoftBreak
 , Code
     "typ/text/em-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Block
        (Content
           [ SoftBreak
           , Code
               "typ/text/em-00.typ"
-              ( line 5 , column 4 )
+              ( line 4 , column 4 )
               (Set
                  (Ident (Identifier "text"))
                  [ KeyValArg (Identifier "size") (Literal (Numeric 2.0 Em)) ])
@@ -65,16 +26,16 @@
           , Text "B"
           , Space
           , Comment
-          , Space
+          , SoftBreak
           , Code
               "typ/text/em-00.typ"
-              ( line 7 , column 4 )
+              ( line 6 , column 4 )
               (Block
                  (Content
                     [ SoftBreak
                     , Code
                         "typ/text/em-00.typ"
-                        ( line 8 , column 6 )
+                        ( line 7 , column 6 )
                         (Set
                            (Ident (Identifier "text"))
                            [ KeyValArg
@@ -85,10 +46,10 @@
                     , Text "C"
                     , Space
                     , Comment
-                    , Space
+                    , SoftBreak
                     , Code
                         "typ/text/em-00.typ"
-                        ( line 10 , column 6 )
+                        ( line 9 , column 6 )
                         (FuncCall
                            (Ident (Identifier "text"))
                            [ KeyValArg (Identifier "size") (Literal (Numeric 2.0 Em))
@@ -96,16 +57,17 @@
                            ])
                     , Space
                     , Comment
-                    , Space
+                    , SoftBreak
                     , Text "E"
                     , Space
                     , Comment
-                    , Space
+                    , ParBreak
                     ]))
           , SoftBreak
           , Text "F"
           , Space
           , Comment
+          , ParBreak
           ]))
 , SoftBreak
 , Text "G"
@@ -115,35 +77,38 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 A ], 
                       size: 5.0pt), 
                  text(body: [
 ], size: 5.0pt), 
                  text(body: [
+], size: 5.0pt), 
+                 text(body: [
 B ], 
                       size: 2.0em), 
-                 text(body: [ ], size: 2.0em), 
                  text(body: [
 ], size: 2.0em), 
                  text(body: [
+], size: 2.0em), 
+                 text(body: [
 C ], 
                       size: 1.5em + 1.0pt), 
-                 text(body: [ ], 
+                 text(body: [
+], 
                       size: 1.5em + 1.0pt), 
                  text(body: text(body: [D], 
                                  size: 1.5em + 1.0pt), 
                       size: 2.0em), 
                  text(body: [ ], 
                       size: 1.5em + 1.0pt), 
-                 text(body: [ E ], 
-                      size: 1.5em + 1.0pt), 
-                 text(body: [ ], 
+                 text(body: [
+E ], 
                       size: 1.5em + 1.0pt), 
+                 parbreak(), 
                  text(body: [
 F ], 
                       size: 1.5em + 1.0pt), 
+                 parbreak(), 
                  text(body: [
 G ], 
                       size: 1.5em + 1.0pt), 
diff --git a/test/typ/text/em-01.out b/test/typ/text/em-01.out
--- a/test/typ/text/em-01.out
+++ b/test/typ/text/em-01.out
@@ -1,69 +1,30 @@
 --- parse tree ---
-[ Code
-    "typ/text/em-01.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
-                                 "typ/text/em-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/em-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/em-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "size") (Literal (Numeric 5.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/em-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "size") (Literal (Numeric 2.0 Em)) ])
 , SoftBreak
 , Code
     "typ/text/em-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red")) ])
 , ParBreak
 , Code
     "typ/text/em-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Let
        (BasicBind (Just (Identifier "size")))
        (Block
@@ -86,7 +47,7 @@
 , ParBreak
 , Code
     "typ/text/em-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
diff --git a/test/typ/text/emoji-00.out b/test/typ/text/emoji-00.out
--- a/test/typ/text/emoji-00.out
+++ b/test/typ/text/emoji-00.out
@@ -1,65 +1,31 @@
 --- parse tree ---
-[ Code
-    "typ/text/emoji-00.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
-                                 "typ/text/emoji-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/emoji-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "\128105\8205\128105\8205\128102"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "\127987\65039\8205\127752"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "\128077\127999"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "1\65039\8419"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [👩‍👩‍👦]), 
+👩‍👩‍👦]), 
                  parbreak(), 
-                 text(body: [🏳️‍🌈]), 
+                 text(body: [
+🏳️‍🌈]), 
                  parbreak(), 
-                 text(body: [👍🏿]), 
+                 text(body: [
+👍🏿]), 
                  parbreak(), 
-                 text(body: [1️⃣]), 
+                 text(body: [
+1️⃣]), 
                  parbreak() })
diff --git a/test/typ/text/emoji-01.out b/test/typ/text/emoji-01.out
--- a/test/typ/text/emoji-01.out
+++ b/test/typ/text/emoji-01.out
@@ -1,50 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/emoji-01.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
-                                 "typ/text/emoji-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/emoji-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, Text "\127966\8205\127755"
-, ParBreak
-]
+[ Comment , SoftBreak , Text "\127966\8205\127755" , ParBreak ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [🏞‍🌋]), 
+🏞‍🌋]), 
                  parbreak() })
diff --git a/test/typ/text/emphasis-00.out b/test/typ/text/emphasis-00.out
--- a/test/typ/text/emphasis-00.out
+++ b/test/typ/text/emphasis-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/emphasis-00.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
-                                 "typ/text/emphasis-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/emphasis-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Emph
     [ Text "Emphasized"
     , Space
@@ -51,17 +12,19 @@
     ]
 , ParBreak
 , Comment
+, SoftBreak
 , Text "hello_world"
 , Space
 , Text "Nutzer*innen"
 , ParBreak
 , Comment
+, SoftBreak
 , Emph
     [ Text "Still"
     , Space
     , Code
         "typ/text/emphasis-00.typ"
-        ( line 9 , column 9 )
+        ( line 8 , column 9 )
         (Block (Content [ ParBreak ]))
     , Space
     , Text "emphasized"
@@ -76,8 +39,11 @@
                               strong(body: text(body: [strong])), 
                               text(body: [ words!]) }), 
                  parbreak(), 
-                 text(body: [hello_world Nutzer*innen]), 
+                 text(body: [
+hello_world Nutzer*innen]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  emph(body: { text(body: [Still ]), 
                               parbreak(), 
                               text(body: [ emphasized.]) }), 
diff --git a/test/typ/text/emphasis-01.out b/test/typ/text/emphasis-01.out
--- a/test/typ/text/emphasis-01.out
+++ b/test/typ/text/emphasis-01.out
@@ -1,49 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/text/emphasis-01.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
-                                 "typ/text/emphasis-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/emphasis-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "P"
 , Code
     "typ/text/emphasis-01.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (FuncCall
        (Ident (Identifier "strong")) [ BlockArg [ Text "art" ] ])
 , Text "ly"
@@ -51,7 +12,7 @@
 , Text "em"
 , Code
     "typ/text/emphasis-01.typ"
-    ( line 3 , column 20 )
+    ( line 2 , column 20 )
     (FuncCall (Ident (Identifier "emph")) [ BlockArg [ Text "phas" ] ])
 , Text "ized"
 , Text "."
@@ -59,8 +20,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [P]), 
+P]), 
                  strong(body: text(body: [art])), 
                  text(body: [ly em]), 
                  emph(body: text(body: [phas])), 
diff --git a/test/typ/text/emphasis-02.out b/test/typ/text/emphasis-02.out
--- a/test/typ/text/emphasis-02.out
+++ b/test/typ/text/emphasis-02.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/text/emphasis-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
-                                 "typ/text/emphasis-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/emphasis-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Normal"
 , ParBreak
 , Code
     "typ/text/emphasis-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "strong"))
        [ KeyValArg (Identifier "delta") (Literal (Int 300)) ])
@@ -53,7 +14,7 @@
 , ParBreak
 , Code
     "typ/text/emphasis-02.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Set
        (Ident (Identifier "strong"))
        [ KeyValArg (Identifier "delta") (Literal (Int 150)) ])
@@ -65,15 +26,14 @@
 , Strong
     [ Code
         "typ/text/emphasis-02.typ"
-        ( line 9 , column 16 )
+        ( line 8 , column 16 )
         (Block (Content [ Strong [ Text "Bold" ] ]))
     ]
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Normal]), 
+Normal]), 
                  parbreak(), 
                  text(body: [
 ]), 
diff --git a/test/typ/text/escape-00.out b/test/typ/text/escape-00.out
--- a/test/typ/text/escape-00.out
+++ b/test/typ/text/escape-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/escape-00.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
-                                 "typ/text/escape-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/escape-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "\\"
 , Space
 , Text "/"
@@ -86,6 +47,7 @@
 , Text "A"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "("
 , Space
 , Text ")"
@@ -93,6 +55,7 @@
 , Text ";"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "/"
 , Text "/"
 , SoftBreak
@@ -106,6 +69,7 @@
 , Strong [ Space , Text "*" , Text "/" , Space ]
 , ParBreak
 , Comment
+, SoftBreak
 , Text "\127957"
 , Space
 , Text "="
@@ -114,6 +78,7 @@
 , Text "\127957"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "A"
 , Space
 , Text "vs"
@@ -126,6 +91,7 @@
 , Text "}"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "let"
 , Space
 , Text "f"
@@ -157,6 +123,7 @@
 , Quote '"'
 , ParBreak
 , Comment
+, SoftBreak
 , Text "10"
 , Text "."
 , Space
@@ -165,23 +132,28 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [\ / [ ] { } # * _ + = ~ ]), 
+\ / [ ] { } # * _ + = ~ ]), 
                  linebreak(), 
                  text(body: [` $ " ' < > @ ( ) A]), 
                  parbreak(), 
-                 text(body: [( ) ;]), 
+                 text(body: [
+( ) ;]), 
                  parbreak(), 
-                 text(body: [//
+                 text(body: [
+//
 /* */
 /]), 
                  strong(body: text(body: [ */ ])), 
                  parbreak(), 
-                 text(body: [🏕 == 🏕]), 
+                 text(body: [
+🏕 == 🏕]), 
                  parbreak(), 
-                 text(body: [A vs. \u{41}]), 
+                 text(body: [
+A vs. \u{41}]), 
                  parbreak(), 
-                 text(body: [let f() , ; : | + - /= == 12 “string”]), 
+                 text(body: [
+let f() , ; : | + - /= == 12 “string”]), 
                  parbreak(), 
-                 text(body: [10. May]), 
+                 text(body: [
+10. May]), 
                  parbreak() })
diff --git a/test/typ/text/fallback-00.out b/test/typ/text/fallback-00.out
--- a/test/typ/text/fallback-00.out
+++ b/test/typ/text/fallback-00.out
@@ -1,48 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/text/fallback-00.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
-                                 "typ/text/fallback-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/fallback-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A\128512B"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "\1583\1593"
 , Space
 , Text "\1575\1604\1606\1589"
@@ -52,30 +14,38 @@
 , Text "\1593\1604\1610\1603"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "\1576\128008\128512\1587\1605"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "A\1576\128512\127966\1587\1605B"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "01\65039\8419\&2"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "A\128008\4850\4638B"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A😀B]), 
+A😀B]), 
                  parbreak(), 
-                 text(body: [دع النص يمطر عليك]), 
+                 text(body: [
+دع النص يمطر عليك]), 
                  parbreak(), 
-                 text(body: [ب🐈😀سم]), 
+                 text(body: [
+ب🐈😀سم]), 
                  parbreak(), 
-                 text(body: [Aب😀🏞سمB]), 
+                 text(body: [
+Aب😀🏞سمB]), 
                  parbreak(), 
-                 text(body: [01️⃣2]), 
+                 text(body: [
+01️⃣2]), 
                  parbreak(), 
-                 text(body: [A🐈ዲሞB]), 
+                 text(body: [
+A🐈ዲሞB]), 
                  parbreak() })
diff --git a/test/typ/text/features-00.out b/test/typ/text/features-00.out
--- a/test/typ/text/features-00.out
+++ b/test/typ/text/features-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-00.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
-                                 "typ/text/features-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "kerning") (Literal (Boolean True))
@@ -52,7 +13,7 @@
 , HardBreak
 , Code
     "typ/text/features-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "kerning") (Literal (Boolean False))
diff --git a/test/typ/text/features-01.out b/test/typ/text/features-01.out
--- a/test/typ/text/features-01.out
+++ b/test/typ/text/features-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-01.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
-                                 "typ/text/features-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "smallcaps")) [ BlockArg [ Text "Smallcaps" ] ])
 , ParBreak
diff --git a/test/typ/text/features-02.out b/test/typ/text/features-02.out
--- a/test/typ/text/features-02.out
+++ b/test/typ/text/features-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-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
-                                 "typ/text/features-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "IBM Plex Serif"))
@@ -54,7 +15,7 @@
 , Space
 , Code
     "typ/text/features-02.typ"
-    ( line 4 , column 7 )
+    ( line 3 , column 7 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "alternates") (Literal (Boolean True))
@@ -68,7 +29,7 @@
 , Space
 , Code
     "typ/text/features-02.typ"
-    ( line 5 , column 7 )
+    ( line 4 , column 7 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "stylistic-set") (Literal (Int 5))
diff --git a/test/typ/text/features-03.out b/test/typ/text/features-03.out
--- a/test/typ/text/features-03.out
+++ b/test/typ/text/features-03.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-03.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
-                                 "typ/text/features-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "fi"
 , Space
 , Text "vs"
@@ -47,7 +8,7 @@
 , Space
 , Code
     "typ/text/features-03.typ"
-    ( line 3 , column 9 )
+    ( line 2 , column 9 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "ligatures") (Literal (Boolean False))
@@ -57,8 +18,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [fi vs. ]), 
+fi vs. ]), 
                  text(body: text(body: [No fi]), 
                       ligatures: false), 
                  parbreak() })
diff --git a/test/typ/text/features-04.out b/test/typ/text/features-04.out
--- a/test/typ/text/features-04.out
+++ b/test/typ/text/features-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-04.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
-                                 "typ/text/features-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -54,7 +15,7 @@
 , HardBreak
 , Code
     "typ/text/features-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "number-type") (Literal Auto)
diff --git a/test/typ/text/features-05.out b/test/typ/text/features-05.out
--- a/test/typ/text/features-05.out
+++ b/test/typ/text/features-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-05.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
-                                 "typ/text/features-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -53,7 +14,7 @@
 , HardBreak
 , Code
     "typ/text/features-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -64,7 +25,7 @@
 , HardBreak
 , Code
     "typ/text/features-05.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
diff --git a/test/typ/text/features-06.out b/test/typ/text/features-06.out
--- a/test/typ/text/features-06.out
+++ b/test/typ/text/features-06.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-06.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
-                                 "typ/text/features-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-06.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "IBM Plex Serif"))
@@ -55,7 +16,7 @@
 , Space
 , Code
     "typ/text/features-06.typ"
-    ( line 4 , column 8 )
+    ( line 3 , column 8 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "slashed-zero") (Literal (Boolean True))
@@ -72,7 +33,7 @@
 , Space
 , Code
     "typ/text/features-06.typ"
-    ( line 5 , column 10 )
+    ( line 4 , column 10 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fractions") (Literal (Boolean True))
diff --git a/test/typ/text/features-07.out b/test/typ/text/features-07.out
--- a/test/typ/text/features-07.out
+++ b/test/typ/text/features-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/features-07.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
-                                 "typ/text/features-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/features-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/features-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -58,7 +19,7 @@
 , Space
 , Code
     "typ/text/features-07.typ"
-    ( line 4 , column 9 )
+    ( line 3 , column 9 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
diff --git a/test/typ/text/font-00.out b/test/typ/text/font-00.out
--- a/test/typ/text/font-00.out
+++ b/test/typ/text/font-00.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/text/font-00.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
-                                 "typ/text/font-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/font-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/font-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 20.0 Pt)) , BlockArg [ Text "A" ] ])
 , SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 2.0 Em)) , BlockArg [ Text "A" ] ])
 , SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -66,16 +27,18 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "text")) [ BlockArg [ Text "Normal" ] ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "style") (Literal (String "italic"))
@@ -83,9 +46,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "weight") (Literal (String "bold"))
@@ -93,9 +57,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "stretch") (Literal (Numeric 50.0 Percent))
@@ -103,9 +68,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "IBM Plex Serif"))
@@ -113,6 +79,7 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "Emoji"
 , Text ":"
 , Space
@@ -123,15 +90,16 @@
 , Text "\127966"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (Block
        (Content
           [ SoftBreak
           , Code
               "typ/text/font-00.typ"
-              ( line 27 , column 4 )
+              ( line 26 , column 4 )
               (Set
                  (Ident (Identifier "text"))
                  [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern")) ])
@@ -142,7 +110,7 @@
           , Space
           , Code
               "typ/text/font-00.typ"
-              ( line 28 , column 12 )
+              ( line 27 , column 12 )
               (FuncCall
                  (Ident (Identifier "text"))
                  [ NormalArg
@@ -158,10 +126,12 @@
           ]))
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/font-00.typ"
-    ( line 33 , column 2 )
+    ( line 32 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -201,25 +171,38 @@
                  text(body: text(body: [A]), 
                       size: 15.0pt + 0.5em), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: text(body: [Normal])), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: text(body: [Italic]), 
                       style: "italic"), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: text(body: [Bold]), 
                       weight: "bold"), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: text(body: [Condensed]), 
                       stretch: 50%), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: text(body: [Serif]), 
                       font: "IBM Plex Serif"), 
                  parbreak(), 
-                 text(body: [Emoji: 🐪, 🌋, 🏞]), 
+                 text(body: [
+Emoji: 🐪, 🌋, 🏞]), 
                  parbreak(), 
                  text(body: [
 ]), 
                  text(body: [
+]), 
+                 text(body: [
 This is ], 
                       fill: rgb(13%,61%,67%,100%)), 
                  text(body: text(body: [way more], 
@@ -230,6 +213,12 @@
                       fill: rgb(13%,61%,67%,100%)), 
                  parbreak(), 
                  parbreak(), 
+                 text(body: [
+], 
+                      fill: rgb(13%,61%,67%,100%)), 
+                 text(body: [
+], 
+                      fill: rgb(13%,61%,67%,100%)), 
                  text(body: [
 2π = 𝛼 + 𝛽. ✅], 
                       fallback: false, 
diff --git a/test/typ/text/font-01.out b/test/typ/text/font-01.out
--- a/test/typ/text/font-01.out
+++ b/test/typ/text/font-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/font-01.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
-                                 "typ/text/font-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/font-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/font-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Literal (String "Text")) ])
@@ -50,7 +11,7 @@
 , HardBreak
 , Code
     "typ/text/font-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Ident (Identifier "red"))
@@ -60,7 +21,7 @@
 , HardBreak
 , Code
     "typ/text/font-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "Ubuntu"))
@@ -71,7 +32,7 @@
 , HardBreak
 , Code
     "typ/text/font-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Block (Content [ Text "Text" ]))
@@ -82,7 +43,7 @@
 , HardBreak
 , Code
     "typ/text/font-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ NormalArg (Ident (Identifier "red"))
diff --git a/test/typ/text/hyphenate-00.out b/test/typ/text/hyphenate-00.out
--- a/test/typ/text/hyphenate-00.out
+++ b/test/typ/text/hyphenate-00.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/text/hyphenate-00.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
-                                 "typ/text/hyphenate-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/hyphenate-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/hyphenate-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/text/hyphenate-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal Auto) ])
 , SoftBreak
 , Code
     "typ/text/hyphenate-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/text/hyphenate-01.out b/test/typ/text/hyphenate-01.out
--- a/test/typ/text/hyphenate-01.out
+++ b/test/typ/text/hyphenate-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/hyphenate-01.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
-                                 "typ/text/hyphenate-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/hyphenate-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/hyphenate-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 110.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/hyphenate-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean True)) ])
@@ -80,7 +41,7 @@
 , Space
 , Code
     "typ/text/hyphenate-01.typ"
-    ( line 8 , column 13 )
+    ( line 7 , column 13 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean False))
@@ -98,7 +59,7 @@
 , Text "wonde"
 , Code
     "typ/text/hyphenate-01.typ"
-    ( line 9 , column 18 )
+    ( line 8 , column 18 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean False))
@@ -112,9 +73,10 @@
 , HardBreak
 , SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/hyphenate-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean False)) ])
@@ -136,7 +98,7 @@
 , Text "wo"
 , Code
     "typ/text/hyphenate-01.typ"
-    ( line 14 , column 15 )
+    ( line 13 , column 15 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean True))
@@ -183,6 +145,9 @@
                  text(body: [ul experiences. ], 
                       hyphenate: true), 
                  linebreak(), 
+                 text(body: [
+], 
+                      hyphenate: true), 
                  text(body: [
 ], 
                       hyphenate: true), 
diff --git a/test/typ/text/hyphenate-02.out b/test/typ/text/hyphenate-02.out
--- a/test/typ/text/hyphenate-02.out
+++ b/test/typ/text/hyphenate-02.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/hyphenate-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
-                                 "typ/text/hyphenate-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/hyphenate-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/hyphenate-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 80.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/hyphenate-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean True)) ])
@@ -62,7 +23,7 @@
 , Space
 , Code
     "typ/text/hyphenate-02.typ"
-    ( line 5 , column 9 )
+    ( line 4 , column 9 )
     (FuncCall (Ident (Identifier "emph")) [ BlockArg [ Text "Tree" ] ])
 , Text "beard"
 , Text "."
diff --git a/test/typ/text/hyphenate-03.out b/test/typ/text/hyphenate-03.out
--- a/test/typ/text/hyphenate-03.out
+++ b/test/typ/text/hyphenate-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/hyphenate-03.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
-                                 "typ/text/hyphenate-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/hyphenate-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/hyphenate-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de"))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/text/hyphenate-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/text/hyphenate-04.out b/test/typ/text/hyphenate-04.out
--- a/test/typ/text/hyphenate-04.out
+++ b/test/typ/text/hyphenate-04.out
@@ -1,65 +1,29 @@
 --- parse tree ---
-[ Code
-    "typ/text/hyphenate-04.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
-                                 "typ/text/hyphenate-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/hyphenate-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/hyphenate-04.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/hyphenate-04.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/text/hyphenate-04.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "h")) [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , Space
@@ -73,6 +37,12 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/text/lang-00.out b/test/typ/text/lang-00.out
--- a/test/typ/text/lang-00.out
+++ b/test/typ/text/lang-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/lang-00.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
-                                 "typ/text/lang-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lang-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lang-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "hyphenate") (Literal (Boolean True)) ])
 , SoftBreak
 , Code
     "typ/text/lang-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/text/lang-01.out b/test/typ/text/lang-01.out
--- a/test/typ/text/lang-01.out
+++ b/test/typ/text/lang-01.out
@@ -1,61 +1,26 @@
 --- parse tree ---
-[ Code
-    "typ/text/lang-01.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
-                                 "typ/text/lang-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lang-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lang-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "Ubuntu")) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Text "\1041\1073"
 , SoftBreak
 , Code
     "typ/text/lang-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "uk"))
@@ -64,7 +29,7 @@
 , SoftBreak
 , Code
     "typ/text/lang-01.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "sr"))
@@ -76,7 +41,17 @@
 document(body: { text(body: [
 ]), 
                  parbreak(), 
-                 text(body: [Бб
+                 text(body: [
+], 
+                      font: "Ubuntu"), 
+                 text(body: [
+], 
+                      font: "Ubuntu"), 
+                 text(body: [
+], 
+                      font: "Ubuntu"), 
+                 text(body: [
+Бб
 ], 
                       font: "Ubuntu"), 
                  text(body: text(body: [Бб], 
diff --git a/test/typ/text/lang-with-region-00.out b/test/typ/text/lang-with-region-00.out
--- a/test/typ/text/lang-with-region-00.out
+++ b/test/typ/text/lang-with-region-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/lang-with-region-00.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
-                                 "typ/text/lang-with-region-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lang-with-region-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lang-with-region-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "zh")) ])
 , SoftBreak
 , Code
     "typ/text/lang-with-region-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "outline")) [])
 , ParBreak
 ]
diff --git a/test/typ/text/lang-with-region-01.out b/test/typ/text/lang-with-region-01.out
--- a/test/typ/text/lang-with-region-01.out
+++ b/test/typ/text/lang-with-region-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/lang-with-region-01.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
-                                 "typ/text/lang-with-region-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lang-with-region-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lang-with-region-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "zh"))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/text/lang-with-region-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "outline")) [])
 , ParBreak
 ]
diff --git a/test/typ/text/lang-with-region-02.out b/test/typ/text/lang-with-region-02.out
--- a/test/typ/text/lang-with-region-02.out
+++ b/test/typ/text/lang-with-region-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/lang-with-region-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
-                                 "typ/text/lang-with-region-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lang-with-region-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lang-with-region-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "zh"))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/text/lang-with-region-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall (Ident (Identifier "outline")) [])
 , ParBreak
 ]
diff --git a/test/typ/text/linebreak-00.out b/test/typ/text/linebreak-00.out
--- a/test/typ/text/linebreak-00.out
+++ b/test/typ/text/linebreak-00.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-00.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
-                                 "typ/text/linebreak-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "This"
 , Space
 , Text "is"
@@ -52,6 +13,5 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [This is a spaceexceedinglylongy.]), 
+This is a spaceexceedinglylongy.]), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-01.out b/test/typ/text/linebreak-01.out
--- a/test/typ/text/linebreak-01.out
+++ b/test/typ/text/linebreak-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-01.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
-                                 "typ/text/linebreak-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Supercalifragilisticexpialidocious"
 , Space
 , Text "Expialigoricmetrioxidation"
@@ -48,6 +9,5 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Supercalifragilisticexpialidocious Expialigoricmetrioxidation.]), 
+Supercalifragilisticexpialidocious Expialigoricmetrioxidation.]), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-02.out b/test/typ/text/linebreak-02.out
--- a/test/typ/text/linebreak-02.out
+++ b/test/typ/text/linebreak-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-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
-                                 "typ/text/linebreak-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "This"
 , Space
 , Text "is"
@@ -49,7 +10,7 @@
 , Text "emp"
 , Code
     "typ/text/linebreak-02.typ"
-    ( line 3 , column 20 )
+    ( line 2 , column 20 )
     (FuncCall (Ident (Identifier "emph")) [ BlockArg [ Text "has" ] ])
 , Text "ized"
 , Text "."
@@ -57,8 +18,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [This is partly emp]), 
+This is partly emp]), 
                  emph(body: text(body: [has])), 
                  text(body: [ized.]), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-03.out b/test/typ/text/linebreak-03.out
--- a/test/typ/text/linebreak-03.out
+++ b/test/typ/text/linebreak-03.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-03.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
-                                 "typ/text/linebreak-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Text "Hard"
+[ Text "Hard"
 , Space
 , Code
     "typ/text/linebreak-03.typ"
-    ( line 2 , column 7 )
+    ( line 1 , column 7 )
     (FuncCall (Ident (Identifier "linebreak")) [])
 , Space
 , Text "break"
@@ -51,8 +11,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-Hard ]), 
+document(body: { text(body: [Hard ]), 
                  linebreak(), 
                  text(body: [ break.]), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-04.out b/test/typ/text/linebreak-04.out
--- a/test/typ/text/linebreak-04.out
+++ b/test/typ/text/linebreak-04.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-04.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
-                                 "typ/text/linebreak-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Hard"
 , Space
 , Text "break"
@@ -57,8 +18,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Hard break directly after ]), 
+Hard break directly after ]), 
                  linebreak(), 
                  text(body: [normal break.]), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-05.out b/test/typ/text/linebreak-05.out
--- a/test/typ/text/linebreak-05.out
+++ b/test/typ/text/linebreak-05.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-05.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
-                                 "typ/text/linebreak-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Two"
 , Space
 , Text "consecutive"
@@ -60,8 +21,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Two consecutive ]), 
+Two consecutive ]), 
                  linebreak(), 
                  linebreak(), 
                  text(body: [breaks and three ]), 
diff --git a/test/typ/text/linebreak-06.out b/test/typ/text/linebreak-06.out
--- a/test/typ/text/linebreak-06.out
+++ b/test/typ/text/linebreak-06.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-06.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
-                                 "typ/text/linebreak-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Trailing"
 , Space
 , Text "break"
@@ -50,8 +11,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Trailing break ]), 
+Trailing break ]), 
                  linebreak(), 
                  linebreak(), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-07.out b/test/typ/text/linebreak-07.out
--- a/test/typ/text/linebreak-07.out
+++ b/test/typ/text/linebreak-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-07.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
-                                 "typ/text/linebreak-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/linebreak-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -55,7 +16,7 @@
 , Space
 , Code
     "typ/text/linebreak-07.typ"
-    ( line 4 , column 14 )
+    ( line 3 , column 14 )
     (FuncCall
        (Ident (Identifier "linebreak"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -76,7 +37,7 @@
 , Space
 , Code
     "typ/text/linebreak-07.typ"
-    ( line 5 , column 38 )
+    ( line 4 , column 38 )
     (FuncCall
        (Ident (Identifier "linebreak"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True)) ])
@@ -88,7 +49,7 @@
 , Space
 , Code
     "typ/text/linebreak-07.typ"
-    ( line 6 , column 26 )
+    ( line 5 , column 26 )
     (FuncCall
        (Ident (Identifier "linebreak"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean False)) ])
diff --git a/test/typ/text/linebreak-08.out b/test/typ/text/linebreak-08.out
--- a/test/typ/text/linebreak-08.out
+++ b/test/typ/text/linebreak-08.out
@@ -1,59 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-08.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
-                                 "typ/text/linebreak-08.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-08.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "First"
 , Space
 , Text "part"
 , Comment
+, SoftBreak
 , Text "Second"
 , Space
 , Text "part"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "First"
 , Space
 , Text "part"
 , Space
 , Comment
+, SoftBreak
 , Text "Second"
 , Space
 , Text "part"
@@ -61,10 +25,12 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [First part]), 
-                 text(body: [Second part]), 
+First part]), 
+                 text(body: [
+Second part]), 
                  parbreak(), 
-                 text(body: [First part ]), 
-                 text(body: [Second part]), 
+                 text(body: [
+First part ]), 
+                 text(body: [
+Second part]), 
                  parbreak() })
diff --git a/test/typ/text/linebreak-obj-00.out b/test/typ/text/linebreak-obj-00.out
--- a/test/typ/text/linebreak-obj-00.out
+++ b/test/typ/text/linebreak-obj-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-obj-00.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
-                                 "typ/text/linebreak-obj-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-obj-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/linebreak-obj-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 162.0 Pt)) ])
@@ -77,7 +38,7 @@
 , ParBreak
 , Code
     "typ/text/linebreak-obj-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "bibliography"))
        [ NormalArg (Literal (String "/works.bib")) ])
diff --git a/test/typ/text/linebreak-obj-01.out b/test/typ/text/linebreak-obj-01.out
--- a/test/typ/text/linebreak-obj-01.out
+++ b/test/typ/text/linebreak-obj-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/linebreak-obj-01.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
-                                 "typ/text/linebreak-obj-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/linebreak-obj-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/linebreak-obj-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 85.0 Pt)) ])
diff --git a/test/typ/text/lorem-00.out b/test/typ/text/lorem-00.out
--- a/test/typ/text/lorem-00.out
+++ b/test/typ/text/lorem-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/lorem-00.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
-                                 "typ/text/lorem-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lorem-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lorem-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 19)) ])
 , ParBreak
diff --git a/test/typ/text/lorem-01.out b/test/typ/text/lorem-01.out
--- a/test/typ/text/lorem-01.out
+++ b/test/typ/text/lorem-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/lorem-01.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
-                                 "typ/text/lorem-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/lorem-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/lorem-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt)) ])
 , ParBreak
 , Code
     "typ/text/lorem-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Block
        (CodeBlock
           [ Let
diff --git a/test/typ/text/microtype-00.out b/test/typ/text/microtype-00.out
--- a/test/typ/text/microtype-00.out
+++ b/test/typ/text/microtype-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/microtype-00.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
-                                 "typ/text/microtype-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/microtype-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/microtype-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 130.0 Pt))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/text/microtype-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "par"))
        [ KeyValArg (Identifier "justify") (Literal (Boolean True))
@@ -60,14 +21,14 @@
 , SoftBreak
 , Code
     "typ/text/microtype-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "size") (Literal (Numeric 9.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/microtype-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt))
@@ -140,9 +101,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/microtype-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "he"))
@@ -204,6 +166,8 @@
                       inset: 0.0pt, 
                       width: 100%), 
                  parbreak(), 
+                 text(body: [
+], size: 9.0pt), 
                  text(body: [
 בנייה נכונה של משפטים ארוכים דורשת ידע בשפה. אז בואו נדבר על מזג האוויר.], 
                       font: ("PT Sans", 
diff --git a/test/typ/text/microtype-01.out b/test/typ/text/microtype-01.out
--- a/test/typ/text/microtype-01.out
+++ b/test/typ/text/microtype-01.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/text/microtype-01.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
-                                 "typ/text/microtype-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/microtype-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/microtype-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "margin") (Literal (Numeric 0.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/microtype-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "end")) ])
 , SoftBreak
 , Code
     "typ/text/microtype-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl")) ])
diff --git a/test/typ/text/quotes-00.out b/test/typ/text/quotes-00.out
--- a/test/typ/text/quotes-00.out
+++ b/test/typ/text/quotes-00.out
@@ -2,54 +2,15 @@
 [ Code
     "typ/text/quotes-00.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
-                                 "typ/text/quotes-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/quotes-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/quotes-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 250.0 Pt)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "en")) ])
@@ -91,7 +52,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de")) ])
@@ -129,7 +90,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "de"))
@@ -169,7 +130,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "es"))
@@ -211,7 +172,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "es"))
@@ -253,7 +214,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "fr"))
@@ -301,7 +262,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "fi")) ])
@@ -333,7 +294,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "he")) ])
@@ -367,7 +328,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 29 , column 2 )
+    ( line 28 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ro")) ])
@@ -407,7 +368,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-00.typ"
-    ( line 32 , column 2 )
+    ( line 31 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "ru")) ])
@@ -447,9 +408,9 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
+document(body: { parbreak(), 
+                 text(body: [
 ]), 
-                 parbreak(), 
                  text(body: [
 “The horse eats no cucumber salad” was the first sentence ever uttered on the ‘telephone.’], 
                       lang: "en"), 
diff --git a/test/typ/text/quotes-01.out b/test/typ/text/quotes-01.out
--- a/test/typ/text/quotes-01.out
+++ b/test/typ/text/quotes-01.out
@@ -1,51 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/quotes-01.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
-                                 "typ/text/quotes-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/quotes-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, Quote '"'
-, Quote '"'
-, ParBreak
-]
+[ Comment , SoftBreak , Quote '"' , Quote '"' , ParBreak ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [””]), 
+“”]), 
                  parbreak() })
diff --git a/test/typ/text/quotes-02.out b/test/typ/text/quotes-02.out
--- a/test/typ/text/quotes-02.out
+++ b/test/typ/text/quotes-02.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/quotes-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
-                                 "typ/text/quotes-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/quotes-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "The"
 , Space
 , Text "5"
@@ -92,8 +53,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [The 5’11” ‘quick” brown fox jumps over the “lazy” dog’s ear.]), 
+The 5’11” ‘quick” brown fox jumps over the “lazy” dog’s ear.]), 
                  parbreak(), 
                  text(body: [He said “I’m a big fella.”]), 
                  parbreak() })
diff --git a/test/typ/text/quotes-03.out b/test/typ/text/quotes-03.out
--- a/test/typ/text/quotes-03.out
+++ b/test/typ/text/quotes-03.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/quotes-03.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
-                                 "typ/text/quotes-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/quotes-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "The"
 , Space
 , Text "5"
@@ -75,6 +36,5 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [The 5'11" ‘quick' brown fox jumps over the "lazy” dog's ear.]), 
+The 5'11" ‘quick' brown fox jumps over the "lazy” dog's ear.]), 
                  parbreak() })
diff --git a/test/typ/text/quotes-04.out b/test/typ/text/quotes-04.out
--- a/test/typ/text/quotes-04.out
+++ b/test/typ/text/quotes-04.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/quotes-04.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
-                                 "typ/text/quotes-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/quotes-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "He"
 , Quote '\''
 , Text "s"
@@ -63,7 +24,7 @@
 , ParBreak
 , Code
     "typ/text/quotes-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "smartquote"))
        [ KeyValArg (Identifier "enabled") (Literal (Boolean False)) ])
@@ -92,8 +53,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [He’s told some books contain questionable “example text”.]), 
+He’s told some books contain questionable “example text”.]), 
                  parbreak(), 
                  text(body: [
 He’s told some books contain questionable “example text”.]), 
diff --git a/test/typ/text/quotes-05.out b/test/typ/text/quotes-05.out
--- a/test/typ/text/quotes-05.out
+++ b/test/typ/text/quotes-05.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/quotes-05.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
-                                 "typ/text/quotes-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/quotes-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Quote '"'
 , Text "She"
 , Space
@@ -54,7 +15,7 @@
 , Space
 , Code
     "typ/text/quotes-05.typ"
-    ( line 3 , column 41 )
+    ( line 2 , column 41 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "lang") (Literal (String "fr"))
@@ -98,12 +59,12 @@
 , Space
 , Code
     "typ/text/quotes-05.typ"
-    ( line 5 , column 41 )
+    ( line 4 , column 41 )
     (Block
        (Content
           [ Code
               "typ/text/quotes-05.typ"
-              ( line 5 , column 43 )
+              ( line 4 , column 43 )
               (Set
                  (Ident (Identifier "smartquote"))
                  [ KeyValArg (Identifier "enabled") (Literal (Boolean False)) ])
@@ -117,8 +78,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [“She suddenly started speaking french: ]), 
+“She suddenly started speaking french: ]), 
                  text(body: text(body: [‘Je suis une banane.’]), 
                       lang: "fr"), 
                  text(body: [” Roman told me.]), 
diff --git a/test/typ/text/raw-00.out b/test/typ/text/raw-00.out
--- a/test/typ/text/raw-00.out
+++ b/test/typ/text/raw-00.out
@@ -1,49 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-00.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
-                                 "typ/text/raw-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, RawInline "A"
-, RawInline "B"
-, ParBreak
-]
+[ Comment , SoftBreak , RawInline "A" , RawInline "B" , ParBreak ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
diff --git a/test/typ/text/raw-01.out b/test/typ/text/raw-01.out
--- a/test/typ/text/raw-01.out
+++ b/test/typ/text/raw-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-01.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
-                                 "typ/text/raw-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , RawBlock "typ" "#let x = 1"
 , Space
 , HardBreak
diff --git a/test/typ/text/raw-02.out b/test/typ/text/raw-02.out
--- a/test/typ/text/raw-02.out
+++ b/test/typ/text/raw-02.out
@@ -1,62 +1,20 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-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
-                                 "typ/text/raw-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Text "Text"
 , SoftBreak
-, RawBlock "rust" "fn code() {}\n"
+, RawBlock "rust" "fn code() {}"
 , SoftBreak
 , Text "Text"
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-Text
+document(body: { parbreak(), 
+                 text(body: [Text
 ]), 
                  raw(block: true, 
                      lang: "rust", 
-                     text: "fn code() {}\n"), 
+                     text: "fn code() {}"), 
                  text(body: [
 Text]), 
                  parbreak() })
diff --git a/test/typ/text/raw-03.out b/test/typ/text/raw-03.out
--- a/test/typ/text/raw-03.out
+++ b/test/typ/text/raw-03.out
@@ -1,52 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-03.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
-                                 "typ/text/raw-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, RawBlock "" "```backticks```\n"
-, ParBreak
-]
+[ Comment , SoftBreak , RawBlock "" "```backticks```" , ParBreak ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
                  raw(block: true, 
                      lang: none, 
-                     text: "```backticks```\n"), 
+                     text: "```backticks```"), 
                  parbreak() })
diff --git a/test/typ/text/raw-04.out b/test/typ/text/raw-04.out
--- a/test/typ/text/raw-04.out
+++ b/test/typ/text/raw-04.out
@@ -1,47 +1,8 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-04.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
-                                 "typ/text/raw-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Text "The"
 , Space
 , Text "keyword"
@@ -50,6 +11,7 @@
 , Text "."
 , ParBreak
 , Comment
+, SoftBreak
 , Text "("
 , RawInline ""
 , Text ")"
@@ -61,7 +23,7 @@
 , Space
 , HardBreak
 , Text "("
-, RawBlock "" "trimmed` "
+, RawBlock "" "trimmed`"
 , Text ")"
 , Space
 , HardBreak
@@ -78,17 +40,16 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
-]), 
-                 text(body: [The keyword ]), 
+The keyword ]), 
                  raw(block: true, 
                      lang: "rust", 
                      text: "let"), 
                  text(body: [.]), 
                  parbreak(), 
-                 text(body: [(]), 
+                 text(body: [
+(]), 
                  raw(block: false, 
                      lang: none, 
                      text: ""), 
@@ -103,7 +64,7 @@
                  text(body: [(]), 
                  raw(block: true, 
                      lang: none, 
-                     text: "trimmed` "), 
+                     text: "trimmed`"), 
                  text(body: [) ]), 
                  linebreak(), 
                  text(body: [(]), 
diff --git a/test/typ/text/raw-05.out b/test/typ/text/raw-05.out
--- a/test/typ/text/raw-05.out
+++ b/test/typ/text/raw-05.out
@@ -1,48 +1,5 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-05.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
-                                 "typ/text/raw-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, RawInline "rust let"
-, ParBreak
-]
+[ Comment , SoftBreak , RawInline "rust let" , ParBreak ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
diff --git a/test/typ/text/raw-06.out b/test/typ/text/raw-06.out
--- a/test/typ/text/raw-06.out
+++ b/test/typ/text/raw-06.out
@@ -1,54 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-06.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
-                                 "typ/text/raw-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, Space
-, RawBlock "" "  A\n        B\n       C\n     "
-, ParBreak
-]
+[ Comment , SoftBreak , RawBlock "" "  A\n   B\n  C" , ParBreak ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [ ]), 
                  raw(block: true, 
                      lang: none, 
-                     text: "  A\n        B\n       C\n     "), 
+                     text: "  A\n   B\n  C"), 
                  parbreak() })
diff --git a/test/typ/text/raw-07.out b/test/typ/text/raw-07.out
--- a/test/typ/text/raw-07.out
+++ b/test/typ/text/raw-07.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-07.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
-                                 "typ/text/raw-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/raw-07.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Show
        (Just (Ident (Identifier "raw")))
        (Set
diff --git a/test/typ/text/raw-align-00.out b/test/typ/text/raw-align-00.out
--- a/test/typ/text/raw-align-00.out
+++ b/test/typ/text/raw-align-00.out
@@ -1,79 +1,40 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-align-00.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
-                                 "typ/text/raw-align-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-align-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/raw-align-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center")) ])
 , SoftBreak
 , Code
     "typ/text/raw-align-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-align-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , ParBreak
 , Code
     "typ/text/raw-align-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 20)) ])
 , ParBreak
 , RawBlock
     "py"
-    "def something(x):\n  return x\n\na = 342395823859823958329\nb = 324923\n"
+    "def something(x):\n  return x\n\na = 342395823859823958329\nb = 324923"
 , ParBreak
 , Code
     "typ/text/raw-align-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 20)) ])
 , ParBreak
@@ -91,7 +52,7 @@
                  parbreak(), 
                  raw(block: true, 
                      lang: "py", 
-                     text: "def something(x):\n  return x\n\na = 342395823859823958329\nb = 324923\n"), 
+                     text: "def something(x):\n  return x\n\na = 342395823859823958329\nb = 324923"), 
                  parbreak(), 
                  text(body: [Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut], 
                       size: 6.0pt), 
diff --git a/test/typ/text/raw-align-01.out b/test/typ/text/raw-align-01.out
--- a/test/typ/text/raw-align-01.out
+++ b/test/typ/text/raw-align-01.out
@@ -1,68 +1,29 @@
 --- parse tree ---
-[ Code
-    "typ/text/raw-align-01.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
-                                 "typ/text/raw-align-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-align-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/raw-align-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-align-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , ParBreak
 , Code
     "typ/text/raw-align-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 20)) ])
 , SoftBreak
 , Code
     "typ/text/raw-align-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
@@ -80,7 +41,7 @@
 , SoftBreak
 , Code
     "typ/text/raw-align-01.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "lorem")) [ NormalArg (Literal (Int 20)) ])
 , ParBreak
diff --git a/test/typ/text/raw-code-00.out b/test/typ/text/raw-code-00.out
--- a/test/typ/text/raw-code-00.out
+++ b/test/typ/text/raw-code-00.out
@@ -2,70 +2,28 @@
 [ Code
     "typ/text/raw-code-00.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
-                                 "typ/text/raw-code-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-code-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/raw-code-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-code-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , SoftBreak
 , RawBlock
     "typ"
-    "= Chapter 1\n#lorem(100)\n\n#let hi = \"Hello World\"\n#show heading: emph\n"
+    "= Chapter 1\n#lorem(100)\n\n#let hi = \"Hello World\"\n#show heading: emph"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
                  text(body: [
-]), 
-                 text(body: [
 ], size: 6.0pt), 
                  raw(block: true, 
                      lang: "typ", 
-                     text: "= Chapter 1\n#lorem(100)\n\n#let hi = \"Hello World\"\n#show heading: emph\n"), 
+                     text: "= Chapter 1\n#lorem(100)\n\n#let hi = \"Hello World\"\n#show heading: emph"), 
                  parbreak() })
diff --git a/test/typ/text/raw-code-01.out b/test/typ/text/raw-code-01.out
--- a/test/typ/text/raw-code-01.out
+++ b/test/typ/text/raw-code-01.out
@@ -2,69 +2,27 @@
 [ Code
     "typ/text/raw-code-01.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
-                                 "typ/text/raw-code-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-code-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/raw-code-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-code-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , ParBreak
 , RawBlock
     "rust"
-    "/// A carefully designed state machine.\n#[derive(Debug)]\nenum State<'a> { A(u8), B(&'a str) }\n\nfn advance(state: State<'_>) -> State<'_> {\n    unimplemented!(\"state machine\")\n}\n"
+    "/// A carefully designed state machine.\n#[derive(Debug)]\nenum State<'a> { A(u8), B(&'a str) }\n\nfn advance(state: State<'_>) -> State<'_> {\n    unimplemented!(\"state machine\")\n}"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  raw(block: true, 
                      lang: "rust", 
-                     text: "/// A carefully designed state machine.\n#[derive(Debug)]\nenum State<'a> { A(u8), B(&'a str) }\n\nfn advance(state: State<'_>) -> State<'_> {\n    unimplemented!(\"state machine\")\n}\n"), 
+                     text: "/// A carefully designed state machine.\n#[derive(Debug)]\nenum State<'a> { A(u8), B(&'a str) }\n\nfn advance(state: State<'_>) -> State<'_> {\n    unimplemented!(\"state machine\")\n}"), 
                  parbreak() })
diff --git a/test/typ/text/raw-code-02.out b/test/typ/text/raw-code-02.out
--- a/test/typ/text/raw-code-02.out
+++ b/test/typ/text/raw-code-02.out
@@ -2,67 +2,25 @@
 [ Code
     "typ/text/raw-code-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
-                                 "typ/text/raw-code-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-code-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/raw-code-02.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-code-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , ParBreak
-, RawBlock "py" "import this\n\ndef hi():\n  print(\"Hi!\")\n"
+, RawBlock "py" "import this\n\ndef hi():\n  print(\"Hi!\")"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  raw(block: true, 
                      lang: "py", 
-                     text: "import this\n\ndef hi():\n  print(\"Hi!\")\n"), 
+                     text: "import this\n\ndef hi():\n  print(\"Hi!\")"), 
                  parbreak() })
diff --git a/test/typ/text/raw-code-03.out b/test/typ/text/raw-code-03.out
--- a/test/typ/text/raw-code-03.out
+++ b/test/typ/text/raw-code-03.out
@@ -2,69 +2,27 @@
 [ Code
     "typ/text/raw-code-03.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
-                                 "typ/text/raw-code-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-code-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/raw-code-03.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-code-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , ParBreak
 , RawBlock
     "cpp"
-    "#include <iostream>\n\nint main() {\n  std::cout << \"Hello, world!\";\n}\n"
+    "#include <iostream>\n\nint main() {\n  std::cout << \"Hello, world!\";\n}"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  raw(block: true, 
                      lang: "cpp", 
-                     text: "#include <iostream>\n\nint main() {\n  std::cout << \"Hello, world!\";\n}\n"), 
+                     text: "#include <iostream>\n\nint main() {\n  std::cout << \"Hello, world!\";\n}"), 
                  parbreak() })
diff --git a/test/typ/text/raw-code-04.out b/test/typ/text/raw-code-04.out
--- a/test/typ/text/raw-code-04.out
+++ b/test/typ/text/raw-code-04.out
@@ -2,60 +2,20 @@
 [ Code
     "typ/text/raw-code-04.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
-                                 "typ/text/raw-code-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/raw-code-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/raw-code-04.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 180.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/text/raw-code-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 6.0 Pt)) ])
 , ParBreak
 , Code
     "typ/text/raw-code-04.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg
@@ -77,7 +37,7 @@
            [ SoftBreak
            , RawBlock
                "html"
-               "<!DOCTYPE html>\n  <html>\n    <head>\n      <meta charset=\"utf-8\">\n    </head>\n    <body>\n      <h1>Topic</h1>\n      <p>The Hypertext Markup Language.</p>\n      <script>\n        function foo(a, b) {\n          return a + b + \"string\";\n        }\n      </script>\n    </body>\n  </html>\n  "
+               "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n  </head>\n  <body>\n    <h1>Topic</h1>\n    <p>The Hypertext Markup Language.</p>\n    <script>\n      function foo(a, b) {\n        return a + b + \"string\";\n      }\n    </script>\n  </body>\n</html>"
            , ParBreak
            ]
        ])
@@ -86,15 +46,13 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
-                 text(body: [
-]), 
                  parbreak(), 
                  rect(body: { text(body: [
 ], 
                                    size: 6.0pt), 
                               raw(block: true, 
                                   lang: "html", 
-                                  text: "<!DOCTYPE html>\n  <html>\n    <head>\n      <meta charset=\"utf-8\">\n    </head>\n    <body>\n      <h1>Topic</h1>\n      <p>The Hypertext Markup Language.</p>\n      <script>\n        function foo(a, b) {\n          return a + b + \"string\";\n        }\n      </script>\n    </body>\n  </html>\n  "), 
+                                  text: "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n  </head>\n  <body>\n    <h1>Topic</h1>\n    <p>The Hypertext Markup Language.</p>\n    <script>\n      function foo(a, b) {\n        return a + b + \"string\";\n      }\n    </script>\n  </body>\n</html>"), 
                               parbreak() }, 
                       fill: rgb(93%,94%,95%,100%), 
                       inset: (x: 4.0pt, y: 5.0pt), 
diff --git a/test/typ/text/shaping-00.out b/test/typ/text/shaping-00.out
--- a/test/typ/text/shaping-00.out
+++ b/test/typ/text/shaping-00.out
@@ -1,52 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/shaping-00.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
-                                 "typ/text/shaping-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/shaping-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "ABC\2309\2346\2366\2352\2381\2335\2350\2375\2306\2335"
 , ParBreak
 , Comment
+, SoftBreak
 , Text "\2309\2346\2366\2352\2381\2335\2350\2375\2306\2335"
 , ParBreak
 , Comment
+, SoftBreak
 , Comment
+, SoftBreak
 , Text "\2309"
 , Space
 , Text "\2346\2366"
@@ -62,10 +26,13 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [ABCअपार्टमेंट]), 
+ABCअपार्टमेंट]), 
                  parbreak(), 
-                 text(body: [अपार्टमेंट]), 
+                 text(body: [
+अपार्टमेंट]), 
                  parbreak(), 
-                 text(body: [अ पा र् ट में ट]), 
+                 text(body: [
+]), 
+                 text(body: [
+अ पा र् ट में ट]), 
                  parbreak() })
diff --git a/test/typ/text/shaping-01.out b/test/typ/text/shaping-01.out
--- a/test/typ/text/shaping-01.out
+++ b/test/typ/text/shaping-01.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/text/shaping-01.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
-                                 "typ/text/shaping-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/shaping-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/text/shaping-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "rtl"))
@@ -57,6 +19,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ], 
diff --git a/test/typ/text/shift-00.out b/test/typ/text/shift-00.out
--- a/test/typ/text/shift-00.out
+++ b/test/typ/text/shift-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/text/shift-00.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
-                                 "typ/text/shift-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/shift-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/shift-00.typ"
-    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 3))
@@ -54,7 +14,7 @@
                  [ Text "x"
                  , Code
                      "typ/text/shift-00.typ"
-                     ( line 5 , column 6 )
+                     ( line 4 , column 6 )
                      (FuncCall (Ident (Identifier "super")) [ BlockArg [ Text "1" ] ])
                  ]))
        , NormalArg
@@ -63,7 +23,7 @@
                  [ Text "x"
                  , Code
                      "typ/text/shift-00.typ"
-                     ( line 5 , column 20 )
+                     ( line 4 , column 20 )
                      (FuncCall (Ident (Identifier "super")) [ BlockArg [ Text "5n" ] ])
                  ]))
        , NormalArg
@@ -72,7 +32,7 @@
                  [ Text "x"
                  , Code
                      "typ/text/shift-00.typ"
-                     ( line 5 , column 35 )
+                     ( line 4 , column 35 )
                      (FuncCall
                         (Ident (Identifier "super"))
                         [ BlockArg
@@ -80,7 +40,7 @@
                             , Space
                             , Code
                                 "typ/text/shift-00.typ"
-                                ( line 5 , column 44 )
+                                ( line 4 , column 44 )
                                 (FuncCall
                                    (Ident (Identifier "box"))
                                    [ NormalArg
@@ -98,7 +58,7 @@
                  [ Text "x"
                  , Code
                      "typ/text/shift-00.typ"
-                     ( line 6 , column 6 )
+                     ( line 5 , column 6 )
                      (FuncCall (Ident (Identifier "sub")) [ BlockArg [ Text "1" ] ])
                  ]))
        , NormalArg
@@ -107,7 +67,7 @@
                  [ Text "x"
                  , Code
                      "typ/text/shift-00.typ"
-                     ( line 6 , column 18 )
+                     ( line 5 , column 18 )
                      (FuncCall (Ident (Identifier "sub")) [ BlockArg [ Text "5n" ] ])
                  ]))
        , NormalArg
@@ -116,7 +76,7 @@
                  [ Text "x"
                  , Code
                      "typ/text/shift-00.typ"
-                     ( line 6 , column 31 )
+                     ( line 5 , column 31 )
                      (FuncCall
                         (Ident (Identifier "sub"))
                         [ BlockArg
@@ -124,7 +84,7 @@
                             , Space
                             , Code
                                 "typ/text/shift-00.typ"
-                                ( line 6 , column 38 )
+                                ( line 5 , column 38 )
                                 (FuncCall
                                    (Ident (Identifier "box"))
                                    [ NormalArg
@@ -140,9 +100,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 table(children: (text(body: [Typo.]), 
+document(body: { table(children: (text(body: [Typo.]), 
                                   text(body: [Fallb.]), 
                                   text(body: [Synth]), 
                                   { text(body: [x]), 
diff --git a/test/typ/text/shift-01.out b/test/typ/text/shift-01.out
--- a/test/typ/text/shift-01.out
+++ b/test/typ/text/shift-01.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/text/shift-01.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
-                                 "typ/text/shift-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/shift-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/shift-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "super"))
        [ KeyValArg (Identifier "typographic") (Literal (Boolean False))
@@ -53,14 +13,14 @@
 , Text "n"
 , Code
     "typ/text/shift-01.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (FuncCall (Ident (Identifier "super")) [ BlockArg [ Text "1" ] ])
 , Text ","
 , Space
 , Text "n"
 , Code
     "typ/text/shift-01.typ"
-    ( line 3 , column 15 )
+    ( line 2 , column 15 )
     (FuncCall (Ident (Identifier "sub")) [ BlockArg [ Text "2" ] ])
 , Text ","
 , Space
@@ -69,14 +29,12 @@
 , Text "n"
 , Code
     "typ/text/shift-01.typ"
-    ( line 3 , column 29 )
+    ( line 2 , column 29 )
     (FuncCall (Ident (Identifier "super")) [ BlockArg [ Text "N" ] ])
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 n]), 
                  super(baseline: -0.25em, 
                        body: text(body: [1]), 
diff --git a/test/typ/text/shift-02.out b/test/typ/text/shift-02.out
--- a/test/typ/text/shift-02.out
+++ b/test/typ/text/shift-02.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/text/shift-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
-                                 "typ/text/shift-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/shift-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/shift-02.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "underline"))
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 0.5 Pt))
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/text/shift-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "underline"))
        [ BlockArg
@@ -59,7 +19,7 @@
            , Text "claim"
            , Code
                "typ/text/shift-02.typ"
-               ( line 3 , column 22 )
+               ( line 2 , column 22 )
                (FuncCall
                   (Ident (Identifier "super"))
                   [ BlockArg [ Text "[" , Text "4" , Text "]" ] ])
@@ -79,13 +39,13 @@
 , Text "claim"
 , Code
     "typ/text/shift-02.typ"
-    ( line 4 , column 11 )
+    ( line 3 , column 11 )
     (FuncCall
        (Ident (Identifier "super"))
        [ BlockArg
            [ Code
                "typ/text/shift-02.typ"
-               ( line 4 , column 18 )
+               ( line 3 , column 18 )
                (FuncCall
                   (Ident (Identifier "underline"))
                   [ BlockArg [ Text "[" , Text "4" , Text "]" ] ])
@@ -109,7 +69,7 @@
 , Text "been"
 , Code
     "typ/text/shift-02.typ"
-    ( line 5 , column 20 )
+    ( line 4 , column 20 )
     (FuncCall
        (Ident (Identifier "super"))
        [ NormalArg
@@ -131,8 +91,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  underline(body: { text(body: [The claim]), 
                                    super(body: text(body: [[4]])) }, 
diff --git a/test/typ/text/space-00.out b/test/typ/text/space-00.out
--- a/test/typ/text/space-00.out
+++ b/test/typ/text/space-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-00.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
-                                 "typ/text/space-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Code
     "typ/text/space-00.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal (Int 1)))
 , Text "B"
 , Space
 , Code
     "typ/text/space-00.typ"
-    ( line 3 , column 17 )
+    ( line 2 , column 17 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -61,13 +22,13 @@
 , Space
 , Code
     "typ/text/space-00.typ"
-    ( line 4 , column 4 )
+    ( line 3 , column 4 )
     (Let (BasicBind (Just (Identifier "x"))) (Literal (Int 2)))
 , Text "D"
 , Space
 , Code
     "typ/text/space-00.typ"
-    ( line 4 , column 17 )
+    ( line 3 , column 17 )
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "x"))
@@ -78,7 +39,7 @@
 , Text "E"
 , Code
     "typ/text/space-00.typ"
-    ( line 5 , column 3 )
+    ( line 4 , column 3 )
     (If [ ( Literal (Boolean True) , Block (Content [ Text "F" ]) ) ])
 , Text "G"
 , Space
@@ -87,7 +48,7 @@
 , Space
 , Code
     "typ/text/space-00.typ"
-    ( line 6 , column 4 )
+    ( line 5 , column 4 )
     (If
        [ ( Literal (Boolean True)
          , Block (CodeBlock [ Literal (String "I") ])
@@ -101,7 +62,7 @@
 , Space
 , Code
     "typ/text/space-00.typ"
-    ( line 7 , column 4 )
+    ( line 6 , column 4 )
     (If
        [ ( Literal (Boolean True) , Block (Content [ Text "L" ]) )
        , ( Literal (Boolean True) , Block (Content []) )
@@ -111,20 +72,20 @@
 , HardBreak
 , Code
     "typ/text/space-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Let (BasicBind (Just (Identifier "c"))) (Literal (Boolean True)))
 , Space
 , Text "N"
 , Code
     "typ/text/space-00.typ"
-    ( line 8 , column 18 )
+    ( line 7 , column 18 )
     (While
        (Ident (Identifier "c"))
        (Block
           (Content
              [ Code
                  "typ/text/space-00.typ"
-                 ( line 8 , column 28 )
+                 ( line 7 , column 28 )
                  (Assign (Ident (Identifier "c")) (Literal (Boolean False)))
              , Text "O"
              ])))
@@ -134,14 +95,14 @@
 , HardBreak
 , Code
     "typ/text/space-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (Let (BasicBind (Just (Identifier "c"))) (Literal (Boolean True)))
 , Space
 , Text "Q"
 , Space
 , Code
     "typ/text/space-00.typ"
-    ( line 9 , column 19 )
+    ( line 8 , column 19 )
     (While
        (Ident (Identifier "c"))
        (Block
@@ -156,7 +117,7 @@
 , Text "T"
 , Code
     "typ/text/space-00.typ"
-    ( line 10 , column 3 )
+    ( line 9 , column 3 )
     (For
        (BasicBind Nothing)
        (Array [ Reg (Literal None) ])
@@ -165,20 +126,20 @@
 , SoftBreak
 , Code
     "typ/text/space-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (Let (BasicBind (Just (Identifier "foo"))) (Literal (String "A")))
 , Space
 , HardBreak
 , Code
     "typ/text/space-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (Ident (Identifier "foo"))
 , Text "B"
 , Space
 , HardBreak
 , Code
     "typ/text/space-00.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (Ident (Identifier "foo"))
 , Space
 , Text "B"
@@ -186,15 +147,14 @@
 , HardBreak
 , Code
     "typ/text/space-00.typ"
-    ( line 14 , column 2 )
+    ( line 13 , column 2 )
     (Ident (Identifier "foo"))
 , Text "B"
 , ParBreak
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
+A]), 
                  text(body: [B ]), 
                  text(body: [✅]), 
                  text(body: [ ]), 
diff --git a/test/typ/text/space-01.out b/test/typ/text/space-01.out
--- a/test/typ/text/space-01.out
+++ b/test/typ/text/space-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-01.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
-                                 "typ/text/space-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Comment
 , Text "B"
@@ -67,8 +28,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
+A]), 
                  text(body: [B]), 
                  text(body: [C ]), 
                  linebreak(), 
diff --git a/test/typ/text/space-02.out b/test/typ/text/space-02.out
--- a/test/typ/text/space-02.out
+++ b/test/typ/text/space-02.out
@@ -1,49 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-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
-                                 "typ/text/space-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Code
     "typ/text/space-02.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "IBM Plex Serif"))
@@ -54,8 +15,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
+A]), 
                  text(body: text(body: [ ]), 
                       font: "IBM Plex Serif"), 
                  text(body: [B]), 
diff --git a/test/typ/text/space-03.out b/test/typ/text/space-03.out
--- a/test/typ/text/space-03.out
+++ b/test/typ/text/space-03.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-03.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
-                                 "typ/text/space-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "Left"
 , Space
 , Code
     "typ/text/space-03.typ"
-    ( line 3 , column 7 )
+    ( line 2 , column 7 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "IBM Plex Serif"))
@@ -55,8 +16,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [Left ]), 
+Left ]), 
                  text(body: text(body: [Right]), 
                       font: "IBM Plex Serif"), 
                  text(body: [.]), 
diff --git a/test/typ/text/space-04.out b/test/typ/text/space-04.out
--- a/test/typ/text/space-04.out
+++ b/test/typ/text/space-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-04.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
-                                 "typ/text/space-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/space-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
diff --git a/test/typ/text/space-05.out b/test/typ/text/space-05.out
--- a/test/typ/text/space-05.out
+++ b/test/typ/text/space-05.out
@@ -1,49 +1,10 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-05.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
-                                 "typ/text/space-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Code
     "typ/text/space-05.typ"
-    ( line 3 , column 3 )
+    ( line 2 , column 3 )
     (Literal (String "\n"))
 , Space
 , Text "B"
@@ -51,8 +12,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A]), 
+A]), 
                  text(body: [
 ]), 
                  text(body: [ B]), 
diff --git a/test/typ/text/space-06.out b/test/typ/text/space-06.out
--- a/test/typ/text/space-06.out
+++ b/test/typ/text/space-06.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/space-06.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
-                                 "typ/text/space-06.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/space-06.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "LLLLLLLLLLLLLLLLLL"
 , Space
 , Text "R"
@@ -49,7 +10,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [LLLLLLLLLLLLLLLLLL R ]), 
+LLLLLLLLLLLLLLLLLL R ]), 
                  emph(body: text(body: [L])), 
                  parbreak() })
diff --git a/test/typ/text/symbol-00.out b/test/typ/text/symbol-00.out
--- a/test/typ/text/symbol-00.out
+++ b/test/typ/text/symbol-00.out
@@ -2,52 +2,12 @@
 [ Code
     "typ/text/symbol-00.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
-                                 "typ/text/symbol-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/symbol-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/text/symbol-00.typ"
-    ( line 2 , column 2 )
     (FieldAccess
        (Ident (Identifier "face")) (Ident (Identifier "emoji")))
 , SoftBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FieldAccess
        (Ident (Identifier "old"))
        (FieldAccess
@@ -55,13 +15,13 @@
 , SoftBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FieldAccess
        (Ident (Identifier "turtle")) (Ident (Identifier "emoji")))
 , ParBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -70,13 +30,13 @@
 , SoftBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FieldAccess
        (Ident (Identifier "arrow")) (Ident (Identifier "sym")))
 , SoftBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FieldAccess
        (Ident (Identifier "l"))
        (FieldAccess
@@ -84,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FieldAccess
        (Ident (Identifier "squiggly"))
        (FieldAccess
@@ -94,7 +54,7 @@
 , SoftBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FieldAccess
        (Ident (Identifier "hook"))
        (FieldAccess
@@ -104,7 +64,7 @@
 , ParBreak
 , Code
     "typ/text/symbol-00.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FieldAccess
        (Ident (Identifier "r"))
        (FieldAccess
@@ -116,7 +76,7 @@
 , Text "this"
 , Code
     "typ/text/symbol-00.typ"
-    ( line 12 , column 28 )
+    ( line 11 , column 28 )
     (FieldAccess
        (Ident (Identifier "l"))
        (FieldAccess
@@ -124,9 +84,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [😀]), 
+document(body: { text(body: [😀]), 
                  text(body: [
 ]), 
                  text(body: [👵]), 
diff --git a/test/typ/text/tracking-spacing-00.out b/test/typ/text/tracking-spacing-00.out
--- a/test/typ/text/tracking-spacing-00.out
+++ b/test/typ/text/tracking-spacing-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/tracking-spacing-00.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
-                                 "typ/text/tracking-spacing-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/tracking-spacing-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/tracking-spacing-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
diff --git a/test/typ/text/tracking-spacing-01.out b/test/typ/text/tracking-spacing-01.out
--- a/test/typ/text/tracking-spacing-01.out
+++ b/test/typ/text/tracking-spacing-01.out
@@ -1,45 +1,6 @@
 --- parse tree ---
-[ Code
-    "typ/text/tracking-spacing-01.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
-                                 "typ/text/tracking-spacing-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/tracking-spacing-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "I"
 , Quote '\''
 , Text "m"
@@ -47,7 +8,7 @@
 , Text "in"
 , Code
     "typ/text/tracking-spacing-01.typ"
-    ( line 3 , column 8 )
+    ( line 2 , column 8 )
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -60,8 +21,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [I’m in]), 
+I’m in]), 
                  text(body: text(body: [ spaace]), 
                       tracking: 0.15em + 1.5pt), 
                  text(body: [!]), 
diff --git a/test/typ/text/tracking-spacing-02.out b/test/typ/text/tracking-spacing-02.out
--- a/test/typ/text/tracking-spacing-02.out
+++ b/test/typ/text/tracking-spacing-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/tracking-spacing-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
-                                 "typ/text/tracking-spacing-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/tracking-spacing-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/tracking-spacing-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
@@ -55,7 +16,7 @@
 , SoftBreak
 , Code
     "typ/text/tracking-spacing-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "tracking") (Literal (Numeric 0.3 Em)) ])
diff --git a/test/typ/text/tracking-spacing-03.out b/test/typ/text/tracking-spacing-03.out
--- a/test/typ/text/tracking-spacing-03.out
+++ b/test/typ/text/tracking-spacing-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/tracking-spacing-03.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
-                                 "typ/text/tracking-spacing-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/tracking-spacing-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/tracking-spacing-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "tracking") (Literal (Numeric 0.3 Em)) ])
diff --git a/test/typ/text/tracking-spacing-04.out b/test/typ/text/tracking-spacing-04.out
--- a/test/typ/text/tracking-spacing-04.out
+++ b/test/typ/text/tracking-spacing-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/tracking-spacing-04.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
-                                 "typ/text/tracking-spacing-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/tracking-spacing-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/tracking-spacing-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "spacing") (Literal (Numeric 1.0 Em)) ])
diff --git a/test/typ/text/tracking-spacing-05.out b/test/typ/text/tracking-spacing-05.out
--- a/test/typ/text/tracking-spacing-05.out
+++ b/test/typ/text/tracking-spacing-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/text/tracking-spacing-05.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
-                                 "typ/text/tracking-spacing-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/text/tracking-spacing-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/text/tracking-spacing-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg
diff --git a/test/typ/visualize/image-00.out b/test/typ/visualize/image-00.out
--- a/test/typ/visualize/image-00.out
+++ b/test/typ/visualize/image-00.out
@@ -1,77 +1,40 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/image-00.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
-                                 "typ/visualize/image-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/image-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/image-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "image"))
        [ NormalArg (Literal (String "/assets/files/rhino.png")) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/image-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/image-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "image"))
        [ NormalArg (Literal (String "/assets/files/tiger.jpg")) ])
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  image(source: "/assets/files/rhino.png"), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  image(source: "/assets/files/tiger.jpg"), 
diff --git a/test/typ/visualize/image-01.out b/test/typ/visualize/image-01.out
--- a/test/typ/visualize/image-01.out
+++ b/test/typ/visualize/image-01.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/image-01.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
-                                 "typ/visualize/image-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/image-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
+[ Comment
+, ParBreak
 , Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/image-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -57,7 +18,7 @@
 , SoftBreak
 , Code
     "typ/visualize/image-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -69,9 +30,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/image-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "image"))
        [ NormalArg (Literal (String "/assets/files/monkey.svg"))
@@ -81,9 +43,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/image-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg
@@ -99,8 +62,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  box(body: image(source: "/assets/files/rhino.png", 
@@ -110,11 +72,15 @@
                  box(body: image(height: 30.0pt, 
                                  source: "/assets/files/rhino.png")), 
                  parbreak(), 
+                 text(body: [
+]), 
                  image(fit: "stretch", 
                        height: 20.0pt, 
                        source: "/assets/files/monkey.svg", 
                        width: 100%), 
                  parbreak(), 
+                 text(body: [
+]), 
                  align(alignment: Axes(right, bottom), 
                        body: image(alt: "A tiger", 
                                    source: "/assets/files/tiger.jpg", 
diff --git a/test/typ/visualize/image-02.out b/test/typ/visualize/image-02.out
--- a/test/typ/visualize/image-02.out
+++ b/test/typ/visualize/image-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/image-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
-                                 "typ/visualize/image-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/image-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/image-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 50.0 Pt))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/visualize/image-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
diff --git a/test/typ/visualize/image-03.out b/test/typ/visualize/image-03.out
--- a/test/typ/visualize/image-03.out
+++ b/test/typ/visualize/image-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/image-03.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
-                                 "typ/visualize/image-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/image-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/image-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/visualize/image-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "image"))
        [ NormalArg (Literal (String "/assets/files/rhino.png")) ])
diff --git a/test/typ/visualize/image-04.out b/test/typ/visualize/image-04.out
--- a/test/typ/visualize/image-04.out
+++ b/test/typ/visualize/image-04.out
@@ -1,50 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/image-04.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
-                                 "typ/visualize/image-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/image-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Text "A"
 , Space
 , Code
     "typ/visualize/image-04.typ"
-    ( line 3 , column 4 )
+    ( line 2 , column 4 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -61,8 +22,7 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [A ]), 
+A ]), 
                  box(body: image(height: 1.0cm, 
                                  source: "/assets/files/tiger.jpg", 
                                  width: 80%)), 
diff --git a/test/typ/visualize/image-05.out b/test/typ/visualize/image-05.out
--- a/test/typ/visualize/image-05.out
+++ b/test/typ/visualize/image-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/image-05.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
-                                 "typ/visualize/image-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/image-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/image-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "image"))
        [ NormalArg (Literal (String "/assets/files/pattern.svg")) ])
diff --git a/test/typ/visualize/line-00.out b/test/typ/visualize/line-00.out
--- a/test/typ/visualize/line-00.out
+++ b/test/typ/visualize/line-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/visualize/line-00.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
-                                 "typ/visualize/line-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/line-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/line-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/line-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -105,7 +65,7 @@
 , Space
 , Code
     "typ/visualize/line-00.typ"
-    ( line 8 , column 11 )
+    ( line 7 , column 11 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -117,7 +77,7 @@
 , ParBreak
 , Code
     "typ/visualize/line-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg
@@ -131,8 +91,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  box(body: { place(body: line(end: (0.4em, 
                                                     0.0pt), 
diff --git a/test/typ/visualize/line-01.out b/test/typ/visualize/line-01.out
--- a/test/typ/visualize/line-01.out
+++ b/test/typ/visualize/line-01.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/line-01.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
-                                 "typ/visualize/line-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/line-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/visualize/line-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg
@@ -55,14 +15,14 @@
 , SoftBreak
 , Code
     "typ/visualize/line-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "stroke") (Ident (Identifier "white")) ])
 , ParBreak
 , Code
     "typ/visualize/line-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (LetFunc
        (Identifier "star")
        [ NormalParam (Identifier "size")
@@ -76,7 +36,7 @@
               [ SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 8 , column 4 )
+                  ( line 7 , column 4 )
                   (Set
                      (Ident (Identifier "text"))
                      [ KeyValArg (Identifier "spacing") (Literal (Numeric 0.0 Percent))
@@ -84,28 +44,28 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 9 , column 4 )
+                  ( line 8 , column 4 )
                   (Set
                      (Ident (Identifier "line"))
                      [ SpreadArg (Ident (Identifier "args")) ])
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 10 , column 4 )
+                  ( line 9 , column 4 )
                   (Set
                      (Ident (Identifier "align"))
                      [ NormalArg (Ident (Identifier "left")) ])
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 11 , column 4 )
+                  ( line 10 , column 4 )
                   (FuncCall
                      (Ident (Identifier "v"))
                      [ NormalArg (Literal (Numeric 30.0 Percent)) ])
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 12 , column 4 )
+                  ( line 11 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -123,7 +83,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 13 , column 4 )
+                  ( line 12 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -143,7 +103,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 14 , column 4 )
+                  ( line 13 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -162,7 +122,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 15 , column 4 )
+                  ( line 14 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -180,7 +140,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 16 , column 4 )
+                  ( line 15 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -201,7 +161,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 17 , column 4 )
+                  ( line 16 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -220,7 +180,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 18 , column 4 )
+                  ( line 17 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -240,7 +200,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 19 , column 4 )
+                  ( line 18 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -260,7 +220,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 20 , column 4 )
+                  ( line 19 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -280,7 +240,7 @@
               , SoftBreak
               , Code
                   "typ/visualize/line-01.typ"
-                  ( line 21 , column 4 )
+                  ( line 20 , column 4 )
                   (FuncCall
                      (Ident (Identifier "place"))
                      [ NormalArg
@@ -302,7 +262,7 @@
 , ParBreak
 , Code
     "typ/visualize/line-01.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "center"))
@@ -328,10 +288,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  text(body: [
 ]), 
                  parbreak(), 
diff --git a/test/typ/visualize/path-00.out b/test/typ/visualize/path-00.out
--- a/test/typ/visualize/path-00.out
+++ b/test/typ/visualize/path-00.out
@@ -2,46 +2,6 @@
 [ Code
     "typ/visualize/path-00.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
-                                 "typ/visualize/path-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/path-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/path-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 200.0 Pt))
@@ -50,7 +10,7 @@
 , SoftBreak
 , Code
     "typ/visualize/path-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg
@@ -239,8 +199,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  table(align: Axes(center, horizon), 
                        children: (path(closed: true, 
diff --git a/test/typ/visualize/polygon-00.out b/test/typ/visualize/polygon-00.out
--- a/test/typ/visualize/polygon-00.out
+++ b/test/typ/visualize/polygon-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/visualize/polygon-00.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
-                                 "typ/visualize/polygon-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/polygon-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/polygon-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 50.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "polygon"))
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 0.75 Pt))
@@ -56,14 +16,15 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall (Ident (Identifier "polygon")) [])
 , SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -75,7 +36,7 @@
 , SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -92,7 +53,7 @@
 , ParBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -114,7 +75,7 @@
 , SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -146,7 +107,7 @@
 , SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 16 , column 2 )
+    ( line 15 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ KeyValArg (Identifier "stroke") (Literal None)
@@ -169,7 +130,7 @@
 , SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 3.0 Pt))
@@ -192,9 +153,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -215,9 +177,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 23 , column 2 )
+    ( line 22 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -243,9 +206,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/polygon-00.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
@@ -279,9 +243,9 @@
 --- evaluated ---
 document(body: { text(body: [
 ]), 
+                 parbreak(), 
                  text(body: [
 ]), 
-                 parbreak(), 
                  polygon(fill: rgb(0%,45%,85%,100%), 
                          stroke: 0.75pt, 
                          vertices: ()), 
@@ -326,12 +290,16 @@
                                     (0.0pt, 10.0pt), 
                                     (10.0pt, 10.0pt))), 
                  parbreak(), 
+                 text(body: [
+]), 
                  polygon(fill: rgb(0%,45%,85%,100%), 
                          stroke: 0.75pt, 
                          vertices: ((0.0pt, 0.0pt), 
                                     (100%, 5.0pt), 
                                     (50%, 10.0pt))), 
                  parbreak(), 
+                 text(body: [
+]), 
                  polygon(fill: rgb(0%,45%,85%,100%), 
                          stroke: 0.75pt, 
                          vertices: ((0.0pt, 5.0pt), 
@@ -339,6 +307,8 @@
                                     (0.0pt, 10.0pt), 
                                     (5.0pt, 15.0pt))), 
                  parbreak(), 
+                 text(body: [
+]), 
                  polygon(fill: rgb(0%,45%,85%,100%), 
                          stroke: 0.75pt, 
                          vertices: ((0.0pt, 10.0pt), 
diff --git a/test/typ/visualize/shape-aspect-00.out b/test/typ/visualize/shape-aspect-00.out
--- a/test/typ/visualize/shape-aspect-00.out
+++ b/test/typ/visualize/shape-aspect-00.out
@@ -1,49 +1,11 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-aspect-00.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
-                                 "typ/visualize/shape-aspect-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-aspect-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
 , Comment
-, Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-aspect-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 120.0 Pt))
@@ -52,14 +14,14 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg (Ident (Identifier "bottom")) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (Let
        (BasicBind (Just (Identifier "centered")))
        (FuncCall
@@ -71,7 +33,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
@@ -110,6 +72,8 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
+]), 
+                 text(body: [
 ]), 
                  text(body: [
 ]), 
diff --git a/test/typ/visualize/shape-aspect-01.out b/test/typ/visualize/shape-aspect-01.out
--- a/test/typ/visualize/shape-aspect-01.out
+++ b/test/typ/visualize/shape-aspect-01.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-aspect-01.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
-                                 "typ/visualize/shape-aspect-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-aspect-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-aspect-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ NormalArg (Literal (Numeric 8.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -64,7 +25,7 @@
                   , Space
                   , Code
                       "typ/visualize/shape-aspect-01.typ"
-                      ( line 5 , column 15 )
+                      ( line 4 , column 15 )
                       (FuncCall
                          (Ident (Identifier "align"))
                          [ NormalArg
@@ -83,7 +44,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/visualize/shape-aspect-02.out b/test/typ/visualize/shape-aspect-02.out
--- a/test/typ/visualize/shape-aspect-02.out
+++ b/test/typ/visualize/shape-aspect-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-aspect-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
-                                 "typ/visualize/shape-aspect-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-aspect-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-aspect-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
diff --git a/test/typ/visualize/shape-aspect-03.out b/test/typ/visualize/shape-aspect-03.out
--- a/test/typ/visualize/shape-aspect-03.out
+++ b/test/typ/visualize/shape-aspect-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-aspect-03.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
-                                 "typ/visualize/shape-aspect-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-aspect-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-aspect-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 20.0 Pt))
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
diff --git a/test/typ/visualize/shape-aspect-04.out b/test/typ/visualize/shape-aspect-04.out
--- a/test/typ/visualize/shape-aspect-04.out
+++ b/test/typ/visualize/shape-aspect-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-aspect-04.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
-                                 "typ/visualize/shape-aspect-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-aspect-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-aspect-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 120.0 Pt))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
diff --git a/test/typ/visualize/shape-aspect-05.out b/test/typ/visualize/shape-aspect-05.out
--- a/test/typ/visualize/shape-aspect-05.out
+++ b/test/typ/visualize/shape-aspect-05.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-aspect-05.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
-                                 "typ/visualize/shape-aspect-05.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-aspect-05.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-aspect-05.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 40.0 Pt))
@@ -52,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-05.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
@@ -60,7 +21,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-aspect-05.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
diff --git a/test/typ/visualize/shape-circle-00.out b/test/typ/visualize/shape-circle-00.out
--- a/test/typ/visualize/shape-circle-00.out
+++ b/test/typ/visualize/shape-circle-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-circle-00.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
-                                 "typ/visualize/shape-circle-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-circle-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-circle-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg (FuncCall (Ident (Identifier "circle")) []) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/visualize/shape-circle-01.out b/test/typ/visualize/shape-circle-01.out
--- a/test/typ/visualize/shape-circle-01.out
+++ b/test/typ/visualize/shape-circle-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-circle-01.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
-                                 "typ/visualize/shape-circle-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-circle-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-circle-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "circle"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt)) ])
@@ -56,7 +17,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "circle"))
        [ KeyValArg
@@ -93,7 +54,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-01.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "circle"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -126,7 +87,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-01.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "circle"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -140,7 +101,7 @@
                   [ SoftBreak
                   , Code
                       "typ/visualize/shape-circle-01.typ"
-                      ( line 20 , column 6 )
+                      ( line 19 , column 6 )
                       (Set
                          (Ident (Identifier "text"))
                          [ NormalArg (Literal (Numeric 8.0 Pt)) ])
@@ -174,7 +135,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-01.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (FuncCall
        (Ident (Identifier "circle"))
        [ KeyValArg (Identifier "stroke") (Ident (Identifier "black"))
diff --git a/test/typ/visualize/shape-circle-02.out b/test/typ/visualize/shape-circle-02.out
--- a/test/typ/visualize/shape-circle-02.out
+++ b/test/typ/visualize/shape-circle-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-circle-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
-                                 "typ/visualize/shape-circle-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-circle-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-circle-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 40.0 Pt))
diff --git a/test/typ/visualize/shape-circle-03.out b/test/typ/visualize/shape-circle-03.out
--- a/test/typ/visualize/shape-circle-03.out
+++ b/test/typ/visualize/shape-circle-03.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-circle-03.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
-                                 "typ/visualize/shape-circle-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-circle-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-circle-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "white")) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Show
        Nothing
        (FuncCall
@@ -66,7 +27,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "align"))
        [ NormalArg
@@ -75,7 +36,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-circle-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
diff --git a/test/typ/visualize/shape-ellipse-00.out b/test/typ/visualize/shape-ellipse-00.out
--- a/test/typ/visualize/shape-ellipse-00.out
+++ b/test/typ/visualize/shape-ellipse-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-ellipse-00.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
-                                 "typ/visualize/shape-ellipse-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-ellipse-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-ellipse-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall (Ident (Identifier "ellipse")) [])
 , ParBreak
 ]
diff --git a/test/typ/visualize/shape-ellipse-01.out b/test/typ/visualize/shape-ellipse-01.out
--- a/test/typ/visualize/shape-ellipse-01.out
+++ b/test/typ/visualize/shape-ellipse-01.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/visualize/shape-ellipse-01.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
-                                 "typ/visualize/shape-ellipse-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-ellipse-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/shape-ellipse-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-ellipse-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "ellipse"))
        [ KeyValArg (Identifier "inset") (Literal (Numeric 0.0 Pt)) ])
@@ -68,7 +28,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-ellipse-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 3.0 Cm))
@@ -120,7 +80,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-ellipse-01.typ"
-    ( line 17 , column 2 )
+    ( line 16 , column 2 )
     (FuncCall
        (Ident (Identifier "ellipse"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
@@ -132,7 +92,7 @@
            [ SoftBreak
            , Code
                "typ/visualize/shape-ellipse-01.typ"
-               ( line 18 , column 4 )
+               ( line 17 , column 4 )
                (Set
                   (Ident (Identifier "text"))
                   [ NormalArg (Literal (Numeric 8.0 Pt)) ])
@@ -162,7 +122,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-ellipse-01.typ"
-    ( line 24 , column 2 )
+    ( line 23 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -185,8 +145,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  text(body: [Rect in ellipse in fixed rect.
diff --git a/test/typ/visualize/shape-fill-stroke-00.out b/test/typ/visualize/shape-fill-stroke-00.out
--- a/test/typ/visualize/shape-fill-stroke-00.out
+++ b/test/typ/visualize/shape-fill-stroke-00.out
@@ -3,46 +3,6 @@
     "typ/visualize/shape-fill-stroke-00.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
-                                 "typ/visualize/shape-fill-stroke-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-fill-stroke-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/shape-fill-stroke-00.typ"
-    ( line 2 , column 2 )
-    (Let
        (BasicBind (Just (Identifier "variant")))
        (FuncCall
           (FieldAccess
@@ -53,13 +13,13 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Let
        (BasicBind (Just (Identifier "items")))
        (For
           (DestructuringBind
-             [ Simple (Just (Identifier "i"))
-             , Simple (Just (Identifier "item"))
+             [ Simple (BasicBind (Just (Identifier "i")))
+             , Simple (BasicBind (Just (Identifier "item")))
              ])
           (FuncCall
              (FieldAccess
@@ -139,7 +99,7 @@
                            , BlockArg
                                [ Code
                                    "typ/visualize/shape-fill-stroke-00.typ"
-                                   ( line 17 , column 20 )
+                                   ( line 16 , column 20 )
                                    (Plus (Ident (Identifier "i")) (Literal (Int 1)))
                                , Text "."
                                ]
@@ -151,7 +111,7 @@
 , ParBreak
 , Code
     "typ/visualize/shape-fill-stroke-00.typ"
-    ( line 20 , column 2 )
+    ( line 19 , column 2 )
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
@@ -171,8 +131,6 @@
 ]
 --- evaluated ---
 document(body: { text(body: [
-]), 
-                 text(body: [
 ]), 
                  parbreak(), 
                  grid(children: (align(alignment: horizon, 
diff --git a/test/typ/visualize/shape-fill-stroke-01.out b/test/typ/visualize/shape-fill-stroke-01.out
--- a/test/typ/visualize/shape-fill-stroke-01.out
+++ b/test/typ/visualize/shape-fill-stroke-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-fill-stroke-01.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
-                                 "typ/visualize/shape-fill-stroke-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-fill-stroke-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (LetFunc
        (Identifier "sq")
        [ SinkParam (Just (Identifier "args")) ]
@@ -58,52 +19,52 @@
 , ParBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (Set
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "stroke") (Literal None) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall (Ident (Identifier "sq")) [])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (Set
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "stroke") (Literal Auto) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall (Ident (Identifier "sq")) [])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "sq"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "teal")) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "sq"))
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 2.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "sq"))
        [ KeyValArg (Identifier "stroke") (Ident (Identifier "blue")) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "sq"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "teal"))
@@ -112,7 +73,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-01.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "sq"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "teal"))
diff --git a/test/typ/visualize/shape-fill-stroke-02.out b/test/typ/visualize/shape-fill-stroke-02.out
--- a/test/typ/visualize/shape-fill-stroke-02.out
+++ b/test/typ/visualize/shape-fill-stroke-02.out
@@ -1,62 +1,23 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-fill-stroke-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
-                                 "typ/visualize/shape-fill-stroke-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-fill-stroke-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-fill-stroke-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 4.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (Set
        (Ident (Identifier "text"))
        [ KeyValArg (Identifier "font") (Literal (String "Roboto")) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-fill-stroke-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg
diff --git a/test/typ/visualize/shape-rect-00.out b/test/typ/visualize/shape-rect-00.out
--- a/test/typ/visualize/shape-rect-00.out
+++ b/test/typ/visualize/shape-rect-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-rect-00.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
-                                 "typ/visualize/shape-rect-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-rect-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-rect-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall (Ident (Identifier "rect")) [])
 , ParBreak
 ]
diff --git a/test/typ/visualize/shape-rect-01.out b/test/typ/visualize/shape-rect-01.out
--- a/test/typ/visualize/shape-rect-01.out
+++ b/test/typ/visualize/shape-rect-01.out
@@ -2,54 +2,15 @@
 [ Code
     "typ/visualize/shape-rect-01.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
-                                 "typ/visualize/shape-rect-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-rect-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/shape-rect-01.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 150.0 Pt)) ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
@@ -57,9 +18,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "block"))
        [ NormalArg
@@ -82,9 +44,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 2.0 Cm))
@@ -98,9 +61,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 18 , column 2 )
+    ( line 17 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "height") (Literal (Numeric 1.0 Cm))
@@ -114,10 +78,11 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Text "{"
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 21 , column 3 )
+    ( line 20 , column 3 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -135,7 +100,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 22 , column 3 )
+    ( line 21 , column 3 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -153,7 +118,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 23 , column 3 )
+    ( line 22 , column 3 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
@@ -171,9 +136,10 @@
 , Text "}"
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 26 , column 2 )
+    ( line 25 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
@@ -213,9 +179,10 @@
        ])
 , ParBreak
 , Comment
+, SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 40 , column 2 )
+    ( line 39 , column 2 )
     (Set
        (Ident (Identifier "rect"))
        [ KeyValArg
@@ -226,7 +193,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-rect-01.typ"
-    ( line 41 , column 2 )
+    ( line 40 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Percent))
@@ -241,27 +208,34 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
+document(body: { parbreak(), 
+                 text(body: [
 ]), 
-                 parbreak(), 
                  rect(body: text(body: [Textbox]), 
                       fill: rgb(18%,80%,25%,100%)), 
                  parbreak(), 
+                 text(body: [
+]), 
                  block(body: rect(fill: rgb(27%,70%,76%,100%), 
                                   height: 15.0pt, 
                                   stroke: (thickness: 2.0pt,
                                            color: rgb(13%,28%,58%,100%)))), 
                  parbreak(), 
+                 text(body: [
+]), 
                  rect(body: text(body: [Fixed and padded]), 
                       fill: rgb(58%,31%,83%,100%), 
                       width: 2.0cm), 
                  parbreak(), 
+                 text(body: [
+]), 
                  rect(body: text(body: [Topleft]), 
                       fill: rgb(45%,29%,92%,100%), 
                       height: 1.0cm, 
                       width: 100%), 
                  parbreak(), 
-                 text(body: [{]), 
+                 text(body: [
+{]), 
                  box(body: rect(fill: rgb(83%,80%,40%,100%), 
                                 height: 7.0pt, 
                                 width: 0.5in)), 
@@ -277,6 +251,8 @@
                                 width: 0.5in)), 
                  text(body: [}]), 
                  parbreak(), 
+                 text(body: [
+]), 
                  stack(children: (rect(radius: 60%, 
                                        width: 2.0cm), 
                                   rect(radius: (left: 10.0pt,
@@ -290,6 +266,8 @@
                        dir: ltr, 
                        spacing: 1.0fr), 
                  parbreak(), 
+                 text(body: [
+]), 
                  text(body: [
 ]), 
                  rect(fill: rgb(0%,100%,43%,100%), 
diff --git a/test/typ/visualize/shape-rounded-00.out b/test/typ/visualize/shape-rounded-00.out
--- a/test/typ/visualize/shape-rounded-00.out
+++ b/test/typ/visualize/shape-rounded-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-rounded-00.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
-                                 "typ/visualize/shape-rounded-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-rounded-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-rounded-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-rounded-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "radius") (Literal (Numeric 30.0 Pt)) ])
diff --git a/test/typ/visualize/shape-square-00.out b/test/typ/visualize/shape-square-00.out
--- a/test/typ/visualize/shape-square-00.out
+++ b/test/typ/visualize/shape-square-00.out
@@ -1,55 +1,16 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-square-00.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
-                                 "typ/visualize/shape-square-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-square-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-square-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg (FuncCall (Ident (Identifier "square")) []) ])
 , SoftBreak
 , Code
     "typ/visualize/shape-square-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "box"))
        [ NormalArg
diff --git a/test/typ/visualize/shape-square-01.out b/test/typ/visualize/shape-square-01.out
--- a/test/typ/visualize/shape-square-01.out
+++ b/test/typ/visualize/shape-square-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-square-01.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
-                                 "typ/visualize/shape-square-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-square-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-square-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern"))
@@ -50,7 +11,7 @@
            [ SoftBreak
            , Code
                "typ/visualize/shape-square-01.typ"
-               ( line 4 , column 4 )
+               ( line 3 , column 4 )
                (Set
                   (Ident (Identifier "text"))
                   [ KeyValArg (Identifier "fill") (Ident (Identifier "white"))
diff --git a/test/typ/visualize/shape-square-02.out b/test/typ/visualize/shape-square-02.out
--- a/test/typ/visualize/shape-square-02.out
+++ b/test/typ/visualize/shape-square-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-square-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
-                                 "typ/visualize/shape-square-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-square-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-square-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern"))
@@ -50,7 +11,7 @@
            [ SoftBreak
            , Code
                "typ/visualize/shape-square-02.typ"
-               ( line 4 , column 4 )
+               ( line 3 , column 4 )
                (FuncCall
                   (Ident (Identifier "rect"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 10.0 Pt))
@@ -60,7 +21,7 @@
            , SoftBreak
            , Code
                "typ/visualize/shape-square-02.typ"
-               ( line 5 , column 4 )
+               ( line 4 , column 4 )
                (FuncCall
                   (Ident (Identifier "rect"))
                   [ KeyValArg (Identifier "width") (Literal (Numeric 40.0 Percent))
diff --git a/test/typ/visualize/shape-square-03.out b/test/typ/visualize/shape-square-03.out
--- a/test/typ/visualize/shape-square-03.out
+++ b/test/typ/visualize/shape-square-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-square-03.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
-                                 "typ/visualize/shape-square-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-square-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-square-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 75.0 Pt))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-square-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
diff --git a/test/typ/visualize/shape-square-04.out b/test/typ/visualize/shape-square-04.out
--- a/test/typ/visualize/shape-square-04.out
+++ b/test/typ/visualize/shape-square-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/shape-square-04.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
-                                 "typ/visualize/shape-square-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/shape-square-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/shape-square-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 100.0 Pt))
@@ -51,7 +12,7 @@
 , SoftBreak
 , Code
     "typ/visualize/shape-square-04.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "square"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "green"))
diff --git a/test/typ/visualize/stroke-00.out b/test/typ/visualize/stroke-00.out
--- a/test/typ/visualize/stroke-00.out
+++ b/test/typ/visualize/stroke-00.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/stroke-00.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
-                                 "typ/visualize/stroke-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/stroke-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -51,13 +12,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -66,13 +27,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -83,13 +44,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -104,13 +65,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-00.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
diff --git a/test/typ/visualize/stroke-01.out b/test/typ/visualize/stroke-01.out
--- a/test/typ/visualize/stroke-01.out
+++ b/test/typ/visualize/stroke-01.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/stroke-01.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
-                                 "typ/visualize/stroke-01.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/stroke-01.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/stroke-01.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "line"))
        [ KeyValArg
@@ -58,20 +19,20 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-01.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-01.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-01.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -80,13 +41,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-01.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-01.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
diff --git a/test/typ/visualize/stroke-02.out b/test/typ/visualize/stroke-02.out
--- a/test/typ/visualize/stroke-02.out
+++ b/test/typ/visualize/stroke-02.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/stroke-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
-                                 "typ/visualize/stroke-02.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/stroke-02.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/stroke-02.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 20.0 Pt))
@@ -52,13 +13,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-02.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-02.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 20.0 Pt))
@@ -79,13 +40,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-02.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-02.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 20.0 Pt))
diff --git a/test/typ/visualize/stroke-03.out b/test/typ/visualize/stroke-03.out
--- a/test/typ/visualize/stroke-03.out
+++ b/test/typ/visualize/stroke-03.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/stroke-03.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
-                                 "typ/visualize/stroke-03.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/stroke-03.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -61,13 +22,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -90,13 +51,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -125,13 +86,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 8 , column 2 )
+    ( line 7 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
@@ -146,13 +107,13 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "v")) [ NormalArg (Literal (Numeric 3.0 Pt)) ])
 , SoftBreak
 , Code
     "typ/visualize/stroke-03.typ"
-    ( line 11 , column 2 )
+    ( line 10 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
diff --git a/test/typ/visualize/stroke-04.out b/test/typ/visualize/stroke-04.out
--- a/test/typ/visualize/stroke-04.out
+++ b/test/typ/visualize/stroke-04.out
@@ -1,48 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/stroke-04.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
-                                 "typ/visualize/stroke-04.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/stroke-04.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
+[ Comment
 , SoftBreak
-, Comment
 , Code
     "typ/visualize/stroke-04.typ"
-    ( line 3 , column 2 )
+    ( line 2 , column 2 )
     (FuncCall
        (Ident (Identifier "stack"))
        [ KeyValArg (Identifier "dir") (Ident (Identifier "ltr"))
diff --git a/test/typ/visualize/stroke-07.out b/test/typ/visualize/stroke-07.out
--- a/test/typ/visualize/stroke-07.out
+++ b/test/typ/visualize/stroke-07.out
@@ -1,49 +1,9 @@
 --- parse tree ---
-[ Code
-    "typ/visualize/stroke-07.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
-                                 "typ/visualize/stroke-07.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/stroke-07.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Comment
-, SoftBreak
+[ Comment
+, ParBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 10.0 Pt))
@@ -53,7 +13,7 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 5 , column 2 )
+    ( line 4 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 10.0 Pt))
@@ -63,7 +23,7 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 6 , column 2 )
+    ( line 5 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 10.0 Pt))
@@ -74,7 +34,7 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 7 , column 2 )
+    ( line 6 , column 2 )
     (FuncCall
        (Ident (Identifier "rect"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 10.0 Pt))
@@ -87,7 +47,7 @@
 , ParBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 9 , column 2 )
+    ( line 8 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 30.0 Pt))
@@ -96,7 +56,7 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 10 , column 2 )
+    ( line 9 , column 2 )
     (FuncCall
        (Ident (Identifier "line"))
        [ KeyValArg (Identifier "length") (Literal (Numeric 30.0 Pt))
@@ -115,7 +75,7 @@
 , ParBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 12 , column 2 )
+    ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -126,7 +86,7 @@
 , SoftBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 13 , column 2 )
+    ( line 12 , column 2 )
     (FuncCall
        (Ident (Identifier "table"))
        [ KeyValArg (Identifier "columns") (Literal (Int 2))
@@ -137,7 +97,7 @@
 , ParBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 15 , column 2 )
+    ( line 14 , column 2 )
     (FuncCall
        (Ident (Identifier "path"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -199,7 +159,7 @@
 , ParBreak
 , Code
     "typ/visualize/stroke-07.typ"
-    ( line 25 , column 2 )
+    ( line 24 , column 2 )
     (FuncCall
        (Ident (Identifier "path"))
        [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
@@ -261,10 +221,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 text(body: [
-]), 
+document(body: { parbreak(), 
                  rect(height: 10.0pt, 
                       stroke: none, 
                       width: 10.0pt), 
diff --git a/test/typ/visualize/svg-text-00.out b/test/typ/visualize/svg-text-00.out
--- a/test/typ/visualize/svg-text-00.out
+++ b/test/typ/visualize/svg-text-00.out
@@ -2,53 +2,13 @@
 [ Code
     "typ/visualize/svg-text-00.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
-                                 "typ/visualize/svg-text-00.typ"
-                                 ( line 1 , column 47 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "x")) ])
-                             , Space
-                             , Text "/"
-                             , Text "="
-                             , Space
-                             , Code
-                                 "typ/visualize/svg-text-00.typ"
-                                 ( line 1 , column 59 )
-                                 (FuncCall
-                                    (Ident (Identifier "repr"))
-                                    [ NormalArg (Ident (Identifier "y")) ])
-                             , Text ")"
-                             ])
-                      )
-                    ]
-                ]))))
-, SoftBreak
-, Code
-    "typ/visualize/svg-text-00.typ"
-    ( line 2 , column 2 )
     (Set
        (Ident (Identifier "page"))
        [ KeyValArg (Identifier "width") (Literal (Numeric 250.0 Pt)) ])
 , ParBreak
 , Code
     "typ/visualize/svg-text-00.typ"
-    ( line 4 , column 2 )
+    ( line 3 , column 2 )
     (FuncCall
        (Ident (Identifier "figure"))
        [ NormalArg
@@ -64,9 +24,7 @@
 , ParBreak
 ]
 --- evaluated ---
-document(body: { text(body: [
-]), 
-                 parbreak(), 
+document(body: { parbreak(), 
                  figure(body: image(source: "/assets/files/diagram.svg"), 
                         caption: text(body: [A textful diagram])), 
                  parbreak() })
diff --git a/typst.cabal b/typst.cabal
--- a/typst.cabal
+++ b/typst.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               typst
-version:            0.8.1
+version:            0.9
 synopsis:           Parsing and evaluating typst syntax.
 description:        A library for parsing and evaluating typst syntax.
                     Typst (<https://typst.app>) is a document layout and