diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,78 @@
 # Revision history for typst-hs
 
-## 0.1.0.0 -- YYYY-mm-dd
+## 0.3.0.0
+
+  * We now target typst 0.6.
+
+  * `joinVals` - fall back on repr when as a fallback in joining values.
+
+  * Fix a spacing issue in parsing code inside equations (#6).
+
+  * Fix `#include`. It wasn't including content!
+
+  * Fix issue with math parsing of factorial (#5).
+
+  * Handle "style" by evaluating it immediately, rather than passing it through
+    as an element in content (#4).
+
+  * Add `outline.entry`.
+
+  * Allow identifiers to start with `_`.
+
+  * Fix bug in parsing consecutive '#' expressions in math function (#2).
+
+  * Fix bugs in makeLiteralRE.
+
+  * Give namedArg an argument for a default value.
+    This avoids spurious parse error messages.
+
+  * Change return value of dictionary insert method to none.
+
+  * Improve #panic output.
+
+  * [API change]:  Add Spreadable type in Typst.Syntax.
+    Use this for Dict and Array values.
+
+  * Handle package lookup, assuming packages are either local or cached.
+
+  * API change: combine IO operations into Operations structure.
+    `evaluateTypst` now takes a single Operations dictionary instead
+    of separate `loadBytes` and `currentUTCTime` functions. And
+    Operations now also includes functions to query environment
+    variables and check directories.  This will be needed for
+    package lookup.
+
+  * Depend on typst-symbols 0.1.2.
+
+  * Make factorial take priority over fraction.
+
+## 0.2.0.0
+
+  * We now target typst 0.5.
+
+  * Implement methods for datetime.
+
+  * Implement `base` parameter on str.
+
+  * Add `datetime` constructor.
+
+  * Implement `datetime.today`.
+
+  * Add VDateTime type.
+
+  * Implement `fields` method on content.
+
+  * Add `display`, `inline`, `script`, `sscript` to math module.
+
+  * Add `str.to-unicode`, `str.from-unicode`.
+
+  * Add `calc.ln` and `calc.exp`.
+
+  * Remove deprecated `calc.mod`.
+
+  * Depend on typst-symbols 0.1.1.
+
+
+## 0.1.0.0
 
 * First version. Released on an unsuspecting world.
diff --git a/app/Main.hs b/app/Main.hs
--- a/app/Main.hs
+++ b/app/Main.hs
@@ -8,13 +8,15 @@
 import Data.Maybe (fromMaybe)
 import qualified Data.Text.IO as TIO
 import System.Environment (getArgs)
+import System.Directory (doesFileExist)
+import System.Environment (lookupEnv)
 import System.Exit
 import System.IO (hPutStrLn, stderr)
 import System.Timeout (timeout)
 import Text.Read (readMaybe)
 import Text.Show.Pretty (pPrint)
 import Typst (evaluateTypst, parseTypst)
-import Typst.Types (Val (..), repr)
+import Typst.Types (Val (..), repr, Operations(..))
 import Data.Time (getCurrentTime)
 
 data Opts = Opts
@@ -50,6 +52,14 @@
     go (Nothing, opts) f = pure (Just f, opts)
     go _ _ = err $ "Only one file can be specified as input."
 
+operations :: Operations IO
+operations = Operations
+  { loadBytes = BS.readFile
+  , currentUTCTime = getCurrentTime
+  , lookupEnvVar = lookupEnv
+  , checkExistence = doesFileExist
+  }
+
 main :: IO ()
 main =
   () <$ do
@@ -70,7 +80,7 @@
             when (optShowParse opts || showAll) $ do
               when showAll $ putStrLn "--- parse tree ---"
               pPrint parseResult
-            result <- evaluateTypst BS.readFile getCurrentTime "stdin" parseResult
+            result <- evaluateTypst operations "stdin" parseResult
             case result of
               Left e -> err $ show e
               Right cs -> do
diff --git a/src/Typst/Evaluate.hs b/src/Typst/Evaluate.hs
--- a/src/Typst/Evaluate.hs
+++ b/src/Typst/Evaluate.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE LambdaCase #-}
@@ -14,18 +15,18 @@
 
 import Control.Monad (MonadPlus (mplus), foldM, foldM_)
 import Control.Monad.State (MonadTrans (lift))
-import qualified Data.ByteString as BS
 import Data.List (intersperse, sortOn)
 import qualified Data.Map as M
 import qualified Data.Map.Ordered as OM
-import Data.Maybe (isJust)
+import Data.Maybe (isJust, fromMaybe)
 import Data.Sequence (Seq)
 import qualified Data.Sequence as Seq
 import qualified Data.Set as Set
 import Data.Text (Text)
 import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
 import qualified Data.Vector as V
-import System.FilePath (replaceFileName, takeBaseName)
+import System.FilePath (replaceFileName, takeBaseName, takeDirectory, (</>))
 import Text.Parsec
 import Typst.Bind (destructuringBind)
 import Typst.Methods (getMethod)
@@ -36,7 +37,7 @@
 import Typst.Syntax
 import Typst.Types
 import Typst.Util (makeFunction, nthArg)
-import Data.Time (UTCTime)
+import qualified Toml as Toml
 
 -- import Debug.Trace
 
@@ -44,20 +45,19 @@
 -- replacing it with content.
 evaluateTypst ::
   Monad m =>
-  -- | Function to read a file
-  (FilePath -> m BS.ByteString) ->
-  -- | Function to get current UTCTime
-  m UTCTime ->
+  -- | Dictionary of functions for IO operations
+  Operations m ->
   -- | Path of parsed content
   FilePath ->
   -- | Markup produced by 'parseTypst'
   [Markup] ->
   m (Either ParseError (Seq Content))
-evaluateTypst loadBytes currentUTCTime =
+evaluateTypst operations fp =
   runParserT
     (mconcat <$> many pContent <* eof)
-    initialEvalState { evalLoadBytes = loadBytes
-                     , evalCurrentUTCTime = currentUTCTime}
+    initialEvalState { evalOperations = operations,
+                       evalPackageRoot = takeDirectory fp }
+    fp
 
 initialEvalState :: EvalState m
 initialEvalState =
@@ -443,13 +443,34 @@
             )
             (VNone, False)
             exprs
-    Array e -> VArray . V.fromList <$> mapM evalExpr e
+    Array es -> VArray <$> foldM
+           ( \xs x ->
+               case x of
+                 Spr y -> do
+                   val <- evalExpr y
+                   case val of
+                     VArray ys -> pure (xs <> ys)
+                     _ -> fail $ "Could not spread " <> show (valType val) <>
+                                 " into array"
+                 Reg e -> do
+                   val <- evalExpr e
+                   pure (V.snoc xs val ) )
+           []
+           es
     Dict items ->
       VDict
         <$> foldM
-          ( \m (k, e) -> do
-              val <- evalExpr e
-              pure $ m OM.|> (k, val)
+          ( \m v -> do
+              case v of
+                Reg (k, e) -> do
+                  val <- evalExpr e
+                  pure $ m OM.|> (k, val)
+                Spr y -> do
+                  val <- evalExpr y
+                  case val of
+                    VDict m' -> pure (m' OM.|<> m)
+                    _ -> fail $ "Could not spread " <> show (valType val) <>
+                                " into dictionary"
           )
           OM.empty
           items
@@ -784,7 +805,7 @@
       argval <- evalExpr e
       (modid, modmap) <-
         case argval of
-          VString t -> loadModule t
+          VString t -> snd <$> loadModule t
           VModule i m -> pure (i, m)
           VFunction (Just i) m _ -> pure (i, m)
           VFunction Nothing m _ -> pure ("anonymous", m)
@@ -802,9 +823,10 @@
     Include e -> do
       argval <- evalExpr e
       case argval of
-        VString t -> loadModule t >>= importModule . snd
+        VString t -> do
+          (cs, _) <- loadModule t
+          pure $ VContent cs
         _ -> fail "Include requires a path"
-      pure VNone
 
 toFunction ::
   Monad m =>
@@ -866,31 +888,99 @@
           pure res
   pure fn
 
-loadModule :: Monad m => Text -> MP m (Identifier, M.Map Identifier Val)
+findPackageEntryPoint :: Monad m => Text -> MP m FilePath
+findPackageEntryPoint modname = do
+  let (namespace, rest) = break (=='/') (drop 1 $ T.unpack modname)
+  let (name, rest') = break (==':') $ drop 1 rest
+  let version = drop 1 rest'
+  operations <- evalOperations <$> getState
+  let getEnv var = do
+        mbv <- lift $ lookupEnvVar operations var
+        case mbv of
+          Just v -> pure v
+          Nothing -> fail (var <> " not defined")
+#ifdef __MACOS__
+  homeDir <- getEnv "HOME"
+  let localDir = homeDir </> "Library" </> "Application Support" </> "typst"
+  let cacheDir = homeDir </> "Library" </> "Caches" </> "typst"
+#elif __WINDOWS__
+  appDataDir <- getEnv "APPDATA"
+  let localDir = appDataDir </> "typst"
+  localAppDataDir <- getEnv "LOCALAPPDATA"
+  let cacheDir = localAppDataDir </> "typst"
+#else
+  homeDir <- getEnv "HOME"
+  dataDir <- lift (lookupEnvVar operations "XDG_DATA_HOME") >>=
+               maybe (pure (homeDir </> ".local" </> "share")) pure
+  cacheDir' <- lift (lookupEnvVar operations "XDG_CACHE_HOME") >>=
+               maybe (pure (homeDir </> ".cache")) pure
+  let localDir = dataDir </> "typst"
+  let cacheDir = cacheDir' </> "typst"
+#endif
+  let subpath = "packages" </> namespace </> (name <> "-" <> version)
+  inLocal <- lift $ checkExistence operations (localDir </> subpath </> "typst.toml")
+  tomlPath <-
+     if inLocal
+        then pure (localDir </> subpath </> "typst.toml")
+        else do
+          inCache <- lift $ checkExistence operations (cacheDir </> subpath </> "typst.toml")
+          if inCache
+             then pure (cacheDir </> subpath </> "typst.toml")
+             else fail $ "Could not find package in local packages or cache. Looked in\n" ++
+                    (localDir </> subpath) ++ "\n" ++ (cacheDir </> subpath) ++
+                    "\nCompile with typst compile to bring the package into your local cache."
+             -- TODO? fetch from CDN if not present in cache?
+  tomlString <- T.unpack . TE.decodeUtf8 <$> lift (loadBytes operations tomlPath)
+  case Toml.parse tomlString of
+    Left e -> fail e
+    Right toptbl ->
+      case M.lookup "package" toptbl of
+        Just (Toml.Table tbl) ->
+          case M.lookup "entrypoint" tbl of
+            Just (Toml.String f) -> pure $ replaceFileName tomlPath f
+            _ -> fail "Could not find entrypoint"
+        _ -> fail "Could not find [package] table"
+
+loadModule :: Monad m => Text
+           -> MP m (Seq Content, (Identifier, M.Map Identifier Val))
 loadModule modname = do
   pos <- getPosition
-  let fp = replaceFileName (sourceName pos) (T.unpack modname)
+  (fp, mbPackageRoot) <-
+        if T.take 1 modname == "@"
+           then do
+            fp' <- findPackageEntryPoint modname
+            pure (fp', Just (takeDirectory fp'))
+           else if T.take 1 modname == "/" -- refers to path relative to package root
+                then do
+                  packageRoot <- evalPackageRoot <$> getState
+                  pure (packageRoot </> drop 1 (T.unpack modname), Nothing)
+                else pure (replaceFileName (sourceName pos) (T.unpack modname), Nothing)
   let modid = Identifier (T.pack $ takeBaseName fp)
   txt <- loadFileText fp
   case parseTypst fp txt of
     Left err -> fail $ show err
     Right ms -> do
-      loadBytes <- evalLoadBytes <$> getState
+      operations <- evalOperations <$> getState
       res <-
         lift $
           runParserT
-            ( inBlock BlockScope $ -- add new identifiers list
-                many pContent *> eof *> getState
+            ( inBlock BlockScope $ do -- add new identifiers list
+                cs <- mconcat <$> many pContent
+                eof
+                s <- getState
+                pure (cs, s)
             )
-            initialEvalState {evalLoadBytes = loadBytes}
+            initialEvalState{evalOperations = operations,
+                             evalPackageRoot = fromMaybe (evalPackageRoot initialEvalState)
+                                                   mbPackageRoot }
             fp
             ms
       case res of
         Left err' -> fail $ show err'
-        Right st ->
+        Right (contents, st) ->
           case evalIdentifiers st of
             [] -> fail "Empty evalIdentifiers in module!"
-            ((_, m) : _) -> pure (modid, m)
+            ((_, m) : _) -> pure (contents, (modid, m))
 
 importModule :: Monad m => M.Map Identifier Val -> MP m ()
 importModule m = updateState $ \st ->
diff --git a/src/Typst/Methods.hs b/src/Typst/Methods.hs
--- a/src/Typst/Methods.hs
+++ b/src/Typst/Methods.hs
@@ -7,8 +7,8 @@
 
 module Typst.Methods
   ( getMethod,
-    applyPureFunction,
     formatNumber,
+    applyPureFunction
   )
 where
 
@@ -25,7 +25,7 @@
 import qualified Data.Vector as V
 import Text.Parsec
 import Text.Parsec.String (Parser)
-import Typst.Module.Standard (standardModule)
+import Typst.Module.Standard (applyPureFunction)
 import Typst.Regex
   ( RE (..),
     RegexMatch (..),
@@ -67,16 +67,16 @@
         "at" ->
           pure $ makeFunction $ do
             key <- nthArg 1
-            defval <- namedArg "default" `mplus` pure VNone
+            defval <- namedArg "default" VNone
             case OM.lookup (Identifier key) m of
               Nothing -> pure defval
               Just v -> pure v
-        "insert" ->
+        "insert" -> do
           pure $ makeFunction $ do
             key <- nthArg 1
             v <- nthArg 2
             lift $ updateVal $ VDict $ m OM.|> (Identifier key, v)
-            pure v
+            pure VNone
         "keys" ->
           pure $
             makeFunction $
@@ -161,10 +161,9 @@
         "slice" ->
           pure $ makeFunction $ do
             start <- toPos <$> nthArg 1
-            end <-
-              (toPos <$> nthArg 2)
-                `mplus` ((+ start) <$> namedArg "count")
-                `mplus` pure (T.length t)
+            mbcount <- namedArg "count" Nothing
+            end <- (toPos <$> nthArg 2) `mplus`
+                      pure (maybe (T.length t) (+ start) mbcount)
             if end < start
               then pure $ VString ""
               else pure $ VString $ T.take (end - start) $ T.drop start t
@@ -228,7 +227,7 @@
         "replace" -> pure $ makeFunction $ do
           patt :: RE <- nthArg 1
           (replacement :: Val) <- nthArg 2
-          mbCount :: Maybe Int <- namedArg "count" `mplus` pure Nothing
+          mbCount :: Maybe Int <- namedArg "count" Nothing
           case mbCount of
             Just 0 -> pure $ VString t
             _ ->
@@ -259,8 +258,8 @@
                 _ -> fail "replacement must be string or function"
         "trim" -> pure $ makeFunction $ do
           (RE patt _) <- nthArg 1 `mplus` makeRE "[[:space:]]*"
-          (repeated :: Bool) <- namedArg "repeat" `mplus` pure True
-          (mbAt :: Maybe Val) <- namedArg "at" `mplus` pure Nothing
+          (repeated :: Bool) <- namedArg "repeat" True
+          (mbAt :: Maybe Val) <- namedArg "at" Nothing
           let patt' =
                 if repeated
                   then "(" <> patt <> ")*"
@@ -338,7 +337,7 @@
                   <> T.unpack (repr (VContent cs))
         "at" -> pure $ makeFunction $ do
           (field :: Text) <- ask >>= getPositionalArg 1 >>= fromVal
-          defval <- namedArg "default" `mplus` pure VNone
+          defval <- namedArg "default" VNone
           case F.toList cs of
             [Elt _ _ fields] ->
               case M.lookup (Identifier field) fields of
@@ -399,7 +398,7 @@
                 else pure $ V.last v
         "at" -> pure $ makeFunction $ do
           pos <- toPos <$> nthArg 1
-          defval <- namedArg "default" `mplus` pure VNone
+          defval <- namedArg "default" VNone
           pure $ fromMaybe defval $ v V.!? pos
         "push" -> pure $ makeFunction $ do
           x <- nthArg 1
@@ -415,10 +414,9 @@
                   pure $ V.last v
         "slice" -> pure $ makeFunction $ do
           start <- toPos <$> nthArg 1
-          end <-
-            (toPos <$> nthArg 2)
-              `mplus` ((+ start) <$> namedArg "count")
-              `mplus` pure (V.length v)
+          mbcount <- namedArg "count" Nothing
+          end <- (toPos <$> nthArg 2) `mplus`
+                    pure (maybe (V.length v) (+ start) mbcount)
           if V.length v < end
             then fail "array contains insufficient elements for slice"
             else
@@ -529,14 +527,14 @@
         "rev" -> pure $ makeFunction $ pure $ VArray $ V.reverse v
         "join" -> pure $ makeFunction $ do
           separator <- nthArg 1
-          lastsep <- namedArg "last" `mplus` pure separator
+          lastsep <- namedArg "last" separator
           let xs' = F.toList v
           let xs = case xs' of
                 [] -> []
                 _ -> intersperse separator (init xs') ++ [lastsep, last xs']
           foldM joinVals VNone xs
         "sorted" -> pure $ makeFunction $ do
-          (mbKeyFn :: Maybe Function) <- namedArg "key" `mplus` pure Nothing
+          (mbKeyFn :: Maybe Function) <- namedArg "key" Nothing
           case mbKeyFn of
             Nothing -> pure $ VArray $ V.fromList $ sort $ V.toList v
             Just (Function kf) -> do
@@ -547,7 +545,7 @@
           (v' :: V.Vector Val) <- ask >>= getPositionalArg 1
           pure $ VArray $ V.map pairToArray $ V.zip v v'
         "sum" -> pure $ makeFunction $ do
-          mbv <- namedArg "default" `mplus` pure Nothing
+          mbv <- namedArg "default" Nothing
           case V.uncons v of
             Nothing ->
               maybe
@@ -565,7 +563,7 @@
                     (Just h)
                     rest
         "product" -> pure $ makeFunction $ do
-          mbv <- namedArg "default" `mplus` pure Nothing
+          mbv <- namedArg "default" Nothing
           case V.uncons v of
             Nothing ->
               maybe
@@ -671,18 +669,6 @@
 
 pairToArray :: (Val, Val) -> Val
 pairToArray (x, y) = VArray $ V.fromList [x, y]
-
-applyPureFunction :: Function -> [Val] -> Attempt Val
-applyPureFunction (Function f) vals =
-  let args = Arguments vals OM.empty
-   in case runParserT (f args) initialEvalState "" [] of
-        Failure s -> Failure s
-        Success (Left s) -> Failure $ show s
-        Success (Right v) -> Success v
-
-initialEvalState :: MonadFail m => EvalState m
-initialEvalState =
-  emptyEvalState { evalIdentifiers = [(BlockScope, standardModule)] }
 
 formatNumber :: Text -> Int -> Text
 formatNumber t n = F.foldMap go $ T.unpack t
diff --git a/src/Typst/Module/Calc.hs b/src/Typst/Module/Calc.hs
--- a/src/Typst/Module/Calc.hs
+++ b/src/Typst/Module/Calc.hs
@@ -6,7 +6,6 @@
   )
 where
 
-import Control.Applicative ((<|>))
 import qualified Data.Map as M
 import Data.Maybe (fromMaybe)
 import Typst.Types
@@ -91,7 +90,7 @@
       ),
       ( "log",
         makeFunction $ do
-          b <- namedArg "base" <|> pure 10
+          b <- namedArg "base" 10
           n <- nthArg 1
           if n <= 0
             then fail "value must be strictly positive"
@@ -159,7 +158,7 @@
       ( "round",
         makeFunction $ do
           (x :: Double) <- nthArg 1
-          (digits :: Integer) <- namedArg "digits" <|> pure 0
+          (digits :: Integer) <- namedArg "digits" 0
           pure $
             if digits > 0
               then
diff --git a/src/Typst/Module/Standard.hs b/src/Typst/Module/Standard.hs
--- a/src/Typst/Module/Standard.hs
+++ b/src/Typst/Module/Standard.hs
@@ -7,6 +7,7 @@
 module Typst.Module.Standard
   ( standardModule,
     loadFileText,
+    applyPureFunction
   )
 where
 
@@ -28,7 +29,7 @@
 import qualified Data.Text.Encoding as TE
 import qualified Data.Vector as V
 import qualified Data.Yaml as Yaml
-import Text.Parsec (getPosition, getState, updateState)
+import Text.Parsec (getPosition, getState, updateState, runParserT)
 import Text.Read (readMaybe)
 import qualified Text.XML as XML
 import Typst.Emoji (typstEmojis)
@@ -225,7 +226,14 @@
       [ ("numbering", One (TString :|: TFunction)),
         ("numbers", Many TInteger)
       ],
-    makeElement Nothing "outline" [],
+    makeElementWithScope Nothing "outline"
+      []
+      [makeElement (Just "outline") "entry"
+        [("level", One TInteger),
+         ("element", One TContent),
+         ("body", One TContent),
+         ("fill", One (TContent :|: TNone)),
+         ("page", One TContent)]],
     makeElement
       Nothing
       "query"
@@ -234,12 +242,16 @@
       ],
     makeElement Nothing "ref" [("target", One TLabel)],
     makeElement Nothing "state" [("key", One TString), ("init", One TAny)],
-    makeElement Nothing "style" [("func", One TFunction)],
     makeElementWithScope
       Nothing
       "footnote"
       [("body", One TContent)]
-      [makeElement (Just "footnote") "entry" [("note", One TContent)]]
+      [makeElement (Just "footnote") "entry" [("note", One TContent)]],
+    ("style", makeFunction $ do
+        Function f <- nthArg 1
+        case applyPureFunction (Function f) [VStyles] of
+          Success x -> pure x
+          Failure e -> fail e)
   ]
 
 colors :: [(Identifier, Val)]
@@ -291,7 +303,7 @@
         ( do
             (cond :: Bool) <- nthArg 1
             unless cond $ do
-              (msg :: String) <- namedArg "message" <|> pure "Assertion failed"
+              (msg :: String) <- namedArg "message" "Assertion failed"
               fail msg
             pure VNone
         )
@@ -311,7 +323,8 @@
           )
         ]
     ),
-    ("panic", makeFunction $ allArgs >>= fail . unlines . map show),
+    ("panic", makeFunction $ allArgs >>= fail . T.unpack .
+                 (("panicked with: " <>) . T.unlines . map repr)),
     ("repr", makeFunction $ nthArg 1 >>= pure . VString . repr),
     ( "type",
       makeFunction $ do
@@ -350,8 +363,8 @@
     ( "range",
       makeFunction $ do
         first <- nthArg 1
-        mbsecond <- nthArg 2 `mplus` (fmap (+ first) <$> namedArg "count")
-        step <- namedArg "step" `mplus` pure 1
+        mbsecond <- nthArg 2
+        step <- namedArg "step" 1
         pure $
           VArray $
             V.fromList $
@@ -384,7 +397,7 @@
       makeFunctionWithScope
       (do
         val <- nthArg 1
-        base <- namedArg "base" <|> pure (10 :: Integer)
+        base <- namedArg "base" (10 :: Integer)
         let digitVector :: V.Vector Char
             digitVector = V.fromList $ ['0'..'9'] ++ ['A'..'Z']
         let renderDigit n = digitVector V.!? (fromIntegral n)
@@ -468,37 +481,37 @@
 
 loadFileLazyBytes :: Monad m => FilePath -> MP m BL.ByteString
 loadFileLazyBytes fp = do
-  loadBytes <- evalLoadBytes <$> getState
-  lift $ BL.fromStrict <$> loadBytes fp
+  operations <- evalOperations <$> getState
+  lift $ BL.fromStrict <$> loadBytes operations fp
 
 loadFileText :: Monad m => FilePath -> MP m T.Text
 loadFileText fp = do
-  loadBytes <- evalLoadBytes <$> getState
-  lift $ TE.decodeUtf8 <$> loadBytes fp
+  operations <- evalOperations <$> getState
+  lift $ TE.decodeUtf8 <$> loadBytes operations fp
 
-currentUTCTime :: Monad m => MP m UTCTime
-currentUTCTime = (evalCurrentUTCTime <$> getState) >>= lift
+getUTCTime :: Monad m => MP m UTCTime
+getUTCTime = (currentUTCTime . evalOperations <$> getState) >>= lift
 
 time :: [(Identifier, Val)]
 time =
   [ ( "datetime", makeFunctionWithScope
       (do
-         mbyear <- namedArg "year" <|> pure Nothing
-         mbmonth <- namedArg "month" <|> pure Nothing
-         mbday <- namedArg "day" <|> pure Nothing
+         mbyear <- namedArg "year" Nothing
+         mbmonth <- namedArg "month" Nothing
+         mbday <- namedArg "day" Nothing
          let mbdate = case (mbyear, mbmonth, mbday) of
                         (Just yr, Just mo, Just da) -> fromGregorianValid yr mo da
                         _ -> Nothing
-         mbhour <- namedArg "hour" <|> pure Nothing
-         mbminute <- namedArg "minute" <|> pure Nothing
-         mbsecond <- namedArg "second" <|> pure Nothing
+         mbhour <- namedArg "hour" Nothing
+         mbminute <- namedArg "minute" Nothing
+         mbsecond <- namedArg "second" Nothing
          let mbtime = case (mbhour, mbminute, mbsecond) of
                         (Just hr, Just mi, Just se) ->
                           Just $ secondsToDiffTime $ (hr * 60 * 60) + (mi * 60) + se
                         _ -> Nothing
          pure $ VDateTime mbdate mbtime)
       [ ("today", makeFunction $ do
-            utcTime <- lift currentUTCTime
+            utcTime <- lift getUTCTime
             pure $ VDateTime (Just (utctDay utcTime)) (Just (utctDayTime utcTime)) ) ]
      )
   ]
@@ -574,3 +587,15 @@
                     ]
     )
   ]
+
+applyPureFunction :: Function -> [Val] -> Attempt Val
+applyPureFunction (Function f) vals =
+  let args = Arguments vals OM.empty
+   in case runParserT (f args) initialEvalState "" [] of
+        Failure s -> Failure s
+        Success (Left s) -> Failure $ show s
+        Success (Right v) -> Success v
+
+initialEvalState :: MonadFail m => EvalState m
+initialEvalState =
+  emptyEvalState { evalIdentifiers = [(BlockScope, standardModule)] }
diff --git a/src/Typst/Parse.hs b/src/Typst/Parse.hs
--- a/src/Typst/Parse.hs
+++ b/src/Typst/Parse.hs
@@ -11,7 +11,7 @@
 import Control.Monad (MonadPlus (mzero), guard, void, when)
 import Control.Monad.Identity (Identity)
 import Data.Char hiding (Space)
-import Data.Maybe (isJust)
+import Data.Maybe (isJust, isNothing)
 import Data.Text (Text)
 import qualified Data.Text as T
 import Text.Parsec hiding (string)
@@ -166,11 +166,18 @@
             mbBeforeSpace <- stBeforeSpace <$> getState
             -- NOTE: can't have space before () or [] arg in a
             -- function call! to prevent bugs with e.g. 'if 2<3 [...]'.
-            guard $ mbBeforeSpace == Nothing
+            guard $ isNothing mbBeforeSpace
             args <- mGrouped '(' ')' True
             pure $ \expr -> MGroup Nothing Nothing [expr, args]
         )
     ],
+    -- precedence 4  -- factorial needs to take precedence over fraction
+    [ Postfix (try $ do
+                  mbBeforeSpace <- stBeforeSpace <$> getState
+                  guard $ isNothing mbBeforeSpace
+                  lexeme $ char '!' *> notFollowedBy (char '=')
+                  pure (\expr -> MGroup Nothing Nothing [expr, Text "!"]))
+    ],
     -- precedence 3
     [ Infix (makeFrac <$ op "/") AssocLeft
     ]
@@ -200,7 +207,7 @@
         mbBeforeSpace <- stBeforeSpace <$> getState
         -- NOTE: can't have space before () or [] arg in a
         -- function call! to prevent bugs with e.g. 'if 2<3 [...]'.
-        guard $ mbBeforeSpace == Nothing
+        guard $ isNothing mbBeforeSpace
         args <- mArgs
         pure $ \expr -> FuncCall expr args
     )
@@ -310,8 +317,7 @@
     many (mKeyValArg <|> mArrayArg <|> mNormArg <|> mMathArg)
   where
     sep = void (sym ",") <|> void (lookAhead (char ')'))
-    mNormArg =
-      NormalArg <$> (char '#' *> pExpr <* sep)
+    mNormArg = try $ NormalArg <$> (char '#' *> pExpr <* sep)
     mKeyValArg = do
       ident <- try $ pIdentifier <* sym ":"
       KeyValArg ident
@@ -346,7 +352,7 @@
       pure (x : xs)
 
 mCode :: P Markup
-mCode = char '#' *> (Code <$> getPosition <*> pBasicExpr)
+mCode = lexeme $ char '#' *> (Code <$> getPosition <*> pBasicExpr)
 
 mMid :: P Markup
 mMid = try $ do
@@ -680,7 +686,7 @@
 -- other letters, letter numbers, plus Other_ID_Start, minus Pattern_Syntax and
 -- Pattern_White_Space code points.
 isIdentStart :: Char -> Bool
-isIdentStart c =
+isIdentStart c = c == '_' ||
   case generalCategory c of
     UppercaseLetter -> True
     LowercaseLetter -> True
@@ -767,7 +773,7 @@
         mbBeforeSpace <- stBeforeSpace <$> getState
         -- NOTE: can't have space before () or [] arg in a
         -- function call! to prevent bugs with e.g. 'if 2<3 [...]'.
-        guard $ mbBeforeSpace == Nothing
+        guard $ isNothing mbBeforeSpace
         args <- pArgs
         pure $ \expr -> FuncCall expr args
     )
@@ -953,8 +959,8 @@
   try $
     inParens $
       ( do
-          v <- pExpr
-          vs <- many $ try $ sym "," *> pExpr
+          v <- pSpread <|> (Reg <$> pExpr)
+          vs <- many $ try $ sym "," *> (pSpread <|> (Reg <$> pExpr))
           if null vs
             then void $ sym ","
             else optional $ void $ sym ","
@@ -968,21 +974,26 @@
 pDictExpr = try $ inParens (pEmptyDict <|> pNonemptyDict)
   where
     pEmptyDict = Dict mempty <$ sym ":"
-    pNonemptyDict = Dict <$> sepEndBy1 pPair (sym ",")
-    pPair = (,) <$> pKey <*> try (sym ":" *> pExpr)
+    pNonemptyDict = Dict <$> sepEndBy1 (pSpread <|> pPair) (sym ",")
+    pPair = Reg <$> ((,) <$> pKey <*> try (sym ":" *> pExpr))
     pKey = pIdentifier <|> pStrKey
     pStrKey = do
       String t <- pStr
       pure $ Identifier t
 
+pSpread :: P (Spreadable a)
+pSpread = try $ string ".." *> (Spr <$> pExpr)
+
 -- func-expr ::= (params | ident) '=>' expr
 pFuncExpr :: P Expr
 pFuncExpr = try $ FuncExpr <$> pParamsOrIdent <*> (sym "=>" *> pExpr)
   where
     pParamsOrIdent =
       pParams
-        <|> ((\i -> [NormalParam i]) <$> pIdentifier)
-        <|> ([SkipParam] <$ sym "_")
+        <|> (do i <- pIdentifier
+                if i == "_"
+                   then pure [SkipParam]
+                   else pure [NormalParam i])
 
 pKeywordExpr :: P Expr
 pKeywordExpr =
@@ -1053,7 +1064,11 @@
 pBasicBind = BasicBind <$> try (pBindIdentifier <|> inParens pBindIdentifier)
 
 pBindIdentifier :: P (Maybe Identifier)
-pBindIdentifier = (Just <$> pIdentifier) <|> (Nothing <$ sym "_")
+pBindIdentifier = do
+  ident <- pIdentifier
+  if ident == "_"
+     then pure Nothing
+     else pure $ Just ident
 
 pDestructuringBind :: P Bind
 pDestructuringBind =
diff --git a/src/Typst/Regex.hs b/src/Typst/Regex.hs
--- a/src/Typst/Regex.hs
+++ b/src/Typst/Regex.hs
@@ -113,7 +113,7 @@
   | otherwise = makeRE $ T.foldl go mempty t
   where
     go acc c = if isSpecial c then acc <> T.pack ['\\', c] else T.snoc acc c
-    isSpecial c = c `elem` (".*?+{}[]\\" :: [Char])
+    isSpecial c = c `elem` (".*?+(){}[]|\\^$" :: [Char])
 
 -- from regex-compat but for Text
 splitRegex :: RE -> Text -> [Text]
diff --git a/src/Typst/Syntax.hs b/src/Typst/Syntax.hs
--- a/src/Typst/Syntax.hs
+++ b/src/Typst/Syntax.hs
@@ -11,6 +11,7 @@
     BindPart (..),
     Literal (..),
     Block (..),
+    Spreadable (..),
     Expr (..),
     Unit (..),
   )
@@ -105,6 +106,11 @@
   | CodeBlock [Expr]
   deriving (Show, Ord, Eq, Data, Typeable)
 
+data Spreadable a =
+    Spr Expr
+  | Reg a
+  deriving (Show, Ord, Eq, Data, Typeable)
+
 -- binary-op ::=
 --   '+' | '-' | '*' | '/' | 'and' | 'or' | '==' | '!=' |
 --   '<' | '<=' | '>' | '>=' | '=' | 'in' | ('not' 'in') |
@@ -132,8 +138,8 @@
   | FuncExpr [Param] Expr
   | FieldAccess Expr Expr
   | Group Expr
-  | Array [Expr]
-  | Dict [(Identifier, Expr)]
+  | Array [Spreadable Expr]
+  | Dict [Spreadable (Identifier, Expr)]
   | Binding Bind
   | Let Bind Expr
   | LetFunc Identifier [Param] Expr
diff --git a/src/Typst/Types.hs b/src/Typst/Types.hs
--- a/src/Typst/Types.hs
+++ b/src/Typst/Types.hs
@@ -27,6 +27,8 @@
     MP,
     Scope (..),
     FlowDirective (..),
+    Operations (..),
+    XdgDirectory (..),
     EvalState (..),
     emptyEvalState,
     ShowRule (..),
@@ -74,6 +76,7 @@
 import Typst.Syntax (Identifier (..), Markup)
 import Data.Time (UTCTime, Day, DiffTime)
 import Data.Time.Format (defaultTimeLocale, formatTime)
+import System.Directory (XdgDirectory(..))
 
 data Val
   = VNone
@@ -314,7 +317,7 @@
     go (VContent cs) (VString t) = pure $ VContent (cs Seq.|> Txt t)
     go (VContent cs) (VContent cs') = pure $ VContent (cs <> cs')
     go (VArray vec) (VArray vec') = pure $ VArray (vec <> vec')
-    go accum v = fail $ "Can't combine " <> show accum <> " and " <> show v
+    go x y = pure $ VContent $ valToContent x <> valToContent y
 
 class Compare a where
   comp :: a -> a -> Maybe Ordering
@@ -520,6 +523,14 @@
   | FlowReturn Bool
   deriving (Show, Ord, Eq)
 
+data Operations m =
+  Operations
+  { loadBytes :: FilePath -> m BS.ByteString
+  , currentUTCTime :: m UTCTime
+  , lookupEnvVar :: String -> m (Maybe String)
+  , checkExistence :: FilePath -> m Bool
+  }
+
 data EvalState m = EvalState
   { evalIdentifiers :: [(Scope, M.Map Identifier Val)],
     -- first item is current block, then superordinate block, etc.
@@ -528,8 +539,8 @@
     evalShowRules :: [ShowRule],
     evalStyles :: M.Map Identifier Arguments,
     evalFlowDirective :: FlowDirective,
-    evalLoadBytes :: FilePath -> m BS.ByteString,
-    evalCurrentUTCTime :: m UTCTime
+    evalPackageRoot :: FilePath,
+    evalOperations :: Operations m
   }
 
 emptyEvalState :: EvalState m
@@ -540,8 +551,8 @@
       evalShowRules = [],
       evalStyles = mempty,
       evalFlowDirective = FlowNormal,
-      evalLoadBytes = undefined,
-      evalCurrentUTCTime = undefined
+      evalPackageRoot = mempty,
+      evalOperations = undefined
     }
 
 data Attempt a
diff --git a/src/Typst/Util.hs b/src/Typst/Util.hs
--- a/src/Typst/Util.hs
+++ b/src/Typst/Util.hs
@@ -137,12 +137,13 @@
 namedArg ::
   (Monad m, FromVal a) =>
   Identifier ->
+  a ->
   ReaderT Arguments (MP m) a
-namedArg ident@(Identifier ident') = do
+namedArg ident@(Identifier _) defaultVal = do
   mbval <- getNamed ident
   case mbval of
     Just val -> fromVal val
-    Nothing -> fail $ "named argument " <> T.unpack ident' <> " not defined"
+    Nothing -> pure defaultVal
 
 allArgs :: Monad m => ReaderT Arguments (MP m) [Val]
 allArgs = asks positional
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -13,12 +13,22 @@
 import Text.Show.Pretty (ppShow)
 import Typst.Evaluate (evaluateTypst)
 import Typst.Parse (parseTypst)
-import Typst.Types (Val (VContent), repr)
+import Typst.Types (Val (VContent), repr, Operations(..))
 import Data.Time (getCurrentTime)
+import System.Directory (doesFileExist)
+import System.Environment (lookupEnv)
 
 main :: IO ()
 main = defaultMain =<< goldenTests
 
+operations :: Operations IO
+operations = Operations
+  { loadBytes = BS.readFile
+  , currentUTCTime = getCurrentTime
+  , lookupEnvVar = lookupEnv
+  , checkExistence = doesFileExist
+  }
+
 goldenTests :: IO TestTree
 goldenTests = do
   inputs <- findByExtension [".typ"] "test/typ"
@@ -52,7 +62,7 @@
       case parseResult of
         Left e -> pure $ fromText $ T.pack $ show e
         Right parsed -> do
-          evalResult <- evaluateTypst BS.readFile getCurrentTime input parsed
+          evalResult <- evaluateTypst operations input parsed
           let parseOutput = "--- parse tree ---\n" <> T.pack (ppShow parsed) <> "\n"
           case evalResult of
             Left e ->
diff --git a/test/out/bugs/args-underscore-00.out b/test/out/bugs/args-underscore-00.out
--- a/test/out/bugs/args-underscore-00.out
+++ b/test/out/bugs/args-underscore-00.out
@@ -51,7 +51,11 @@
                  (FuncCall
                     (FieldAccess
                        (Ident (Identifier "map"))
-                       (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                       (Array
+                          [ Reg (Literal (Int 1))
+                          , Reg (Literal (Int 2))
+                          , Reg (Literal (Int 3))
+                          ]))
                     [ NormalArg (FuncExpr [ SkipParam ] (Block (CodeBlock []))) ]))
               [])
        , NormalArg (Literal (Int 3))
diff --git a/test/out/bugs/grid-1-00.out b/test/out/bugs/grid-1-00.out
--- a/test/out/bugs/grid-1-00.out
+++ b/test/out/bugs/grid-1-00.out
@@ -53,9 +53,10 @@
        (Ident (Identifier "table"))
        [ KeyValArg
            (Identifier "columns")
-           (Array [ Literal (Numeric 1.5 Cm) , Literal Auto ])
+           (Array [ Reg (Literal (Numeric 1.5 Cm)) , Reg (Literal Auto) ])
        , KeyValArg
-           (Identifier "rows") (Array [ Literal Auto , Literal Auto ])
+           (Identifier "rows")
+           (Array [ Reg (Literal Auto) , Reg (Literal Auto) ])
        , NormalArg
            (FuncCall
               (Ident (Identifier "rect"))
diff --git a/test/out/bugs/grid-2-00.out b/test/out/bugs/grid-2-00.out
--- a/test/out/bugs/grid-2-00.out
+++ b/test/out/bugs/grid-2-00.out
@@ -53,9 +53,10 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Array [ Literal (Numeric 2.0 Cm) , Literal Auto ])
+           (Array [ Reg (Literal (Numeric 2.0 Cm)) , Reg (Literal Auto) ])
        , KeyValArg
-           (Identifier "rows") (Array [ Literal Auto , Literal Auto ])
+           (Identifier "rows")
+           (Array [ Reg (Literal Auto) , Reg (Literal Auto) ])
        , NormalArg
            (FuncCall
               (Ident (Identifier "rect"))
@@ -112,16 +113,18 @@
               [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
               , NormalArg
                   (Array
-                     [ Literal (Numeric 0.0 Percent) , Literal (Numeric 0.0 Percent) ])
+                     [ Reg (Literal (Numeric 0.0 Percent))
+                     , Reg (Literal (Numeric 0.0 Percent))
+                     ])
               , NormalArg
                   (Array
-                     [ Literal (Numeric 100.0 Percent)
-                     , Literal (Numeric 0.0 Percent)
+                     [ Reg (Literal (Numeric 100.0 Percent))
+                     , Reg (Literal (Numeric 0.0 Percent))
                      ])
               , NormalArg
                   (Array
-                     [ Literal (Numeric 100.0 Percent)
-                     , Literal (Numeric 20.0 Percent)
+                     [ Reg (Literal (Numeric 100.0 Percent))
+                     , Reg (Literal (Numeric 20.0 Percent))
                      ])
               ])
        ])
diff --git a/test/out/bugs/math-realize-00.out b/test/out/bugs/math-realize-00.out
--- a/test/out/bugs/math-realize-00.out
+++ b/test/out/bugs/math-realize-00.out
@@ -224,7 +224,8 @@
                 body: { text(body: [f]), 
                         box(baseline: 10.0pt, 
                             body: text(body: [f])), 
-                        style(func: ) }, 
+                        box(baseline: 10.0pt, 
+                            body: text(body: [f])) }, 
                 numbering: none), 
   text(body: [
 ]), 
diff --git a/test/out/bugs/parameter-pattern-00.out b/test/out/bugs/parameter-pattern-00.out
--- a/test/out/bugs/parameter-pattern-00.out
+++ b/test/out/bugs/parameter-pattern-00.out
@@ -51,9 +51,17 @@
                  (FuncCall
                     (FieldAccess
                        (Ident (Identifier "zip"))
-                       (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                       (Array
+                          [ Reg (Literal (Int 1))
+                          , Reg (Literal (Int 2))
+                          , Reg (Literal (Int 3))
+                          ]))
                     [ NormalArg
-                        (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+                        (Array
+                           [ Reg (Literal (Int 1))
+                           , Reg (Literal (Int 2))
+                           , Reg (Literal (Int 3))
+                           ])
                     ]))
               [ NormalArg
                   (FuncExpr
@@ -63,7 +71,11 @@
                      (Ident (Identifier "x")))
               ])
        , NormalArg
-           (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+           (Array
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/array-00.out b/test/out/compiler/array-00.out
--- a/test/out/compiler/array-00.out
+++ b/test/out/compiler/array-00.out
@@ -62,22 +62,24 @@
 , Code
     "test/typ/compiler/array-00.typ"
     ( line 13 , column 2 )
-    (Array [ Negated (Literal (Int 1)) ])
+    (Array [ Reg (Negated (Literal (Int 1))) ])
 , ParBreak
 , Comment
 , Code
     "test/typ/compiler/array-00.typ"
     ( line 16 , column 2 )
-    (Array [ Literal (Boolean True) , Literal (Boolean False) ])
+    (Array
+       [ Reg (Literal (Boolean True)) , Reg (Literal (Boolean False)) ])
 , ParBreak
 , Comment
 , Code
     "test/typ/compiler/array-00.typ"
     ( line 19 , column 2 )
     (Array
-       [ Literal (String "1")
-       , FuncCall
-           (Ident (Identifier "rgb")) [ NormalArg (Literal (String "002")) ]
+       [ Reg (Literal (String "1"))
+       , Reg
+           (FuncCall
+              (Ident (Identifier "rgb")) [ NormalArg (Literal (String "002")) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/array-01.out b/test/out/compiler/array-01.out
--- a/test/out/compiler/array-01.out
+++ b/test/out/compiler/array-01.out
@@ -60,9 +60,9 @@
               (FieldAccess
                  (Ident (Identifier "len"))
                  (Array
-                    [ Literal (String "A")
-                    , Literal (String "B")
-                    , Literal (String "C")
+                    [ Reg (Literal (String "A"))
+                    , Reg (Literal (String "B"))
+                    , Reg (Literal (String "C"))
                     ]))
               [])
        , NormalArg (Literal (Int 3))
diff --git a/test/out/compiler/array-02.out b/test/out/compiler/array-02.out
--- a/test/out/compiler/array-02.out
+++ b/test/out/compiler/array-02.out
@@ -47,7 +47,7 @@
        (CodeBlock
           [ Let
               (BasicBind (Just (Identifier "array")))
-              (Array [ Literal (Int 1) , Literal (Int 2) ])
+              (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
           , Assign
               (FuncCall
                  (FieldAccess
@@ -67,7 +67,8 @@
           , FuncCall
               (Ident (Identifier "test"))
               [ NormalArg (Ident (Identifier "array"))
-              , NormalArg (Array [ Literal (Int 1) , Literal (Int 8) ])
+              , NormalArg
+                  (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 8)) ])
               ]
           ]))
 , ParBreak
diff --git a/test/out/compiler/array-03.out b/test/out/compiler/array-03.out
--- a/test/out/compiler/array-03.out
+++ b/test/out/compiler/array-03.out
@@ -47,7 +47,11 @@
        (CodeBlock
           [ Let
               (BasicBind (Just (Identifier "array")))
-              (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+              (Array
+                 [ Reg (Literal (Int 1))
+                 , Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 ])
           , Assign
               (FuncCall
                  (FieldAccess
@@ -69,7 +73,11 @@
               (Ident (Identifier "test"))
               [ NormalArg (Ident (Identifier "array"))
               , NormalArg
-                  (Array [ Literal (Int 7) , Literal (Int 16) , Literal (Int 3) ])
+                  (Array
+                     [ Reg (Literal (Int 7))
+                     , Reg (Literal (Int 16))
+                     , Reg (Literal (Int 3))
+                     ])
               ]
           ]))
 , ParBreak
diff --git a/test/out/compiler/array-06.out b/test/out/compiler/array-06.out
--- a/test/out/compiler/array-06.out
+++ b/test/out/compiler/array-06.out
@@ -49,7 +49,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "at"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [ NormalArg (Literal (Int 2))
               , KeyValArg (Identifier "default") (Literal (Int 5))
               ])
@@ -65,7 +69,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "at"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [ NormalArg (Literal (Int 3))
               , KeyValArg (Identifier "default") (Literal (Int 5))
               ])
diff --git a/test/out/compiler/array-09.out b/test/out/compiler/array-09.out
--- a/test/out/compiler/array-09.out
+++ b/test/out/compiler/array-09.out
@@ -48,10 +48,10 @@
           [ Let
               (BasicBind (Just (Identifier "array")))
               (Array
-                 [ Literal (Int 1)
-                 , Literal (Int 2)
-                 , Literal (Int 3)
-                 , Literal (Int 4)
+                 [ Reg (Literal (Int 1))
+                 , Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 , Reg (Literal (Int 4))
                  ])
           , FuncCall
               (Ident (Identifier "test"))
diff --git a/test/out/compiler/array-10.out b/test/out/compiler/array-10.out
--- a/test/out/compiler/array-10.out
+++ b/test/out/compiler/array-10.out
@@ -48,7 +48,7 @@
        [ NormalArg
            (FuncCall
               (FieldAccess
-                 (Ident (Identifier "first")) (Array [ Literal (Int 1) ]))
+                 (Ident (Identifier "first")) (Array [ Reg (Literal (Int 1)) ]))
               [])
        , NormalArg (Literal (Int 1))
        ])
@@ -61,7 +61,7 @@
        [ NormalArg
            (FuncCall
               (FieldAccess
-                 (Ident (Identifier "last")) (Array [ Literal (Int 2) ]))
+                 (Ident (Identifier "last")) (Array [ Reg (Literal (Int 2)) ]))
               [])
        , NormalArg (Literal (Int 2))
        ])
@@ -75,7 +75,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "first"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [])
        , NormalArg (Literal (Int 1))
        ])
@@ -89,7 +93,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "last"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [])
        , NormalArg (Literal (Int 3))
        ])
diff --git a/test/out/compiler/array-13.out b/test/out/compiler/array-13.out
--- a/test/out/compiler/array-13.out
+++ b/test/out/compiler/array-13.out
@@ -48,12 +48,22 @@
           [ Let
               (BasicBind (Just (Identifier "tasks")))
               (Dict
-                 [ ( Identifier "a"
-                   , Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]
-                   )
-                 , ( Identifier "b"
-                   , Array [ Literal (Int 4) , Literal (Int 5) , Literal (Int 6) ]
-                   )
+                 [ Reg
+                     ( Identifier "a"
+                     , Array
+                         [ Reg (Literal (Int 1))
+                         , Reg (Literal (Int 2))
+                         , Reg (Literal (Int 3))
+                         ]
+                     )
+                 , Reg
+                     ( Identifier "b"
+                     , Array
+                         [ Reg (Literal (Int 4))
+                         , Reg (Literal (Int 5))
+                         , Reg (Literal (Int 6))
+                         ]
+                     )
                  ])
           , FuncCall
               (Ident (Identifier "test"))
@@ -78,7 +88,8 @@
               (Ident (Identifier "test"))
               [ NormalArg
                   (FieldAccess (Ident (Identifier "a")) (Ident (Identifier "tasks")))
-              , NormalArg (Array [ Literal (Int 1) , Literal (Int 2) ])
+              , NormalArg
+                  (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
               ]
           , FuncCall
               (Ident (Identifier "test"))
@@ -89,10 +100,10 @@
                      [ NormalArg (Literal (String "b")) ])
               , NormalArg
                   (Array
-                     [ Literal (Int 4)
-                     , Literal (Int 5)
-                     , Literal (Int 6)
-                     , Literal (Int 7)
+                     [ Reg (Literal (Int 4))
+                     , Reg (Literal (Int 5))
+                     , Reg (Literal (Int 6))
+                     , Reg (Literal (Int 7))
                      ])
               ]
           ]))
diff --git a/test/out/compiler/array-14.out b/test/out/compiler/array-14.out
--- a/test/out/compiler/array-14.out
+++ b/test/out/compiler/array-14.out
@@ -48,11 +48,11 @@
           [ Let
               (BasicBind (Just (Identifier "array")))
               (Array
-                 [ Literal (Int 0)
-                 , Literal (Int 1)
-                 , Literal (Int 2)
-                 , Literal (Int 4)
-                 , Literal (Int 5)
+                 [ Reg (Literal (Int 0))
+                 , Reg (Literal (Int 1))
+                 , Reg (Literal (Int 2))
+                 , Reg (Literal (Int 4))
+                 , Reg (Literal (Int 5))
                  ])
           , FuncCall
               (FieldAccess
@@ -74,17 +74,20 @@
               [ NormalArg (Ident (Identifier "array"))
               , NormalArg
                   (Array
-                     [ Literal (Int 0)
-                     , Literal (Int 2)
-                     , Literal (Int 3)
-                     , Literal (Int 4)
-                     , Literal (Int 5)
+                     [ Reg (Literal (Int 0))
+                     , Reg (Literal (Int 2))
+                     , Reg (Literal (Int 3))
+                     , Reg (Literal (Int 4))
+                     , Reg (Literal (Int 5))
                      ])
               ]
           ]))
 , ParBreak
 ]
-"test/typ/compiler/array-14.typ" (line 3, column 2):
-unexpected end of input
-expecting end of input
-Can't combine VContent (fromList [Elt {eltName = Identifier "text", eltPos = Just "test/typ/compiler/array-14.typ" (line 3, column 2), eltFields = fromList [(Identifier "body",VContent (fromList [Txt "\9989"]))]}]) and VInteger 1
+--- evaluated ---
+{ text(body: [
+]), 
+  text(body: [✅]), 
+  text(body: [1]), 
+  text(body: [✅]), 
+  parbreak() }
diff --git a/test/out/compiler/array-16.out b/test/out/compiler/array-16.out
--- a/test/out/compiler/array-16.out
+++ b/test/out/compiler/array-16.out
@@ -50,13 +50,14 @@
               (FieldAccess
                  (Ident (Identifier "slice"))
                  (Array
-                    [ Literal (Int 1)
-                    , Literal (Int 2)
-                    , Literal (Int 3)
-                    , Literal (Int 4)
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    , Reg (Literal (Int 4))
                     ]))
               [ NormalArg (Literal (Int 2)) ])
-       , NormalArg (Array [ Literal (Int 3) , Literal (Int 4) ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ])
        ])
 , SoftBreak
 , Code
@@ -73,10 +74,10 @@
               [ NormalArg (Literal (Int 2)) , NormalArg (Literal (Int 6)) ])
        , NormalArg
            (Array
-              [ Literal (Int 2)
-              , Literal (Int 3)
-              , Literal (Int 4)
-              , Literal (Int 5)
+              [ Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
+              , Reg (Literal (Int 5))
               ])
        ])
 , SoftBreak
@@ -95,7 +96,11 @@
               , KeyValArg (Identifier "count") (Literal (Int 3))
               ])
        , NormalArg
-           (Array [ Literal (Int 4) , Literal (Int 5) , Literal (Int 6) ])
+           (Array
+              [ Reg (Literal (Int 4))
+              , Reg (Literal (Int 5))
+              , Reg (Literal (Int 6))
+              ])
        ])
 , SoftBreak
 , Code
@@ -112,7 +117,8 @@
               [ NormalArg (Negated (Literal (Int 5)))
               , KeyValArg (Identifier "count") (Literal (Int 2))
               ])
-       , NormalArg (Array [ Literal (Int 5) , Literal (Int 6) ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 5)) , Reg (Literal (Int 6)) ])
        ])
 , SoftBreak
 , Code
@@ -124,7 +130,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "slice"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [ NormalArg (Literal (Int 2))
               , NormalArg (Negated (Literal (Int 2)))
               ])
@@ -140,11 +150,15 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "slice"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [ NormalArg (Negated (Literal (Int 2)))
               , NormalArg (Literal (Int 2))
               ])
-       , NormalArg (Array [ Literal (Int 2) ])
+       , NormalArg (Array [ Reg (Literal (Int 2)) ])
        ])
 , SoftBreak
 , Code
@@ -156,11 +170,16 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "slice"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [ NormalArg (Negated (Literal (Int 3)))
               , NormalArg (Literal (Int 2))
               ])
-       , NormalArg (Array [ Literal (Int 1) , Literal (Int 2) ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
        ])
 , SoftBreak
 , Code
diff --git a/test/out/compiler/array-19.out b/test/out/compiler/array-19.out
--- a/test/out/compiler/array-19.out
+++ b/test/out/compiler/array-19.out
@@ -50,9 +50,9 @@
               (FieldAccess
                  (Ident (Identifier "position"))
                  (Array
-                    [ Literal (String "Hi")
-                    , Literal (String "\10084\65039")
-                    , Literal (String "Love")
+                    [ Reg (Literal (String "Hi"))
+                    , Reg (Literal (String "\10084\65039"))
+                    , Reg (Literal (String "Love"))
                     ]))
               [ NormalArg
                   (FuncExpr
@@ -73,9 +73,9 @@
               (FieldAccess
                  (Ident (Identifier "position"))
                  (Array
-                    [ Literal (String "Bye")
-                    , Literal (String "\128152")
-                    , Literal (String "Apart")
+                    [ Reg (Literal (String "Bye"))
+                    , Reg (Literal (String "\128152"))
+                    , Reg (Literal (String "Apart"))
                     ]))
               [ NormalArg
                   (FuncExpr
@@ -96,10 +96,10 @@
               (FieldAccess
                  (Ident (Identifier "position"))
                  (Array
-                    [ Literal (String "A")
-                    , Literal (String "B")
-                    , Literal (String "CDEF")
-                    , Literal (String "G")
+                    [ Reg (Literal (String "A"))
+                    , Reg (Literal (String "B"))
+                    , Reg (Literal (String "CDEF"))
+                    , Reg (Literal (String "G"))
                     ]))
               [ NormalArg
                   (FuncExpr
diff --git a/test/out/compiler/array-20.out b/test/out/compiler/array-20.out
--- a/test/out/compiler/array-20.out
+++ b/test/out/compiler/array-20.out
@@ -65,16 +65,17 @@
               (FieldAccess
                  (Ident (Identifier "filter"))
                  (Array
-                    [ Literal (Int 1)
-                    , Literal (Int 2)
-                    , Literal (Int 3)
-                    , Literal (Int 4)
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    , Reg (Literal (Int 4))
                     ]))
               [ NormalArg
                   (FieldAccess
                      (Ident (Identifier "even")) (Ident (Identifier "calc")))
               ])
-       , NormalArg (Array [ Literal (Int 2) , Literal (Int 4) ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 4)) ])
        ])
 , SoftBreak
 , Code
@@ -87,11 +88,11 @@
               (FieldAccess
                  (Ident (Identifier "filter"))
                  (Array
-                    [ Literal (Int 7)
-                    , Literal (Int 3)
-                    , Literal (Int 2)
-                    , Literal (Int 5)
-                    , Literal (Int 1)
+                    [ Reg (Literal (Int 7))
+                    , Reg (Literal (Int 3))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 5))
+                    , Reg (Literal (Int 1))
                     ]))
               [ NormalArg
                   (FuncExpr
@@ -99,7 +100,11 @@
                      (LessThan (Ident (Identifier "x")) (Literal (Int 5))))
               ])
        , NormalArg
-           (Array [ Literal (Int 3) , Literal (Int 2) , Literal (Int 1) ])
+           (Array
+              [ Reg (Literal (Int 3))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 1))
+              ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/array-21.out b/test/out/compiler/array-21.out
--- a/test/out/compiler/array-21.out
+++ b/test/out/compiler/array-21.out
@@ -65,13 +65,14 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "map"))
-                 (Array [ Literal (Int 2) , Literal (Int 3) ]))
+                 (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 3)) ]))
               [ NormalArg
                   (FuncExpr
                      [ NormalParam (Identifier "x") ]
                      (Times (Ident (Identifier "x")) (Literal (Int 2))))
               ])
-       , NormalArg (Array [ Literal (Int 4) , Literal (Int 6) ])
+       , NormalArg
+           (Array [ Reg (Literal (Int 4)) , Reg (Literal (Int 6)) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/array-22.out b/test/out/compiler/array-22.out
--- a/test/out/compiler/array-22.out
+++ b/test/out/compiler/array-22.out
@@ -64,10 +64,10 @@
               (FieldAccess
                  (Ident (Identifier "fold"))
                  (Array
-                    [ Literal (Int 1)
-                    , Literal (Int 2)
-                    , Literal (Int 3)
-                    , Literal (Int 4)
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    , Reg (Literal (Int 4))
                     ]))
               [ NormalArg (Literal (Int 0))
               , NormalArg
diff --git a/test/out/compiler/array-24.out b/test/out/compiler/array-24.out
--- a/test/out/compiler/array-24.out
+++ b/test/out/compiler/array-24.out
@@ -73,7 +73,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "sum"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [])
        , NormalArg (Literal (Int 6))
        ])
diff --git a/test/out/compiler/array-26.out b/test/out/compiler/array-26.out
--- a/test/out/compiler/array-26.out
+++ b/test/out/compiler/array-26.out
@@ -73,7 +73,8 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "product"))
-                 (Array [ Block (Content [ Text "ab" ]) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Block (Content [ Text "ab" ])) , Reg (Literal (Int 3)) ]))
               [])
        , NormalArg
            (Times (Block (Content [ Text "ab" ])) (Literal (Int 3)))
@@ -88,7 +89,11 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "product"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ]))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ]))
               [])
        , NormalArg (Literal (Int 6))
        ])
diff --git a/test/out/compiler/array-28.out b/test/out/compiler/array-28.out
--- a/test/out/compiler/array-28.out
+++ b/test/out/compiler/array-28.out
@@ -53,7 +53,11 @@
                     (Ident (Identifier "range")) [ NormalArg (Literal (Int 3)) ]))
               [])
        , NormalArg
-           (Array [ Literal (Int 2) , Literal (Int 1) , Literal (Int 0) ])
+           (Array
+              [ Reg (Literal (Int 2))
+              , Reg (Literal (Int 1))
+              , Reg (Literal (Int 0))
+              ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/array-29.out b/test/out/compiler/array-29.out
--- a/test/out/compiler/array-29.out
+++ b/test/out/compiler/array-29.out
@@ -58,7 +58,7 @@
        [ NormalArg
            (FuncCall
               (FieldAccess
-                 (Ident (Identifier "join")) (Array [ Literal (Int 1) ]))
+                 (Ident (Identifier "join")) (Array [ Reg (Literal (Int 1)) ]))
               [])
        , NormalArg (Literal (Int 1))
        ])
@@ -73,9 +73,9 @@
               (FieldAccess
                  (Ident (Identifier "join"))
                  (Array
-                    [ Literal (String "a")
-                    , Literal (String "b")
-                    , Literal (String "c")
+                    [ Reg (Literal (String "a"))
+                    , Reg (Literal (String "b"))
+                    , Reg (Literal (String "c"))
                     ]))
               [])
        , NormalArg (Literal (String "abc"))
@@ -94,9 +94,9 @@
                     (FieldAccess
                        (Ident (Identifier "join"))
                        (Array
-                          [ Literal (String "a")
-                          , Literal (String "b")
-                          , Literal (String "c")
+                          [ Reg (Literal (String "a"))
+                          , Reg (Literal (String "b"))
+                          , Reg (Literal (String "c"))
                           ]))
                     [ NormalArg (Literal (String ", ")) ]))
               (Literal (String ")")))
diff --git a/test/out/compiler/array-32.out b/test/out/compiler/array-32.out
--- a/test/out/compiler/array-32.out
+++ b/test/out/compiler/array-32.out
@@ -48,9 +48,9 @@
        (FieldAccess
           (Ident (Identifier "join"))
           (Array
-             [ Block (Content [ Text "One" ])
-             , Block (Content [ Text "Two" ])
-             , Block (Content [ Text "Three" ])
+             [ Reg (Block (Content [ Text "One" ]))
+             , Reg (Block (Content [ Text "Two" ]))
+             , Reg (Block (Content [ Text "Three" ]))
              ]))
        [ NormalArg (Block (Content [ Text "," , Space ]))
        , KeyValArg
diff --git a/test/out/compiler/array-33.out b/test/out/compiler/array-33.out
--- a/test/out/compiler/array-33.out
+++ b/test/out/compiler/array-33.out
@@ -77,13 +77,16 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Times
-                    (Array [ Literal (Boolean True) , Literal (Boolean False) ])
+                    (Array
+                       [ Reg (Literal (Boolean True)) , Reg (Literal (Boolean False)) ])
                     (Literal (Int 10))))
               [])
        , NormalArg
            (Plus
-              (Times (Array [ Literal (Boolean False) ]) (Literal (Int 10)))
-              (Times (Array [ Literal (Boolean True) ]) (Literal (Int 10))))
+              (Times
+                 (Array [ Reg (Literal (Boolean False)) ]) (Literal (Int 10)))
+              (Times
+                 (Array [ Reg (Literal (Boolean True)) ]) (Literal (Int 10))))
        ])
 , SoftBreak
 , Code
@@ -96,18 +99,18 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Array
-                    [ Literal (String "it")
-                    , Literal (String "the")
-                    , Literal (String "hi")
-                    , Literal (String "text")
+                    [ Reg (Literal (String "it"))
+                    , Reg (Literal (String "the"))
+                    , Reg (Literal (String "hi"))
+                    , Reg (Literal (String "text"))
                     ]))
               [])
        , NormalArg
            (Array
-              [ Literal (String "hi")
-              , Literal (String "it")
-              , Literal (String "text")
-              , Literal (String "the")
+              [ Reg (Literal (String "hi"))
+              , Reg (Literal (String "it"))
+              , Reg (Literal (String "text"))
+              , Reg (Literal (String "the"))
               ])
        ])
 , SoftBreak
@@ -121,10 +124,10 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Array
-                    [ Literal (String "I")
-                    , Literal (String "the")
-                    , Literal (String "hi")
-                    , Literal (String "text")
+                    [ Reg (Literal (String "I"))
+                    , Reg (Literal (String "the"))
+                    , Reg (Literal (String "hi"))
+                    , Reg (Literal (String "text"))
                     ]))
               [ KeyValArg
                   (Identifier "key")
@@ -133,10 +136,10 @@
               ])
        , NormalArg
            (Array
-              [ Literal (String "I")
-              , Literal (String "hi")
-              , Literal (String "text")
-              , Literal (String "the")
+              [ Reg (Literal (String "I"))
+              , Reg (Literal (String "hi"))
+              , Reg (Literal (String "text"))
+              , Reg (Literal (String "the"))
               ])
        ])
 , SoftBreak
@@ -150,10 +153,10 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Array
-                    [ Literal (String "I")
-                    , Literal (String "the")
-                    , Literal (String "hi")
-                    , Literal (String "text")
+                    [ Reg (Literal (String "I"))
+                    , Reg (Literal (String "the"))
+                    , Reg (Literal (String "hi"))
+                    , Reg (Literal (String "text"))
                     ]))
               [ KeyValArg
                   (Identifier "key")
@@ -165,10 +168,10 @@
               ])
        , NormalArg
            (Array
-              [ Literal (String "I")
-              , Literal (String "hi")
-              , Literal (String "the")
-              , Literal (String "text")
+              [ Reg (Literal (String "I"))
+              , Reg (Literal (String "hi"))
+              , Reg (Literal (String "the"))
+              , Reg (Literal (String "text"))
               ])
        ])
 , SoftBreak
@@ -182,28 +185,28 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Array
-                    [ Literal (Int 2)
-                    , Literal (Int 1)
-                    , Literal (Int 3)
-                    , Literal (Int 10)
-                    , Literal (Int 5)
-                    , Literal (Int 8)
-                    , Literal (Int 6)
-                    , Negated (Literal (Int 7))
-                    , Literal (Int 2)
+                    [ Reg (Literal (Int 2))
+                    , Reg (Literal (Int 1))
+                    , Reg (Literal (Int 3))
+                    , Reg (Literal (Int 10))
+                    , Reg (Literal (Int 5))
+                    , Reg (Literal (Int 8))
+                    , Reg (Literal (Int 6))
+                    , Reg (Negated (Literal (Int 7)))
+                    , Reg (Literal (Int 2))
                     ]))
               [])
        , NormalArg
            (Array
-              [ Negated (Literal (Int 7))
-              , Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 2)
-              , Literal (Int 3)
-              , Literal (Int 5)
-              , Literal (Int 6)
-              , Literal (Int 8)
-              , Literal (Int 10)
+              [ Reg (Negated (Literal (Int 7)))
+              , Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 5))
+              , Reg (Literal (Int 6))
+              , Reg (Literal (Int 8))
+              , Reg (Literal (Int 10))
               ])
        ])
 , SoftBreak
@@ -217,15 +220,15 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Array
-                    [ Literal (Int 2)
-                    , Literal (Int 1)
-                    , Literal (Int 3)
-                    , Negated (Literal (Int 10))
-                    , Negated (Literal (Int 5))
-                    , Literal (Int 8)
-                    , Literal (Int 6)
-                    , Negated (Literal (Int 7))
-                    , Literal (Int 2)
+                    [ Reg (Literal (Int 2))
+                    , Reg (Literal (Int 1))
+                    , Reg (Literal (Int 3))
+                    , Reg (Negated (Literal (Int 10)))
+                    , Reg (Negated (Literal (Int 5)))
+                    , Reg (Literal (Int 8))
+                    , Reg (Literal (Int 6))
+                    , Reg (Negated (Literal (Int 7)))
+                    , Reg (Literal (Int 2))
                     ]))
               [ KeyValArg
                   (Identifier "key")
@@ -234,15 +237,15 @@
               ])
        , NormalArg
            (Array
-              [ Negated (Literal (Int 10))
-              , Negated (Literal (Int 7))
-              , Negated (Literal (Int 5))
-              , Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 2)
-              , Literal (Int 3)
-              , Literal (Int 6)
-              , Literal (Int 8)
+              [ Reg (Negated (Literal (Int 10)))
+              , Reg (Negated (Literal (Int 7)))
+              , Reg (Negated (Literal (Int 5)))
+              , Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 6))
+              , Reg (Literal (Int 8))
               ])
        ])
 , SoftBreak
@@ -256,15 +259,15 @@
               (FieldAccess
                  (Ident (Identifier "sorted"))
                  (Array
-                    [ Literal (Int 2)
-                    , Literal (Int 1)
-                    , Literal (Int 3)
-                    , Negated (Literal (Int 10))
-                    , Negated (Literal (Int 5))
-                    , Literal (Int 8)
-                    , Literal (Int 6)
-                    , Negated (Literal (Int 7))
-                    , Literal (Int 2)
+                    [ Reg (Literal (Int 2))
+                    , Reg (Literal (Int 1))
+                    , Reg (Literal (Int 3))
+                    , Reg (Negated (Literal (Int 10)))
+                    , Reg (Negated (Literal (Int 5)))
+                    , Reg (Literal (Int 8))
+                    , Reg (Literal (Int 6))
+                    , Reg (Negated (Literal (Int 7)))
+                    , Reg (Literal (Int 2))
                     ]))
               [ KeyValArg
                   (Identifier "key")
@@ -274,15 +277,15 @@
               ])
        , NormalArg
            (Array
-              [ Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 2)
-              , Literal (Int 3)
-              , Negated (Literal (Int 5))
-              , Literal (Int 6)
-              , Negated (Literal (Int 7))
-              , Literal (Int 8)
-              , Negated (Literal (Int 10))
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Negated (Literal (Int 5)))
+              , Reg (Literal (Int 6))
+              , Reg (Negated (Literal (Int 7)))
+              , Reg (Literal (Int 8))
+              , Reg (Negated (Literal (Int 10)))
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/array-34.out b/test/out/compiler/array-34.out
--- a/test/out/compiler/array-34.out
+++ b/test/out/compiler/array-34.out
@@ -60,7 +60,7 @@
        [ NormalArg
            (FuncCall
               (FieldAccess
-                 (Ident (Identifier "zip")) (Array [ Literal (Int 1) ]))
+                 (Ident (Identifier "zip")) (Array [ Reg (Literal (Int 1)) ]))
               [ NormalArg (Array []) ])
        , NormalArg (Array [])
        ])
@@ -73,9 +73,11 @@
        [ NormalArg
            (FuncCall
               (FieldAccess
-                 (Ident (Identifier "zip")) (Array [ Literal (Int 1) ]))
-              [ NormalArg (Array [ Literal (Int 2) ]) ])
-       , NormalArg (Array [ Array [ Literal (Int 1) , Literal (Int 2) ] ])
+                 (Ident (Identifier "zip")) (Array [ Reg (Literal (Int 1)) ]))
+              [ NormalArg (Array [ Reg (Literal (Int 2)) ]) ])
+       , NormalArg
+           (Array
+              [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]) ])
        ])
 , SoftBreak
 , Code
@@ -87,12 +89,14 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "zip"))
-                 (Array [ Literal (Int 1) , Literal (Int 2) ]))
-              [ NormalArg (Array [ Literal (Int 3) , Literal (Int 4) ]) ])
+                 (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
+              [ NormalArg
+                  (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ])
+              ])
        , NormalArg
            (Array
-              [ Array [ Literal (Int 1) , Literal (Int 3) ]
-              , Array [ Literal (Int 2) , Literal (Int 4) ]
+              [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 3)) ])
+              , Reg (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 4)) ])
               ])
        ])
 , SoftBreak
@@ -106,16 +110,18 @@
               (FieldAccess
                  (Ident (Identifier "zip"))
                  (Array
-                    [ Literal (Int 1)
-                    , Literal (Int 2)
-                    , Literal (Int 3)
-                    , Literal (Int 4)
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    , Reg (Literal (Int 4))
                     ]))
-              [ NormalArg (Array [ Literal (Int 5) , Literal (Int 6) ]) ])
+              [ NormalArg
+                  (Array [ Reg (Literal (Int 5)) , Reg (Literal (Int 6)) ])
+              ])
        , NormalArg
            (Array
-              [ Array [ Literal (Int 1) , Literal (Int 5) ]
-              , Array [ Literal (Int 2) , Literal (Int 6) ]
+              [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 5)) ])
+              , Reg (Array [ Reg (Literal (Int 2)) , Reg (Literal (Int 6)) ])
               ])
        ])
 , SoftBreak
@@ -129,13 +135,20 @@
               (FieldAccess
                  (Ident (Identifier "zip"))
                  (Array
-                    [ Array [ Literal (Int 1) , Literal (Int 2) ] , Literal (Int 3) ]))
-              [ NormalArg (Array [ Literal (Int 4) , Literal (Int 5) ]) ])
+                    [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
+                    , Reg (Literal (Int 3))
+                    ]))
+              [ NormalArg
+                  (Array [ Reg (Literal (Int 4)) , Reg (Literal (Int 5)) ])
+              ])
        , NormalArg
            (Array
-              [ Array
-                  [ Array [ Literal (Int 1) , Literal (Int 2) ] , Literal (Int 4) ]
-              , Array [ Literal (Int 3) , Literal (Int 5) ]
+              [ Reg
+                  (Array
+                     [ Reg (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
+                     , Reg (Literal (Int 4))
+                     ])
+              , Reg (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 5)) ])
               ])
        ])
 , SoftBreak
@@ -148,14 +161,18 @@
            (FuncCall
               (FieldAccess
                  (Ident (Identifier "zip"))
-                 (Array [ Literal (Int 1) , Literal (String "hi") ]))
+                 (Array [ Reg (Literal (Int 1)) , Reg (Literal (String "hi")) ]))
               [ NormalArg
-                  (Array [ Literal (Boolean True) , Literal (Boolean False) ])
+                  (Array
+                     [ Reg (Literal (Boolean True)) , Reg (Literal (Boolean False)) ])
               ])
        , NormalArg
            (Array
-              [ Array [ Literal (Int 1) , Literal (Boolean True) ]
-              , Array [ Literal (String "hi") , Literal (Boolean False) ]
+              [ Reg
+                  (Array [ Reg (Literal (Int 1)) , Reg (Literal (Boolean True)) ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (String "hi")) , Reg (Literal (Boolean False)) ])
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/block-00.out b/test/out/compiler/block-00.out
--- a/test/out/compiler/block-00.out
+++ b/test/out/compiler/block-00.out
@@ -49,7 +49,10 @@
        (CodeBlock
           [ Let
               (BasicBind (Just (Identifier "parts")))
-              (Array [ Literal (String "my fri") , Literal (String "end.") ])
+              (Array
+                 [ Reg (Literal (String "my fri"))
+                 , Reg (Literal (String "end."))
+                 ])
           , Block (Content [ Text "Hello," , Space ])
           , For
               (BasicBind (Just (Identifier "s")))
diff --git a/test/out/compiler/break-continue-09.out b/test/out/compiler/break-continue-09.out
--- a/test/out/compiler/break-continue-09.out
+++ b/test/out/compiler/break-continue-09.out
@@ -48,10 +48,10 @@
     (For
        (BasicBind (Just (Identifier "color")))
        (Array
-          [ Ident (Identifier "red")
-          , Ident (Identifier "blue")
-          , Ident (Identifier "green")
-          , Ident (Identifier "yellow")
+          [ Reg (Ident (Identifier "red"))
+          , Reg (Ident (Identifier "blue"))
+          , Reg (Ident (Identifier "green"))
+          , Reg (Ident (Identifier "yellow"))
           ])
        (Block
           (Content
diff --git a/test/out/compiler/closure-06.out b/test/out/compiler/closure-06.out
--- a/test/out/compiler/closure-06.out
+++ b/test/out/compiler/closure-06.out
@@ -47,7 +47,11 @@
        (CodeBlock
           [ Let
               (BasicBind (Just (Identifier "v")))
-              (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+              (Array
+                 [ Reg (Literal (Int 1))
+                 , Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 ])
           , LetFunc
               (Identifier "f")
               []
diff --git a/test/out/compiler/content-field-00.out b/test/out/compiler/content-field-00.out
--- a/test/out/compiler/content-field-00.out
+++ b/test/out/compiler/content-field-00.out
@@ -327,5 +327,5 @@
 "test/typ/compiler/content-field-00.typ" (line 42, column 2):
 unexpected end of input
 expecting end of input
-named argument default not defined or VString "unknown math variable: +"
+panicked with: "unknown math variable: +"
 
diff --git a/test/out/compiler/dict-00.out b/test/out/compiler/dict-00.out
--- a/test/out/compiler/dict-00.out
+++ b/test/out/compiler/dict-00.out
@@ -52,8 +52,8 @@
     (Let
        (BasicBind (Just (Identifier "dict")))
        (Dict
-          [ ( Identifier "normal" , Literal (Int 1) )
-          , ( Identifier "spacy key" , Literal (Int 2) )
+          [ Reg ( Identifier "normal" , Literal (Int 1) )
+          , Reg ( Identifier "spacy key" , Literal (Int 2) )
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/dict-01.out b/test/out/compiler/dict-01.out
--- a/test/out/compiler/dict-01.out
+++ b/test/out/compiler/dict-01.out
@@ -48,8 +48,8 @@
           [ Let
               (BasicBind (Just (Identifier "dict")))
               (Dict
-                 [ ( Identifier "a" , Literal (Int 1) )
-                 , ( Identifier "b b" , Literal (Int 1) )
+                 [ Reg ( Identifier "a" , Literal (Int 1) )
+                 , Reg ( Identifier "b b" , Literal (Int 1) )
                  ])
           , Assign
               (FuncCall
@@ -64,22 +64,23 @@
               (FieldAccess
                  (Ident (Identifier "state")) (Ident (Identifier "dict")))
               (Dict
-                 [ ( Identifier "ok" , Literal (Boolean True) )
-                 , ( Identifier "err" , Literal (Boolean False) )
+                 [ Reg ( Identifier "ok" , Literal (Boolean True) )
+                 , Reg ( Identifier "err" , Literal (Boolean False) )
                  ])
           , FuncCall
               (Ident (Identifier "test"))
               [ NormalArg (Ident (Identifier "dict"))
               , NormalArg
                   (Dict
-                     [ ( Identifier "a" , Literal (Int 1) )
-                     , ( Identifier "b b" , Literal (Int 2) )
-                     , ( Identifier "state"
-                       , Dict
-                           [ ( Identifier "ok" , Literal (Boolean True) )
-                           , ( Identifier "err" , Literal (Boolean False) )
-                           ]
-                       )
+                     [ Reg ( Identifier "a" , Literal (Int 1) )
+                     , Reg ( Identifier "b b" , Literal (Int 2) )
+                     , Reg
+                         ( Identifier "state"
+                         , Dict
+                             [ Reg ( Identifier "ok" , Literal (Boolean True) )
+                             , Reg ( Identifier "err" , Literal (Boolean False) )
+                             ]
+                         )
                      ])
               ]
           , FuncCall
diff --git a/test/out/compiler/dict-03.out b/test/out/compiler/dict-03.out
--- a/test/out/compiler/dict-03.out
+++ b/test/out/compiler/dict-03.out
@@ -50,8 +50,8 @@
               (FieldAccess
                  (Ident (Identifier "at"))
                  (Dict
-                    [ ( Identifier "a" , Literal (Int 1) )
-                    , ( Identifier "b" , Literal (Int 2) )
+                    [ Reg ( Identifier "a" , Literal (Int 1) )
+                    , Reg ( Identifier "b" , Literal (Int 2) )
                     ]))
               [ NormalArg (Literal (String "b"))
               , KeyValArg (Identifier "default") (Literal (Int 3))
@@ -69,8 +69,8 @@
               (FieldAccess
                  (Ident (Identifier "at"))
                  (Dict
-                    [ ( Identifier "a" , Literal (Int 1) )
-                    , ( Identifier "b" , Literal (Int 2) )
+                    [ Reg ( Identifier "a" , Literal (Int 1) )
+                    , Reg ( Identifier "b" , Literal (Int 2) )
                     ]))
               [ NormalArg (Literal (String "c"))
               , KeyValArg (Identifier "default") (Literal (Int 3))
diff --git a/test/out/compiler/dict-05.out b/test/out/compiler/dict-05.out
--- a/test/out/compiler/dict-05.out
+++ b/test/out/compiler/dict-05.out
@@ -46,9 +46,9 @@
     (Let
        (BasicBind (Just (Identifier "dict")))
        (Dict
-          [ ( Identifier "a" , Literal (Int 3) )
-          , ( Identifier "c" , Literal (Int 2) )
-          , ( Identifier "b" , Literal (Int 1) )
+          [ Reg ( Identifier "a" , Literal (Int 3) )
+          , Reg ( Identifier "c" , Literal (Int 2) )
+          , Reg ( Identifier "b" , Literal (Int 1) )
           ]))
 , SoftBreak
 , Code
@@ -85,7 +85,11 @@
                  (Ident (Identifier "values")) (Ident (Identifier "dict")))
               [])
        , NormalArg
-           (Array [ Literal (Int 3) , Literal (Int 2) , Literal (Int 1) ])
+           (Array
+              [ Reg (Literal (Int 3))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 1))
+              ])
        ])
 , SoftBreak
 , Code
@@ -150,8 +154,8 @@
        [ NormalArg (Ident (Identifier "dict"))
        , NormalArg
            (Dict
-              [ ( Identifier "a" , Literal (Int 3) )
-              , ( Identifier "b" , Literal (Int 1) )
+              [ Reg ( Identifier "a" , Literal (Int 3) )
+              , Reg ( Identifier "b" , Literal (Int 1) )
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/field-00.out b/test/out/compiler/field-00.out
--- a/test/out/compiler/field-00.out
+++ b/test/out/compiler/field-00.out
@@ -46,8 +46,8 @@
     (Let
        (BasicBind (Just (Identifier "dict")))
        (Dict
-          [ ( Identifier "nothing" , Literal (String "ness") )
-          , ( Identifier "hello" , Literal (String "world") )
+          [ Reg ( Identifier "nothing" , Literal (String "ness") )
+          , Reg ( Identifier "hello" , Literal (String "world") )
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/for-00.out b/test/out/compiler/for-00.out
--- a/test/out/compiler/for-00.out
+++ b/test/out/compiler/for-00.out
@@ -61,8 +61,8 @@
           , Simple (Just (Identifier "v"))
           ])
        (Dict
-          [ ( Identifier "Name" , Literal (String "Typst") )
-          , ( Identifier "Age" , Literal (Int 2) )
+          [ Reg ( Identifier "Name" , Literal (String "Typst") )
+          , Reg ( Identifier "Age" , Literal (Int 2) )
           ])
        (Block
           (Content
@@ -92,10 +92,10 @@
           , For
               (BasicBind (Just (Identifier "v")))
               (Array
-                 [ Literal (Int 1)
-                 , Literal (Int 2)
-                 , Literal (Int 3)
-                 , Literal (Int 4)
+                 [ Reg (Literal (Int 1))
+                 , Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 , Reg (Literal (Int 4))
                  ])
               (Block
                  (CodeBlock
@@ -143,13 +143,13 @@
     (For
        (BasicBind (Just (Identifier "v")))
        (Array
-          [ Literal (Int 1)
-          , Literal (Int 2)
-          , Literal (Int 3)
-          , Literal (Int 4)
-          , Literal (Int 5)
-          , Literal (Int 6)
-          , Literal (Int 7)
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          , Reg (Literal (Int 4))
+          , Reg (Literal (Int 5))
+          , Reg (Literal (Int 6))
+          , Reg (Literal (Int 7))
           ])
        (Block
           (Content
diff --git a/test/out/compiler/for-01.out b/test/out/compiler/for-01.out
--- a/test/out/compiler/for-01.out
+++ b/test/out/compiler/for-01.out
@@ -50,13 +50,18 @@
     ( line 5 , column 2 )
     (For
        (BasicBind (Just (Identifier "v")))
-       (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+       (Array
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          ])
        (Block
           (CodeBlock
              [ Assign
                  (Ident (Identifier "out"))
                  (Plus
-                    (Ident (Identifier "out")) (Array [ Ident (Identifier "v") ]))
+                    (Ident (Identifier "out"))
+                    (Array [ Reg (Ident (Identifier "v")) ]))
              ])))
 , ParBreak
 , Comment
@@ -72,9 +77,9 @@
           (FieldAccess
              (Ident (Identifier "enumerate"))
              (Array
-                [ Literal (String "1")
-                , Literal (String "2")
-                , Literal (String "3")
+                [ Reg (Literal (String "1"))
+                , Reg (Literal (String "2"))
+                , Reg (Literal (String "3"))
                 ]))
           [])
        (Block
@@ -96,15 +101,16 @@
     (For
        (BasicBind (Just (Identifier "v")))
        (Dict
-          [ ( Identifier "a" , Literal (Int 4) )
-          , ( Identifier "b" , Literal (Int 5) )
+          [ Reg ( Identifier "a" , Literal (Int 4) )
+          , Reg ( Identifier "b" , Literal (Int 5) )
           ])
        (Block
           (CodeBlock
              [ Assign
                  (Ident (Identifier "out"))
                  (Plus
-                    (Ident (Identifier "out")) (Array [ Ident (Identifier "v") ]))
+                    (Ident (Identifier "out"))
+                    (Array [ Reg (Ident (Identifier "v")) ]))
              ])))
 , ParBreak
 , Comment
@@ -117,19 +123,21 @@
           , Simple (Just (Identifier "v"))
           ])
        (Dict
-          [ ( Identifier "a" , Literal (Int 6) )
-          , ( Identifier "b" , Literal (Int 7) )
+          [ Reg ( Identifier "a" , Literal (Int 6) )
+          , Reg ( Identifier "b" , Literal (Int 7) )
           ])
        (Block
           (CodeBlock
              [ Assign
                  (Ident (Identifier "out"))
                  (Plus
-                    (Ident (Identifier "out")) (Array [ Ident (Identifier "k") ]))
+                    (Ident (Identifier "out"))
+                    (Array [ Reg (Ident (Identifier "k")) ]))
              , Assign
                  (Ident (Identifier "out"))
                  (Plus
-                    (Ident (Identifier "out")) (Array [ Ident (Identifier "v") ]))
+                    (Ident (Identifier "out"))
+                    (Array [ Reg (Ident (Identifier "v")) ]))
              ])))
 , ParBreak
 , Code
@@ -140,15 +148,17 @@
        [ NormalArg (Ident (Identifier "out"))
        , NormalArg
            (Array
-              [ Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 3)
-              , Array [ Literal (String "a") , Literal (Int 4) ]
-              , Array [ Literal (String "b") , Literal (Int 5) ]
-              , Literal (String "a")
-              , Literal (Int 6)
-              , Literal (String "b")
-              , Literal (Int 7)
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg
+                  (Array [ Reg (Literal (String "a")) , Reg (Literal (Int 4)) ])
+              , Reg
+                  (Array [ Reg (Literal (String "b")) , Reg (Literal (Int 5)) ])
+              , Reg (Literal (String "a"))
+              , Reg (Literal (Int 6))
+              , Reg (Literal (String "b"))
+              , Reg (Literal (Int 7))
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/import-06.out b/test/out/compiler/import-06.out
--- a/test/out/compiler/import-06.out
+++ b/test/out/compiler/import-06.out
@@ -50,7 +50,7 @@
     ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "d")))
-       (Dict [ ( Identifier "e" , Ident (Identifier "enum") ) ]))
+       (Dict [ Reg ( Identifier "e" , Ident (Identifier "enum") ) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/import-06.typ"
diff --git a/test/out/compiler/include-00.out b/test/out/compiler/include-00.out
--- a/test/out/compiler/include-00.out
+++ b/test/out/compiler/include-00.out
@@ -82,10 +82,41 @@
   parbreak(), 
   heading(body: text(body: [Document]), 
           level: 1), 
+  text(body: [
+]), 
   parbreak(), 
+  heading(body: text(body: [Chapter 1]), 
+          level: 2), 
+  text(body: [Klaus]), 
+  text(body: [ stood in a field of wheat. There was nothing of particular interest about
+the field ]), 
+  text(body: [Klaus]), 
+  text(body: [ just casually surveyed for any paths on which the corn would not
+totally ruin his semi-new outdorsy jacket but then again, most of us spend
+considerable time in non-descript environments.]), 
   parbreak(), 
+  parbreak(), 
+  parbreak(), 
   text(body: [– ]), 
   emph(body: text(body: [Intermission])), 
   text(body: [ –
 ]), 
+  text(body: [
+]), 
+  parbreak(), 
+  heading(body: text(body: [Chapter 2]), 
+          level: 2), 
+  text(body: [Their motivations, however, were pretty descript, so to speak. ]), 
+  text(body: [Klaus]), 
+  text(body: [ had not yet
+conceptualized their consequences, but that should change pretty quickly. ]), 
+  text(body: [Klaus]), 
+  text(body: [
+approached the center of the field and picked up a 4-foot long disk made from
+what could only be cow manure. The hair on the back of ]), 
+  text(body: [Klaus]), 
+  text(body: [” neck bristled as
+he stared at the unusual sight. After studying the object for a while, he
+promptly popped the question, “How much?”]), 
+  parbreak(), 
   parbreak() }
diff --git a/test/out/compiler/let-02.out b/test/out/compiler/let-02.out
--- a/test/out/compiler/let-02.out
+++ b/test/out/compiler/let-02.out
@@ -46,7 +46,7 @@
     ( line 4 , column 2 )
     (Let
        (BasicBind (Just (Identifier "a")))
-       (Array [ Literal (Int 1) , Literal (Int 2) ]))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , ParBreak
 ]
 --- evaluated ---
diff --git a/test/out/compiler/let-03.out b/test/out/compiler/let-03.out
--- a/test/out/compiler/let-03.out
+++ b/test/out/compiler/let-03.out
@@ -49,7 +49,7 @@
           [ Simple (Just (Identifier "a"))
           , Simple (Just (Identifier "b"))
           ])
-       (Array [ Literal (Int 1) , Literal (Int 2) ]))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/let-03.typ"
diff --git a/test/out/compiler/let-04.out b/test/out/compiler/let-04.out
--- a/test/out/compiler/let-04.out
+++ b/test/out/compiler/let-04.out
@@ -45,7 +45,7 @@
     ( line 3 , column 2 )
     (Let
        (DestructuringBind [ Simple (Just (Identifier "a")) ])
-       (Array [ Literal (Int 1) ]))
+       (Array [ Reg (Literal (Int 1)) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/let-04.typ"
diff --git a/test/out/compiler/let-05.out b/test/out/compiler/let-05.out
--- a/test/out/compiler/let-05.out
+++ b/test/out/compiler/let-05.out
@@ -52,10 +52,10 @@
           , Simple Nothing
           ])
        (Array
-          [ Literal (Int 1)
-          , Literal (Int 2)
-          , Literal (Int 3)
-          , Literal (Int 4)
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Int 2))
+          , Reg (Literal (Int 3))
+          , Reg (Literal (Int 4))
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/let-06.out b/test/out/compiler/let-06.out
--- a/test/out/compiler/let-06.out
+++ b/test/out/compiler/let-06.out
@@ -51,12 +51,12 @@
           , Sink (Just (Identifier "c"))
           ])
        (Array
-          [ Literal (Int 1)
-          , Literal (Int 2)
-          , Literal (Int 3)
-          , Literal (Int 4)
-          , Literal (Int 5)
-          , Literal (Int 6)
+          [ 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
@@ -85,10 +85,10 @@
        [ NormalArg (Ident (Identifier "c"))
        , NormalArg
            (Array
-              [ Literal (Int 3)
-              , Literal (Int 4)
-              , Literal (Int 5)
-              , Literal (Int 6)
+              [ Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
+              , Reg (Literal (Int 5))
+              , Reg (Literal (Int 6))
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/let-07.out b/test/out/compiler/let-07.out
--- a/test/out/compiler/let-07.out
+++ b/test/out/compiler/let-07.out
@@ -51,12 +51,12 @@
           , Simple (Just (Identifier "c"))
           ])
        (Array
-          [ Literal (Int 1)
-          , Literal (Int 2)
-          , Literal (Int 3)
-          , Literal (Int 4)
-          , Literal (Int 5)
-          , Literal (Int 6)
+          [ 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
@@ -76,10 +76,10 @@
        [ NormalArg (Ident (Identifier "b"))
        , NormalArg
            (Array
-              [ Literal (Int 2)
-              , Literal (Int 3)
-              , Literal (Int 4)
-              , Literal (Int 5)
+              [ Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
+              , Reg (Literal (Int 5))
               ])
        ])
 , SoftBreak
diff --git a/test/out/compiler/let-08.out b/test/out/compiler/let-08.out
--- a/test/out/compiler/let-08.out
+++ b/test/out/compiler/let-08.out
@@ -50,7 +50,7 @@
           , Simple (Just (Identifier "b"))
           , Simple (Just (Identifier "c"))
           ])
-       (Array [ Literal (Int 1) , Literal (Int 2) ]))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/let-08.typ"
diff --git a/test/out/compiler/let-09.out b/test/out/compiler/let-09.out
--- a/test/out/compiler/let-09.out
+++ b/test/out/compiler/let-09.out
@@ -50,7 +50,7 @@
           , Sink (Just (Identifier "b"))
           , Simple (Just (Identifier "c"))
           ])
-       (Array [ Literal (Int 1) , Literal (Int 2) ]))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/let-09.typ"
diff --git a/test/out/compiler/let-10.out b/test/out/compiler/let-10.out
--- a/test/out/compiler/let-10.out
+++ b/test/out/compiler/let-10.out
@@ -50,7 +50,7 @@
           , Simple (Just (Identifier "b"))
           , Sink (Just (Identifier "c"))
           ])
-       (Array [ Literal (Int 1) , Literal (Int 2) ]))
+       (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/let-10.typ"
diff --git a/test/out/compiler/let-16.out b/test/out/compiler/let-16.out
--- a/test/out/compiler/let-16.out
+++ b/test/out/compiler/let-16.out
@@ -51,9 +51,9 @@
           , WithKey (Identifier "x") (Just (Identifier "c"))
           ])
        (Dict
-          [ ( Identifier "a" , Literal (Int 1) )
-          , ( Identifier "b" , Literal (Int 2) )
-          , ( Identifier "x" , Literal (Int 3) )
+          [ Reg ( Identifier "a" , Literal (Int 1) )
+          , Reg ( Identifier "b" , Literal (Int 2) )
+          , Reg ( Identifier "x" , Literal (Int 3) )
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/let-17.out b/test/out/compiler/let-17.out
--- a/test/out/compiler/let-17.out
+++ b/test/out/compiler/let-17.out
@@ -50,9 +50,9 @@
           , Sink (Just (Identifier "b"))
           ])
        (Dict
-          [ ( Identifier "a" , Literal (Int 1) )
-          , ( Identifier "b" , Literal (Int 2) )
-          , ( Identifier "c" , Literal (Int 3) )
+          [ Reg ( Identifier "a" , Literal (Int 1) )
+          , Reg ( Identifier "b" , Literal (Int 2) )
+          , Reg ( Identifier "c" , Literal (Int 3) )
           ]))
 , SoftBreak
 , Code
@@ -63,8 +63,8 @@
        [ NormalArg (Ident (Identifier "b"))
        , NormalArg
            (Dict
-              [ ( Identifier "b" , Literal (Int 2) )
-              , ( Identifier "c" , Literal (Int 3) )
+              [ Reg ( Identifier "b" , Literal (Int 2) )
+              , Reg ( Identifier "c" , Literal (Int 3) )
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/let-18.out b/test/out/compiler/let-18.out
--- a/test/out/compiler/let-18.out
+++ b/test/out/compiler/let-18.out
@@ -51,9 +51,9 @@
           , WithKey (Identifier "c") Nothing
           ])
        (Dict
-          [ ( Identifier "a" , Literal (Int 1) )
-          , ( Identifier "b" , Literal (Int 2) )
-          , ( Identifier "c" , Literal (Int 3) )
+          [ Reg ( Identifier "a" , Literal (Int 1) )
+          , Reg ( Identifier "b" , Literal (Int 2) )
+          , Reg ( Identifier "c" , Literal (Int 3) )
           ]))
 , SoftBreak
 , Code
@@ -62,7 +62,7 @@
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg (Ident (Identifier "b"))
-       , NormalArg (Dict [ ( Identifier "b" , Literal (Int 2) ) ])
+       , NormalArg (Dict [ Reg ( Identifier "b" , Literal (Int 2) ) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/let-19.out b/test/out/compiler/let-19.out
--- a/test/out/compiler/let-19.out
+++ b/test/out/compiler/let-19.out
@@ -49,7 +49,7 @@
           [ WithKey (Identifier "a") Nothing
           , Sink (Just (Identifier "b"))
           ])
-       (Dict [ ( Identifier "a" , Literal (Int 1) ) ]))
+       (Dict [ Reg ( Identifier "a" , Literal (Int 1) ) ]))
 , SoftBreak
 , Code
     "test/typ/compiler/let-19.typ"
diff --git a/test/out/compiler/let-21.out b/test/out/compiler/let-21.out
--- a/test/out/compiler/let-21.out
+++ b/test/out/compiler/let-21.out
@@ -48,8 +48,8 @@
        (DestructuringBind
           [ Simple (Just (Identifier "a")) , Sink Nothing ])
        (Dict
-          [ ( Identifier "a" , Literal (Int 1) )
-          , ( Identifier "b" , Literal (Int 2) )
+          [ Reg ( Identifier "a" , Literal (Int 1) )
+          , Reg ( Identifier "b" , Literal (Int 2) )
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/methods-00.out b/test/out/compiler/methods-00.out
--- a/test/out/compiler/methods-00.out
+++ b/test/out/compiler/methods-00.out
@@ -51,7 +51,8 @@
                  (Ident (Identifier "split")) (Literal (String "Hi there")))
               [])
        , NormalArg
-           (Array [ Literal (String "Hi") , Literal (String "there") ])
+           (Array
+              [ Reg (Literal (String "Hi")) , Reg (Literal (String "there")) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compiler/methods-01.out b/test/out/compiler/methods-01.out
--- a/test/out/compiler/methods-01.out
+++ b/test/out/compiler/methods-01.out
@@ -48,8 +48,16 @@
           [ Let
               (BasicBind (Just (Identifier "matrix")))
               (Array
-                 [ Array [ Array [ Literal (Int 1) ] , Array [ Literal (Int 2) ] ]
-                 , Array [ Array [ Literal (Int 3) ] , Array [ Literal (Int 4) ] ]
+                 [ Reg
+                     (Array
+                        [ Reg (Array [ Reg (Literal (Int 1)) ])
+                        , Reg (Array [ Reg (Literal (Int 2)) ])
+                        ])
+                 , Reg
+                     (Array
+                        [ Reg (Array [ Reg (Literal (Int 3)) ])
+                        , Reg (Array [ Reg (Literal (Int 4)) ])
+                        ])
                  ])
           , FuncCall
               (FieldAccess
@@ -68,11 +76,16 @@
               [ NormalArg (Ident (Identifier "matrix"))
               , NormalArg
                   (Array
-                     [ Array [ Array [ Literal (Int 1) ] , Array [ Literal (Int 2) ] ]
-                     , Array
-                         [ Array [ Literal (Int 3) , Literal (Int 5) ]
-                         , Array [ Literal (Int 4) ]
-                         ]
+                     [ Reg
+                         (Array
+                            [ Reg (Array [ Reg (Literal (Int 1)) ])
+                            , Reg (Array [ Reg (Literal (Int 2)) ])
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 5)) ])
+                            , Reg (Array [ Reg (Literal (Int 4)) ])
+                            ])
                      ])
               ]
           ]))
diff --git a/test/out/compiler/ops-01.out b/test/out/compiler/ops-01.out
--- a/test/out/compiler/ops-01.out
+++ b/test/out/compiler/ops-01.out
@@ -48,13 +48,14 @@
     (For
        (BasicBind (Just (Identifier "v")))
        (Array
-          [ Literal (Int 1)
-          , Literal (Float 3.14)
-          , Literal (Numeric 12.0 Pt)
-          , Literal (Numeric 45.0 Deg)
-          , Literal (Numeric 90.0 Percent)
-          , Plus (Literal (Numeric 13.0 Percent)) (Literal (Numeric 10.0 Pt))
-          , Literal (Numeric 6.3 Fr)
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Float 3.14))
+          , Reg (Literal (Numeric 12.0 Pt))
+          , Reg (Literal (Numeric 45.0 Deg))
+          , Reg (Literal (Numeric 90.0 Percent))
+          , Reg
+              (Plus (Literal (Numeric 13.0 Percent)) (Literal (Numeric 10.0 Pt)))
+          , Reg (Literal (Numeric 6.3 Fr))
           ])
        (Block
           (CodeBlock
@@ -160,14 +161,14 @@
        (Ident (Identifier "test"))
        [ NormalArg
            (Plus
-              (Array [ Literal (Int 1) , Literal (Int 2) ])
-              (Array [ Literal (Int 3) , Literal (Int 4) ]))
+              (Array [ Reg (Literal (Int 1)) , Reg (Literal (Int 2)) ])
+              (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ]))
        , NormalArg
            (Array
-              [ Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 3)
-              , Literal (Int 4)
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
               ])
        ])
 , SoftBreak
@@ -178,16 +179,16 @@
        (Ident (Identifier "test"))
        [ NormalArg
            (Plus
-              (Dict [ ( Identifier "a" , Literal (Int 1) ) ])
+              (Dict [ Reg ( Identifier "a" , Literal (Int 1) ) ])
               (Dict
-                 [ ( Identifier "b" , Literal (Int 2) )
-                 , ( Identifier "c" , Literal (Int 3) )
+                 [ Reg ( Identifier "b" , Literal (Int 2) )
+                 , Reg ( Identifier "c" , Literal (Int 3) )
                  ]))
        , NormalArg
            (Dict
-              [ ( Identifier "a" , Literal (Int 1) )
-              , ( Identifier "b" , Literal (Int 2) )
-              , ( Identifier "c" , Literal (Int 3) )
+              [ Reg ( Identifier "a" , Literal (Int 1) )
+              , Reg ( Identifier "b" , Literal (Int 2) )
+              , Reg ( Identifier "c" , Literal (Int 3) )
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/ops-03.out b/test/out/compiler/ops-03.out
--- a/test/out/compiler/ops-03.out
+++ b/test/out/compiler/ops-03.out
@@ -169,18 +169,20 @@
     (Let
        (BasicBind (Just (Identifier "nums")))
        (Array
-          [ Literal (Int 1)
-          , Literal (Float 3.14)
-          , Literal (Numeric 12.0 Pt)
-          , Literal (Numeric 3.0 Em)
-          , Plus (Literal (Numeric 12.0 Pt)) (Literal (Numeric 3.0 Em))
-          , Literal (Numeric 45.0 Deg)
-          , Literal (Numeric 90.0 Percent)
-          , Plus (Literal (Numeric 13.0 Percent)) (Literal (Numeric 10.0 Pt))
-          , Plus
-              (Plus (Literal (Numeric 5.0 Percent)) (Literal (Numeric 1.0 Em)))
-              (Literal (Numeric 3.0 Pt))
-          , Literal (Numeric 2.3 Fr)
+          [ Reg (Literal (Int 1))
+          , Reg (Literal (Float 3.14))
+          , Reg (Literal (Numeric 12.0 Pt))
+          , Reg (Literal (Numeric 3.0 Em))
+          , Reg (Plus (Literal (Numeric 12.0 Pt)) (Literal (Numeric 3.0 Em)))
+          , Reg (Literal (Numeric 45.0 Deg))
+          , Reg (Literal (Numeric 90.0 Percent))
+          , Reg
+              (Plus (Literal (Numeric 13.0 Percent)) (Literal (Numeric 10.0 Pt)))
+          , Reg
+              (Plus
+                 (Plus (Literal (Numeric 5.0 Percent)) (Literal (Numeric 1.0 Em)))
+                 (Literal (Numeric 3.0 Pt)))
+          , Reg (Literal (Numeric 2.3 Fr))
           ]))
 , ParBreak
 , Code
@@ -280,14 +282,16 @@
     (Let
        (BasicBind (Just (Identifier "dims")))
        (Array
-          [ Literal (Numeric 10.0 Pt)
-          , Literal (Numeric 1.0 Em)
-          , Plus (Literal (Numeric 10.0 Pt)) (Literal (Numeric 1.0 Em))
-          , Literal (Numeric 30.0 Percent)
-          , Plus (Literal (Numeric 50.0 Percent)) (Literal (Numeric 3.0 Cm))
-          , Plus
-              (Plus (Literal (Numeric 40.0 Percent)) (Literal (Numeric 2.0 Em)))
-              (Literal (Numeric 1.0 Cm))
+          [ Reg (Literal (Numeric 10.0 Pt))
+          , Reg (Literal (Numeric 1.0 Em))
+          , Reg (Plus (Literal (Numeric 10.0 Pt)) (Literal (Numeric 1.0 Em)))
+          , Reg (Literal (Numeric 30.0 Percent))
+          , Reg
+              (Plus (Literal (Numeric 50.0 Percent)) (Literal (Numeric 3.0 Cm)))
+          , Reg
+              (Plus
+                 (Plus (Literal (Numeric 40.0 Percent)) (Literal (Numeric 2.0 Em)))
+                 (Literal (Numeric 1.0 Cm)))
           ]))
 , SoftBreak
 , Code
@@ -321,7 +325,7 @@
                        ]))
              , For
                  (BasicBind (Just (Identifier "b")))
-                 (Array [ Literal (Int 7) , Literal (Float 3.14) ])
+                 (Array [ Reg (Literal (Int 7)) , Reg (Literal (Float 3.14)) ])
                  (Block
                     (CodeBlock
                        [ FuncCall
@@ -373,18 +377,18 @@
     (For
        (BasicBind (Just (Identifier "a")))
        (Array
-          [ Literal (Numeric 0.0 Pt)
-          , Literal (Numeric 0.0 Em)
-          , Literal (Numeric 0.0 Percent)
+          [ Reg (Literal (Numeric 0.0 Pt))
+          , Reg (Literal (Numeric 0.0 Em))
+          , Reg (Literal (Numeric 0.0 Percent))
           ])
        (Block
           (CodeBlock
              [ For
                  (BasicBind (Just (Identifier "b")))
                  (Array
-                    [ Literal (Numeric 10.0 Pt)
-                    , Literal (Numeric 10.0 Em)
-                    , Literal (Numeric 10.0 Percent)
+                    [ Reg (Literal (Numeric 10.0 Pt))
+                    , Reg (Literal (Numeric 10.0 Em))
+                    , Reg (Literal (Numeric 10.0 Percent))
                     ])
                  (Block
                     (CodeBlock
diff --git a/test/out/compiler/ops-08.out b/test/out/compiler/ops-08.out
--- a/test/out/compiler/ops-08.out
+++ b/test/out/compiler/ops-08.out
@@ -113,7 +113,7 @@
     ( line 11 , column 2 )
     (FuncCall
        (Ident (Identifier "test"))
-       [ NormalArg (Equals (Array []) (Array [ Literal (Int 1) ]))
+       [ NormalArg (Equals (Array []) (Array [ Reg (Literal (Int 1)) ]))
        , NormalArg (Literal (Boolean False))
        ])
 , SoftBreak
@@ -124,10 +124,14 @@
        (Ident (Identifier "test"))
        [ NormalArg
            (Equals
-              (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+              (Array
+                 [ Reg (Literal (Int 1))
+                 , Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 ])
               (Plus
-                 (Array [ Literal (Int 1) , Literal (Float 2.0) ])
-                 (Array [ Literal (Int 3) ])))
+                 (Array [ Reg (Literal (Int 1)) , Reg (Literal (Float 2.0)) ])
+                 (Array [ Reg (Literal (Int 3)) ])))
        , NormalArg (Literal (Boolean True))
        ])
 , SoftBreak
@@ -137,7 +141,8 @@
     (FuncCall
        (Ident (Identifier "test"))
        [ NormalArg
-           (Equals (Dict []) (Dict [ ( Identifier "a" , Literal (Int 1) ) ]))
+           (Equals
+              (Dict []) (Dict [ Reg ( Identifier "a" , Literal (Int 1) ) ]))
        , NormalArg (Literal (Boolean False))
        ])
 , SoftBreak
@@ -149,14 +154,13 @@
        [ NormalArg
            (Equals
               (Dict
-                 [ ( Identifier "a"
-                   , Minus (Literal (Int 2)) (Literal (Float 1.0))
-                   )
-                 , ( Identifier "b" , Literal (Int 2) )
+                 [ Reg
+                     ( Identifier "a" , Minus (Literal (Int 2)) (Literal (Float 1.0)) )
+                 , Reg ( Identifier "b" , Literal (Int 2) )
                  ])
               (Dict
-                 [ ( Identifier "b" , Literal (Int 2) )
-                 , ( Identifier "a" , Literal (Int 1) )
+                 [ Reg ( Identifier "b" , Literal (Int 2) )
+                 , Reg ( Identifier "a" , Literal (Int 1) )
                  ]))
        , NormalArg (Literal (Boolean True))
        ])
diff --git a/test/out/compiler/ops-13.out b/test/out/compiler/ops-13.out
--- a/test/out/compiler/ops-13.out
+++ b/test/out/compiler/ops-13.out
@@ -59,9 +59,9 @@
            (InCollection
               (Literal (String "hi"))
               (Array
-                 [ Literal (String "we")
-                 , Literal (String "hi")
-                 , Literal (String "bye")
+                 [ Reg (Literal (String "we"))
+                 , Reg (Literal (String "hi"))
+                 , Reg (Literal (String "bye"))
                  ]))
        , NormalArg (Literal (Boolean True))
        ])
@@ -131,7 +131,7 @@
        [ NormalArg
            (InCollection
               (Literal (String "key"))
-              (Dict [ ( Identifier "key" , Literal (String "value") ) ]))
+              (Dict [ Reg ( Identifier "key" , Literal (String "value") ) ]))
        , NormalArg (Literal (Boolean True))
        ])
 , SoftBreak
@@ -143,7 +143,7 @@
        [ NormalArg
            (InCollection
               (Literal (String "value"))
-              (Dict [ ( Identifier "key" , Literal (String "value") ) ]))
+              (Dict [ Reg ( Identifier "key" , Literal (String "value") ) ]))
        , NormalArg (Literal (Boolean False))
        ])
 , SoftBreak
diff --git a/test/out/compiler/ops-prec-03.out b/test/out/compiler/ops-prec-03.out
--- a/test/out/compiler/ops-prec-03.out
+++ b/test/out/compiler/ops-prec-03.out
@@ -49,7 +49,11 @@
            (Not
               (InCollection
                  (Negated (Literal (Int 1)))
-                 (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])))
+                 (Array
+                    [ Reg (Literal (Int 1))
+                    , Reg (Literal (Int 2))
+                    , Reg (Literal (Int 3))
+                    ])))
        , NormalArg (Literal (Boolean True))
        ])
 , ParBreak
diff --git a/test/out/compiler/set-04.out b/test/out/compiler/set-04.out
--- a/test/out/compiler/set-04.out
+++ b/test/out/compiler/set-04.out
@@ -46,9 +46,9 @@
     (Let
        (BasicBind (Just (Identifier "choice")))
        (Array
-          [ Literal (String "monkey.svg")
-          , Literal (String "rhino.png")
-          , Literal (String "tiger.jpg")
+          [ Reg (Literal (String "monkey.svg"))
+          , Reg (Literal (String "rhino.png"))
+          , Reg (Literal (String "tiger.jpg"))
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/show-selector-00.out b/test/out/compiler/show-selector-00.out
--- a/test/out/compiler/show-selector-00.out
+++ b/test/out/compiler/show-selector-00.out
@@ -55,12 +55,12 @@
           [ KeyValArg (Identifier "radius") (Literal (Numeric 2.0 Pt))
           , KeyValArg
               (Identifier "outset")
-              (Dict [ ( Identifier "y" , Literal (Numeric 2.5 Pt) ) ])
+              (Dict [ Reg ( Identifier "y" , Literal (Numeric 2.5 Pt) ) ])
           , KeyValArg
               (Identifier "inset")
               (Dict
-                 [ ( Identifier "x" , Literal (Numeric 3.0 Pt) )
-                 , ( Identifier "y" , Literal (Numeric 0.0 Pt) )
+                 [ Reg ( Identifier "x" , Literal (Numeric 3.0 Pt) )
+                 , Reg ( Identifier "y" , Literal (Numeric 0.0 Pt) )
                  ])
           , KeyValArg
               (Identifier "fill")
@@ -91,12 +91,13 @@
           , KeyValArg
               (Identifier "stroke")
               (Dict
-                 [ ( Identifier "left"
-                   , Plus
-                       (Literal (Numeric 1.5 Pt))
-                       (FuncCall
-                          (Ident (Identifier "luma")) [ NormalArg (Literal (Int 180)) ])
-                   )
+                 [ Reg
+                     ( Identifier "left"
+                     , Plus
+                         (Literal (Numeric 1.5 Pt))
+                         (FuncCall
+                            (Ident (Identifier "luma")) [ NormalArg (Literal (Int 180)) ])
+                     )
                  ])
           ]))
 , ParBreak
@@ -107,7 +108,7 @@
        (Ident (Identifier "page"))
        [ KeyValArg
            (Identifier "margin")
-           (Dict [ ( Identifier "top" , Literal (Numeric 12.0 Pt) ) ])
+           (Dict [ Reg ( Identifier "top" , Literal (Numeric 12.0 Pt) ) ])
        ])
 , SoftBreak
 , Code
diff --git a/test/out/compiler/spread-03.out b/test/out/compiler/spread-03.out
--- a/test/out/compiler/spread-03.out
+++ b/test/out/compiler/spread-03.out
@@ -48,10 +48,10 @@
           [ Let
               (BasicBind (Just (Identifier "more")))
               (Array
-                 [ Literal (Int 3)
-                 , Negated (Literal (Int 3))
-                 , Literal (Int 6)
-                 , Literal (Int 10)
+                 [ Reg (Literal (Int 3))
+                 , Reg (Negated (Literal (Int 3)))
+                 , Reg (Literal (Int 6))
+                 , Reg (Literal (Int 10))
                  ])
           , FuncCall
               (Ident (Identifier "test"))
@@ -97,8 +97,8 @@
           [ Let
               (BasicBind (Just (Identifier "more")))
               (Dict
-                 [ ( Identifier "c" , Literal (Int 3) )
-                 , ( Identifier "d" , Literal (Int 4) )
+                 [ Reg ( Identifier "c" , Literal (Int 3) )
+                 , Reg ( Identifier "d" , Literal (Int 4) )
                  ])
           , LetFunc
               (Identifier "tostr")
diff --git a/test/out/compiler/spread-09.out b/test/out/compiler/spread-09.out
--- a/test/out/compiler/spread-09.out
+++ b/test/out/compiler/spread-09.out
@@ -1,3 +1,3 @@
-"test/typ/compiler/spread-09.typ" (line 6, column 10):
-unexpected "."
-expecting digit
+"test/typ/compiler/spread-09.typ" (line 14, column 9):
+unexpected ":"
+expecting "//", "/*", "none", "auto", "true", "false", "0b", "0x", "0o", digit, ".", "\"", "let", "set", "show", "if", "while", "for", "import", "include", "break", "continue", "return", "(", "$", "<", "{" or "["
diff --git a/test/out/compiler/spread-12.out b/test/out/compiler/spread-12.out
--- a/test/out/compiler/spread-12.out
+++ b/test/out/compiler/spread-12.out
@@ -50,7 +50,8 @@
               [ SinkParam (Just (Identifier "a"))
               , NormalParam (Identifier "b")
               ]
-              (Array [ Ident (Identifier "a") , Ident (Identifier "b") ])
+              (Array
+                 [ Reg (Ident (Identifier "a")) , Reg (Ident (Identifier "b")) ])
           , FuncCall
               (Ident (Identifier "test"))
               [ NormalArg
diff --git a/test/out/compiler/spread-13.out b/test/out/compiler/spread-13.out
--- a/test/out/compiler/spread-13.out
+++ b/test/out/compiler/spread-13.out
@@ -52,9 +52,9 @@
               , NormalParam (Identifier "c")
               ]
               (Array
-                 [ Ident (Identifier "a")
-                 , Ident (Identifier "b")
-                 , Ident (Identifier "c")
+                 [ Reg (Ident (Identifier "a"))
+                 , Reg (Ident (Identifier "b"))
+                 , Reg (Ident (Identifier "c"))
                  ])
           , FuncCall
               (Ident (Identifier "test"))
diff --git a/test/out/compiler/string-09.out b/test/out/compiler/string-09.out
--- a/test/out/compiler/string-09.out
+++ b/test/out/compiler/string-09.out
@@ -52,9 +52,9 @@
               [])
        , NormalArg
            (Array
-              [ Literal (String "a")
-              , Literal (String "b")
-              , Literal (String "c")
+              [ Reg (Literal (String "a"))
+              , Reg (Literal (String "b"))
+              , Reg (Literal (String "c"))
               ])
        ])
 , SoftBreak
@@ -70,9 +70,9 @@
               [])
        , NormalArg
            (Array
-              [ Literal (String "a")
-              , Literal (String "b")
-              , Literal (String "c")
+              [ Reg (Literal (String "a"))
+              , Reg (Literal (String "b"))
+              , Reg (Literal (String "c"))
               ])
        ])
 , SoftBreak
@@ -89,8 +89,8 @@
               [])
        , NormalArg
            (Array
-              [ Literal (String "\127987\65039\8205\127752")
-              , Literal (String "!")
+              [ Reg (Literal (String "\127987\65039\8205\127752"))
+              , Reg (Literal (String "!"))
               ])
        ])
 , SoftBreak
@@ -107,11 +107,11 @@
               [])
        , NormalArg
            (Array
-              [ Literal (String "\127987")
-              , Literal (String "\65039")
-              , Literal (String "\8205")
-              , Literal (String "\127752")
-              , Literal (String "!")
+              [ Reg (Literal (String "\127987"))
+              , Reg (Literal (String "\65039"))
+              , Reg (Literal (String "\8205"))
+              , Reg (Literal (String "\127752"))
+              , Reg (Literal (String "!"))
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/string-13.out b/test/out/compiler/string-13.out
--- a/test/out/compiler/string-13.out
+++ b/test/out/compiler/string-13.out
@@ -70,10 +70,10 @@
               ])
        , NormalArg
            (Dict
-              [ ( Identifier "start" , Literal (Int 4) )
-              , ( Identifier "end" , Literal (Int 8) )
-              , ( Identifier "text" , Literal (String "time") )
-              , ( Identifier "captures" , Array [] )
+              [ Reg ( Identifier "start" , Literal (Int 4) )
+              , Reg ( Identifier "end" , Literal (Int 8) )
+              , Reg ( Identifier "text" , Literal (String "time") )
+              , Reg ( Identifier "captures" , Array [] )
               ])
        ])
 , ParBreak
@@ -103,18 +103,20 @@
               [ NormalArg (Literal (String "Day")) ])
        , NormalArg
            (Array
-              [ Dict
-                  [ ( Identifier "start" , Literal (Int 0) )
-                  , ( Identifier "end" , Literal (Int 3) )
-                  , ( Identifier "text" , Literal (String "Day") )
-                  , ( Identifier "captures" , Array [] )
-                  ]
-              , Dict
-                  [ ( Identifier "start" , Literal (Int 7) )
-                  , ( Identifier "end" , Literal (Int 10) )
-                  , ( Identifier "text" , Literal (String "Day") )
-                  , ( Identifier "captures" , Array [] )
-                  ]
+              [ Reg
+                  (Dict
+                     [ Reg ( Identifier "start" , Literal (Int 0) )
+                     , Reg ( Identifier "end" , Literal (Int 3) )
+                     , Reg ( Identifier "text" , Literal (String "Day") )
+                     , Reg ( Identifier "captures" , Array [] )
+                     ])
+              , Reg
+                  (Dict
+                     [ Reg ( Identifier "start" , Literal (Int 7) )
+                     , Reg ( Identifier "end" , Literal (Int 10) )
+                     , Reg ( Identifier "text" , Literal (String "Day") )
+                     , Reg ( Identifier "captures" , Array [] )
+                     ])
               ])
        ])
 , ParBreak
diff --git a/test/out/compiler/string-18.out b/test/out/compiler/string-18.out
--- a/test/out/compiler/string-18.out
+++ b/test/out/compiler/string-18.out
@@ -53,10 +53,10 @@
     (Let
        (BasicBind (Just (Identifier "array")))
        (Array
-          [ Literal (String "Typst")
-          , Literal (String "LaTeX")
-          , Literal (String "Word")
-          , Literal (String "InDesign")
+          [ Reg (Literal (String "Typst"))
+          , Reg (Literal (String "LaTeX"))
+          , Reg (Literal (String "Word"))
+          , Reg (Literal (String "InDesign"))
           ]))
 , SoftBreak
 , Code
diff --git a/test/out/compiler/string-20.out b/test/out/compiler/string-20.out
--- a/test/out/compiler/string-20.out
+++ b/test/out/compiler/string-20.out
@@ -51,11 +51,11 @@
               [ NormalArg (Literal (String "")) ])
        , NormalArg
            (Array
-              [ Literal (String "")
-              , Literal (String "a")
-              , Literal (String "b")
-              , Literal (String "c")
-              , Literal (String "")
+              [ Reg (Literal (String ""))
+              , Reg (Literal (String "a"))
+              , Reg (Literal (String "b"))
+              , Reg (Literal (String "c"))
+              , Reg (Literal (String ""))
               ])
        ])
 , SoftBreak
@@ -68,7 +68,8 @@
            (FuncCall
               (FieldAccess (Ident (Identifier "split")) (Literal (String "abc")))
               [ NormalArg (Literal (String "b")) ])
-       , NormalArg (Array [ Literal (String "a") , Literal (String "c") ])
+       , NormalArg
+           (Array [ Reg (Literal (String "a")) , Reg (Literal (String "c")) ])
        ])
 , SoftBreak
 , Code
@@ -87,10 +88,10 @@
               ])
        , NormalArg
            (Array
-              [ Literal (String "a")
-              , Literal (String "")
-              , Literal (String "")
-              , Literal (String "c")
+              [ Reg (Literal (String "a"))
+              , Reg (Literal (String ""))
+              , Reg (Literal (String ""))
+              , Reg (Literal (String "c"))
               ])
        ])
 , SoftBreak
@@ -108,7 +109,8 @@
                      (Ident (Identifier "regex"))
                      [ NormalArg (Literal (String "\\d+")) ])
               ])
-       , NormalArg (Array [ Literal (String "a") , Literal (String "c") ])
+       , NormalArg
+           (Array [ Reg (Literal (String "a")) , Reg (Literal (String "c")) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/compute/calc-36.out b/test/out/compute/calc-36.out
--- a/test/out/compute/calc-36.out
+++ b/test/out/compute/calc-36.out
@@ -50,10 +50,10 @@
               (Ident (Identifier "range")) [ NormalArg (Literal (Int 4)) ])
        , NormalArg
            (Array
-              [ Literal (Int 0)
-              , Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 3)
+              [ Reg (Literal (Int 0))
+              , Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
               ])
        ])
 , SoftBreak
@@ -67,7 +67,11 @@
               (Ident (Identifier "range"))
               [ NormalArg (Literal (Int 1)) , NormalArg (Literal (Int 4)) ])
        , NormalArg
-           (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+           (Array
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              ])
        ])
 , SoftBreak
 , Code
@@ -83,12 +87,12 @@
               ])
        , NormalArg
            (Array
-              [ Negated (Literal (Int 4))
-              , Negated (Literal (Int 3))
-              , Negated (Literal (Int 2))
-              , Negated (Literal (Int 1))
-              , Literal (Int 0)
-              , Literal (Int 1)
+              [ Reg (Negated (Literal (Int 4)))
+              , Reg (Negated (Literal (Int 3)))
+              , Reg (Negated (Literal (Int 2)))
+              , Reg (Negated (Literal (Int 1)))
+              , Reg (Literal (Int 0))
+              , Reg (Literal (Int 1))
               ])
        ])
 , SoftBreak
@@ -117,10 +121,10 @@
               ])
        , NormalArg
            (Array
-              [ Literal (Int 0)
-              , Literal (Int 3)
-              , Literal (Int 6)
-              , Literal (Int 9)
+              [ Reg (Literal (Int 0))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 6))
+              , Reg (Literal (Int 9))
               ])
        ])
 , SoftBreak
@@ -137,7 +141,11 @@
               , KeyValArg (Identifier "step") (Literal (Int 1))
               ])
        , NormalArg
-           (Array [ Literal (Int 1) , Literal (Int 2) , Literal (Int 3) ])
+           (Array
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              ])
        ])
 , SoftBreak
 , Code
@@ -154,10 +162,10 @@
               ])
        , NormalArg
            (Array
-              [ Literal (Int 1)
-              , Literal (Int 3)
-              , Literal (Int 5)
-              , Literal (Int 7)
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 5))
+              , Reg (Literal (Int 7))
               ])
        ])
 , SoftBreak
@@ -174,7 +182,11 @@
               , KeyValArg (Identifier "step") (Negated (Literal (Int 1)))
               ])
        , NormalArg
-           (Array [ Literal (Int 5) , Literal (Int 4) , Literal (Int 3) ])
+           (Array
+              [ Reg (Literal (Int 5))
+              , Reg (Literal (Int 4))
+              , Reg (Literal (Int 3))
+              ])
        ])
 , SoftBreak
 , Code
@@ -191,10 +203,10 @@
               ])
        , NormalArg
            (Array
-              [ Literal (Int 10)
-              , Literal (Int 7)
-              , Literal (Int 4)
-              , Literal (Int 1)
+              [ Reg (Literal (Int 10))
+              , Reg (Literal (Int 7))
+              , Reg (Literal (Int 4))
+              , Reg (Literal (Int 1))
               ])
        ])
 , ParBreak
diff --git a/test/out/compute/construct-07.out b/test/out/compute/construct-07.out
--- a/test/out/compute/construct-07.out
+++ b/test/out/compute/construct-07.out
@@ -49,15 +49,25 @@
           (Ident (Identifier "symbol"))
           [ NormalArg (Literal (String "\128386"))
           , NormalArg
-              (Array [ Literal (String "stamped") , Literal (String "\128387") ])
+              (Array
+                 [ Reg (Literal (String "stamped"))
+                 , Reg (Literal (String "\128387"))
+                 ])
           , NormalArg
               (Array
-                 [ Literal (String "stamped.pen") , Literal (String "\128390") ])
+                 [ Reg (Literal (String "stamped.pen"))
+                 , Reg (Literal (String "\128390"))
+                 ])
           , NormalArg
               (Array
-                 [ Literal (String "lightning") , Literal (String "\128388") ])
+                 [ Reg (Literal (String "lightning"))
+                 , Reg (Literal (String "\128388"))
+                 ])
           , NormalArg
-              (Array [ Literal (String "fly") , Literal (String "\128389") ])
+              (Array
+                 [ Reg (Literal (String "fly"))
+                 , Reg (Literal (String "\128389"))
+                 ])
           ]))
 , ParBreak
 , Code
diff --git a/test/out/compute/construct-11.out b/test/out/compute/construct-11.out
--- a/test/out/compute/construct-11.out
+++ b/test/out/compute/construct-11.out
@@ -49,7 +49,11 @@
               (FuncCall
                  (Ident (Identifier "range"))
                  [ NormalArg (Literal (Int 2)) , NormalArg (Literal (Int 5)) ])
-              (Array [ Literal (Int 2) , Literal (Int 3) , Literal (Int 4) ]))
+              (Array
+                 [ Reg (Literal (Int 2))
+                 , Reg (Literal (Int 3))
+                 , Reg (Literal (Int 4))
+                 ]))
        ])
 , ParBreak
 ]
diff --git a/test/out/compute/data-08.out b/test/out/compute/data-08.out
--- a/test/out/compute/data-08.out
+++ b/test/out/compute/data-08.out
@@ -115,10 +115,10 @@
               (Ident (Identifier "array")) (Ident (Identifier "data")))
        , NormalArg
            (Array
-              [ Literal (Int 1)
-              , Literal (String "string")
-              , Literal (Float 3.0)
-              , Literal (Boolean False)
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (String "string"))
+              , Reg (Literal (Float 3.0))
+              , Reg (Literal (Boolean False))
               ])
        ])
 , SoftBreak
@@ -132,8 +132,8 @@
               (Ident (Identifier "inline_table")) (Ident (Identifier "data")))
        , NormalArg
            (Dict
-              [ ( Identifier "first" , Literal (String "amazing") )
-              , ( Identifier "second" , Literal (String "greater") )
+              [ Reg ( Identifier "first" , Literal (String "amazing") )
+              , Reg ( Identifier "second" , Literal (String "greater") )
               ])
        ])
 , SoftBreak
@@ -162,9 +162,9 @@
                  (Ident (Identifier "table")) (Ident (Identifier "data"))))
        , NormalArg
            (Array
-              [ Literal (Boolean False)
-              , Literal (String "indeed")
-              , Literal (Int 7)
+              [ Reg (Literal (Boolean False))
+              , Reg (Literal (String "indeed"))
+              , Reg (Literal (Int 7))
               ])
        ])
 , ParBreak
diff --git a/test/out/compute/data-10.out b/test/out/compute/data-10.out
--- a/test/out/compute/data-10.out
+++ b/test/out/compute/data-10.out
@@ -71,7 +71,7 @@
        [ NormalArg
            (FieldAccess
               (Ident (Identifier "null_key")) (Ident (Identifier "data")))
-       , NormalArg (Array [ Literal None , Literal None ])
+       , NormalArg (Array [ Reg (Literal None) , Reg (Literal None) ])
        ])
 , SoftBreak
 , Code
@@ -117,8 +117,8 @@
               (Ident (Identifier "mapping")) (Ident (Identifier "data")))
        , NormalArg
            (Dict
-              [ ( Identifier "1" , Literal (String "one") )
-              , ( Identifier "2" , Literal (String "two") )
+              [ Reg ( Identifier "1" , Literal (String "one") )
+              , Reg ( Identifier "2" , Literal (String "two") )
               ])
        ])
 , SoftBreak
@@ -132,10 +132,10 @@
               (Ident (Identifier "seq")) (Ident (Identifier "data")))
        , NormalArg
            (Array
-              [ Literal (Int 1)
-              , Literal (Int 2)
-              , Literal (Int 3)
-              , Literal (Int 4)
+              [ Reg (Literal (Int 1))
+              , Reg (Literal (Int 2))
+              , Reg (Literal (Int 3))
+              , Reg (Literal (Int 4))
               ])
        ])
 , SoftBreak
diff --git a/test/out/compute/data-12.out b/test/out/compute/data-12.out
--- a/test/out/compute/data-12.out
+++ b/test/out/compute/data-12.out
@@ -57,49 +57,68 @@
        [ NormalArg (Ident (Identifier "data"))
        , NormalArg
            (Array
-              [ Dict
-                  [ ( Identifier "tag" , Literal (String "data") )
-                  , ( Identifier "attrs" , Dict [] )
-                  , ( Identifier "children"
-                    , Array
-                        [ Literal (String "\n  ")
-                        , Dict
-                            [ ( Identifier "tag" , Literal (String "hello") )
-                            , ( Identifier "attrs"
-                              , Dict [ ( Identifier "name" , Literal (String "hi") ) ]
-                              )
-                            , ( Identifier "children" , Array [ Literal (String "1") ] )
-                            ]
-                        , Literal (String "\n  ")
-                        , Dict
-                            [ ( Identifier "tag" , Literal (String "data") )
-                            , ( Identifier "attrs" , Dict [] )
-                            , ( Identifier "children"
-                              , Array
-                                  [ Literal (String "\n    ")
-                                  , Dict
-                                      [ ( Identifier "tag" , Literal (String "hello") )
-                                      , ( Identifier "attrs" , Dict [] )
-                                      , ( Identifier "children"
-                                        , Array [ Literal (String "World") ]
+              [ Reg
+                  (Dict
+                     [ Reg ( Identifier "tag" , Literal (String "data") )
+                     , Reg ( Identifier "attrs" , Dict [] )
+                     , Reg
+                         ( Identifier "children"
+                         , Array
+                             [ Reg (Literal (String "\n  "))
+                             , Reg
+                                 (Dict
+                                    [ Reg ( Identifier "tag" , Literal (String "hello") )
+                                    , Reg
+                                        ( Identifier "attrs"
+                                        , Dict [ Reg ( Identifier "name" , Literal (String "hi") ) ]
                                         )
-                                      ]
-                                  , Literal (String "\n    ")
-                                  , Dict
-                                      [ ( Identifier "tag" , Literal (String "hello") )
-                                      , ( Identifier "attrs" , Dict [] )
-                                      , ( Identifier "children"
-                                        , Array [ Literal (String "World") ]
+                                    , Reg
+                                        ( Identifier "children"
+                                        , Array [ Reg (Literal (String "1")) ]
                                         )
-                                      ]
-                                  , Literal (String "\n  ")
-                                  ]
-                              )
-                            ]
-                        , Literal (String "\n")
-                        ]
-                    )
-                  ]
+                                    ])
+                             , Reg (Literal (String "\n  "))
+                             , Reg
+                                 (Dict
+                                    [ Reg ( Identifier "tag" , Literal (String "data") )
+                                    , Reg ( Identifier "attrs" , Dict [] )
+                                    , Reg
+                                        ( Identifier "children"
+                                        , Array
+                                            [ Reg (Literal (String "\n    "))
+                                            , Reg
+                                                (Dict
+                                                   [ Reg
+                                                       ( Identifier "tag"
+                                                       , Literal (String "hello")
+                                                       )
+                                                   , Reg ( Identifier "attrs" , Dict [] )
+                                                   , Reg
+                                                       ( Identifier "children"
+                                                       , Array [ Reg (Literal (String "World")) ]
+                                                       )
+                                                   ])
+                                            , Reg (Literal (String "\n    "))
+                                            , Reg
+                                                (Dict
+                                                   [ Reg
+                                                       ( Identifier "tag"
+                                                       , Literal (String "hello")
+                                                       )
+                                                   , Reg ( Identifier "attrs" , Dict [] )
+                                                   , Reg
+                                                       ( Identifier "children"
+                                                       , Array [ Reg (Literal (String "World")) ]
+                                                       )
+                                                   ])
+                                            , Reg (Literal (String "\n  "))
+                                            ]
+                                        )
+                                    ])
+                             , Reg (Literal (String "\n"))
+                             ]
+                         )
+                     ])
               ])
        ])
 , ParBreak
diff --git a/test/out/compute/foundations-01.out b/test/out/compute/foundations-01.out
--- a/test/out/compute/foundations-01.out
+++ b/test/out/compute/foundations-01.out
@@ -61,7 +61,10 @@
               (Ident (Identifier "repr"))
               [ NormalArg
                   (Array
-                     [ Literal (Int 1) , Literal (Int 2) , Literal (Boolean False) ])
+                     [ Reg (Literal (Int 1))
+                     , Reg (Literal (Int 2))
+                     , Reg (Literal (Boolean False))
+                     ])
               ])
        , NormalArg (Literal (String "(1, 2, false)"))
        ])
diff --git a/test/out/layout/columns-00.out b/test/out/layout/columns-00.out
--- a/test/out/layout/columns-00.out
+++ b/test/out/layout/columns-00.out
@@ -59,8 +59,8 @@
        , KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "Noto Sans Arabic")
-              , Literal (String "Linux Libertine")
+              [ Reg (Literal (String "Noto Sans Arabic"))
+              , Reg (Literal (String "Linux Libertine"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/layout/container-02.out b/test/out/layout/container-02.out
--- a/test/out/layout/container-02.out
+++ b/test/out/layout/container-02.out
@@ -53,13 +53,25 @@
               (Ident (Identifier "path"))
               [ KeyValArg (Identifier "fill") (Ident (Identifier "purple"))
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 30.0 Pt) , Literal (Numeric 30.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 30.0 Pt))
+                     , Reg (Literal (Numeric 30.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 30.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 30.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 30.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 30.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               ])
        ])
 , ParBreak
diff --git a/test/out/layout/enum-numbering-02.out b/test/out/layout/enum-numbering-02.out
--- a/test/out/layout/enum-numbering-02.out
+++ b/test/out/layout/enum-numbering-02.out
@@ -62,9 +62,9 @@
                         (FieldAccess
                            (Ident (Identifier "at"))
                            (Array
-                              [ Ident (Identifier "red")
-                              , Ident (Identifier "green")
-                              , Ident (Identifier "blue")
+                              [ Reg (Ident (Identifier "red"))
+                              , Reg (Ident (Identifier "green"))
+                              , Reg (Ident (Identifier "blue"))
                               ]))
                         [ NormalArg
                             (FuncCall
diff --git a/test/out/layout/grid-1-00.out b/test/out/layout/grid-1-00.out
--- a/test/out/layout/grid-1-00.out
+++ b/test/out/layout/grid-1-00.out
@@ -71,12 +71,13 @@
        [ KeyValArg
            (Identifier "columns")
            (Array
-              [ Literal Auto
-              , Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 3.0 Fr)
-              , Literal (Numeric 0.25 Cm)
-              , Literal (Numeric 3.0 Percent)
-              , Plus (Literal (Numeric 2.0 Mm)) (Literal (Numeric 10.0 Percent))
+              [ Reg (Literal Auto)
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 3.0 Fr))
+              , Reg (Literal (Numeric 0.25 Cm))
+              , Reg (Literal (Numeric 3.0 Percent))
+              , Reg
+                  (Plus (Literal (Numeric 2.0 Mm)) (Literal (Numeric 10.0 Percent)))
               ])
        , NormalArg
            (FuncCall
diff --git a/test/out/layout/grid-1-01.out b/test/out/layout/grid-1-01.out
--- a/test/out/layout/grid-1-01.out
+++ b/test/out/layout/grid-1-01.out
@@ -54,7 +54,10 @@
        [ KeyValArg
            (Identifier "columns")
            (Array
-              [ Literal Auto , Literal Auto , Literal (Numeric 40.0 Percent) ])
+              [ Reg (Literal Auto)
+              , Reg (Literal Auto)
+              , Reg (Literal (Numeric 40.0 Percent))
+              ])
        , KeyValArg (Identifier "column-gutter") (Literal (Numeric 1.0 Fr))
        , KeyValArg (Identifier "row-gutter") (Literal (Numeric 1.0 Fr))
        , NormalArg
diff --git a/test/out/layout/grid-1-02.out b/test/out/layout/grid-1-02.out
--- a/test/out/layout/grid-1-02.out
+++ b/test/out/layout/grid-1-02.out
@@ -54,13 +54,13 @@
     (FuncCall
        (Ident (Identifier "grid"))
        [ KeyValArg
-           (Identifier "columns") (Array [ Literal (Numeric 1.0 Fr) ])
+           (Identifier "columns") (Array [ Reg (Literal (Numeric 1.0 Fr)) ])
        , KeyValArg
            (Identifier "rows")
            (Array
-              [ Literal (Numeric 1.0 Fr)
-              , Literal Auto
-              , Literal (Numeric 2.0 Fr)
+              [ Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal Auto)
+              , Reg (Literal (Numeric 2.0 Fr))
               ])
        , NormalArg (Block (Content []))
        , NormalArg
diff --git a/test/out/layout/grid-2-00.out b/test/out/layout/grid-2-00.out
--- a/test/out/layout/grid-2-00.out
+++ b/test/out/layout/grid-2-00.out
@@ -57,9 +57,9 @@
        , KeyValArg
            (Identifier "column-gutter")
            (Array
-              [ Literal (Numeric 2.0 Fr)
-              , Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
+              [ Reg (Literal (Numeric 2.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
               ])
        , KeyValArg (Identifier "row-gutter") (Literal (Numeric 6.0 Pt))
        , NormalArg (Block (Content [ Strong [ Text "Quarter" ] ]))
diff --git a/test/out/layout/grid-3-01.out b/test/out/layout/grid-3-01.out
--- a/test/out/layout/grid-3-01.out
+++ b/test/out/layout/grid-3-01.out
@@ -57,12 +57,15 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Literal (Int 4)) (Array [ Literal (Numeric 1.0 Fr) ]))
+           (Times
+              (Literal (Int 4)) (Array [ Reg (Literal (Numeric 1.0 Fr)) ]))
        , KeyValArg (Identifier "row-gutter") (Literal (Numeric 10.0 Pt))
        , KeyValArg
            (Identifier "column-gutter")
            (Array
-              [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Percent) ])
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Percent))
+              ])
        , NormalArg
            (FuncCall
               (Ident (Identifier "align"))
diff --git a/test/out/layout/grid-3-02.out b/test/out/layout/grid-3-02.out
--- a/test/out/layout/grid-3-02.out
+++ b/test/out/layout/grid-3-02.out
@@ -56,12 +56,15 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Literal (Int 3)) (Array [ Literal (Numeric 1.0 Fr) ]))
+           (Times
+              (Literal (Int 3)) (Array [ Reg (Literal (Numeric 1.0 Fr)) ]))
        , KeyValArg (Identifier "row-gutter") (Literal (Numeric 8.0 Pt))
        , KeyValArg
            (Identifier "column-gutter")
            (Array
-              [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Percent) ])
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Percent))
+              ])
        , NormalArg (Block (Content [ Text "A" ]))
        , NormalArg (Block (Content [ Text "B" ]))
        , NormalArg (Block (Content [ Text "C" ]))
diff --git a/test/out/layout/grid-3-03.out b/test/out/layout/grid-3-03.out
--- a/test/out/layout/grid-3-03.out
+++ b/test/out/layout/grid-3-03.out
@@ -56,12 +56,15 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Literal (Int 4)) (Array [ Literal (Numeric 1.0 Fr) ]))
+           (Times
+              (Literal (Int 4)) (Array [ Reg (Literal (Numeric 1.0 Fr)) ]))
        , KeyValArg (Identifier "row-gutter") (Literal (Numeric 10.0 Pt))
        , KeyValArg
            (Identifier "column-gutter")
            (Array
-              [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Percent) ])
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Percent))
+              ])
        , NormalArg (Block (Content [ Text "A" ]))
        , NormalArg (Block (Content [ Text "B" ]))
        , NormalArg (Block (Content [ Text "C" ]))
diff --git a/test/out/layout/grid-4-00.out b/test/out/layout/grid-4-00.out
--- a/test/out/layout/grid-4-00.out
+++ b/test/out/layout/grid-4-00.out
@@ -47,9 +47,11 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Array [ Literal Auto , Literal (Numeric 60.0 Percent) ])
+           (Array
+              [ Reg (Literal Auto) , Reg (Literal (Numeric 60.0 Percent)) ])
        , KeyValArg
-           (Identifier "rows") (Array [ Literal Auto , Literal Auto ])
+           (Identifier "rows")
+           (Array [ Reg (Literal Auto) , Reg (Literal Auto) ])
        , NormalArg
            (FuncCall
               (Ident (Identifier "rect"))
diff --git a/test/out/layout/grid-4-01.out b/test/out/layout/grid-4-01.out
--- a/test/out/layout/grid-4-01.out
+++ b/test/out/layout/grid-4-01.out
@@ -47,9 +47,10 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Array [ Literal (Numeric 1.0 Fr) ]) (Literal (Int 4)))
+           (Times
+              (Array [ Reg (Literal (Numeric 1.0 Fr)) ]) (Literal (Int 4)))
        , KeyValArg
-           (Identifier "rows") (Array [ Literal (Numeric 1.0 Cm) ])
+           (Identifier "rows") (Array [ Reg (Literal (Numeric 1.0 Cm)) ])
        , NormalArg
            (FuncCall
               (Ident (Identifier "rect"))
diff --git a/test/out/layout/grid-4-02.out b/test/out/layout/grid-4-02.out
--- a/test/out/layout/grid-4-02.out
+++ b/test/out/layout/grid-4-02.out
@@ -57,10 +57,10 @@
        [ KeyValArg
            (Identifier "rows")
            (Array
-              [ Literal (Numeric 1.0 Cm)
-              , Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
-              , Literal Auto
+              [ Reg (Literal (Numeric 1.0 Cm))
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal Auto)
               ])
        , NormalArg
            (FuncCall
diff --git a/test/out/layout/list-marker-01.out b/test/out/layout/list-marker-01.out
--- a/test/out/layout/list-marker-01.out
+++ b/test/out/layout/list-marker-01.out
@@ -48,7 +48,9 @@
        [ KeyValArg
            (Identifier "marker")
            (Array
-              [ Block (Content [ EnDash ]) , Block (Content [ Text "\8226" ]) ])
+              [ Reg (Block (Content [ EnDash ]))
+              , Reg (Block (Content [ Text "\8226" ]))
+              ])
        ])
 , SoftBreak
 , BulletListItem
diff --git a/test/out/layout/page-03.out b/test/out/layout/page-03.out
--- a/test/out/layout/page-03.out
+++ b/test/out/layout/page-03.out
@@ -73,8 +73,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "top" , Literal (Numeric 10.0 Pt) )
-              , ( Identifier "rest" , Literal Auto )
+              [ Reg ( Identifier "top" , Literal (Numeric 10.0 Pt) )
+              , Reg ( Identifier "rest" , Literal Auto )
               ])
        , BlockArg [ Text "Hi" ]
        ])
diff --git a/test/out/layout/page-margin-01.out b/test/out/layout/page-margin-01.out
--- a/test/out/layout/page-margin-01.out
+++ b/test/out/layout/page-margin-01.out
@@ -59,7 +59,7 @@
                  (Ident (Identifier "page"))
                  [ KeyValArg
                      (Identifier "margin")
-                     (Dict [ ( Identifier "left" , Literal (Numeric 0.0 Pt) ) ])
+                     (Dict [ Reg ( Identifier "left" , Literal (Numeric 0.0 Pt) ) ])
                  ])
           , Space
           , Code
@@ -84,7 +84,7 @@
                  (Ident (Identifier "page"))
                  [ KeyValArg
                      (Identifier "margin")
-                     (Dict [ ( Identifier "right" , Literal (Numeric 0.0 Pt) ) ])
+                     (Dict [ Reg ( Identifier "right" , Literal (Numeric 0.0 Pt) ) ])
                  ])
           , Space
           , Code
@@ -109,7 +109,7 @@
                  (Ident (Identifier "page"))
                  [ KeyValArg
                      (Identifier "margin")
-                     (Dict [ ( Identifier "top" , Literal (Numeric 0.0 Pt) ) ])
+                     (Dict [ Reg ( Identifier "top" , Literal (Numeric 0.0 Pt) ) ])
                  ])
           , Space
           , Code
@@ -132,7 +132,7 @@
                  (Ident (Identifier "page"))
                  [ KeyValArg
                      (Identifier "margin")
-                     (Dict [ ( Identifier "bottom" , Literal (Numeric 0.0 Pt) ) ])
+                     (Dict [ Reg ( Identifier "bottom" , Literal (Numeric 0.0 Pt) ) ])
                  ])
           , Space
           , Code
@@ -159,8 +159,8 @@
                  [ KeyValArg
                      (Identifier "margin")
                      (Dict
-                        [ ( Identifier "rest" , Literal (Numeric 0.0 Pt) )
-                        , ( Identifier "left" , Literal (Numeric 20.0 Pt) )
+                        [ Reg ( Identifier "rest" , Literal (Numeric 0.0 Pt) )
+                        , Reg ( Identifier "left" , Literal (Numeric 20.0 Pt) )
                         ])
                  ])
           , Space
diff --git a/test/out/layout/page-marginals-00.out b/test/out/layout/page-marginals-00.out
--- a/test/out/layout/page-marginals-00.out
+++ b/test/out/layout/page-marginals-00.out
@@ -48,8 +48,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "x" , Literal (Numeric 15.0 Pt) )
-              , ( Identifier "y" , Literal (Numeric 30.0 Pt) )
+              [ Reg ( Identifier "x" , Literal (Numeric 15.0 Pt) )
+              , Reg ( Identifier "y" , Literal (Numeric 30.0 Pt) )
               ])
        , KeyValArg
            (Identifier "header")
@@ -344,8 +344,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "top" , Literal (Numeric 15.0 Pt) )
-              , ( Identifier "bottom" , Literal (Numeric 25.0 Pt) )
+              [ Reg ( Identifier "top" , Literal (Numeric 15.0 Pt) )
+              , Reg ( Identifier "bottom" , Literal (Numeric 25.0 Pt) )
               ])
        ])
 , SoftBreak
diff --git a/test/out/layout/par-bidi-01.out b/test/out/layout/par-bidi-01.out
--- a/test/out/layout/par-bidi-01.out
+++ b/test/out/layout/par-bidi-01.out
@@ -68,8 +68,8 @@
        [ KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "PT Sans")
-              , Literal (String "Noto Sans Arabic")
+              [ Reg (Literal (String "PT Sans"))
+              , Reg (Literal (String "Noto Sans Arabic"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/layout/par-bidi-02.out b/test/out/layout/par-bidi-02.out
--- a/test/out/layout/par-bidi-02.out
+++ b/test/out/layout/par-bidi-02.out
@@ -68,8 +68,8 @@
        [ KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "Linux Libertine")
-              , Literal (String "Noto Serif Hebrew")
+              [ Reg (Literal (String "Linux Libertine"))
+              , Reg (Literal (String "Noto Serif Hebrew"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/layout/par-bidi-04.out b/test/out/layout/par-bidi-04.out
--- a/test/out/layout/par-bidi-04.out
+++ b/test/out/layout/par-bidi-04.out
@@ -49,8 +49,8 @@
        , KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "Noto Sans Arabic")
-              , Literal (String "PT Sans")
+              [ Reg (Literal (String "Noto Sans Arabic"))
+              , Reg (Literal (String "PT Sans"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/layout/par-indent-00.out b/test/out/layout/par-indent-00.out
--- a/test/out/layout/par-indent-00.out
+++ b/test/out/layout/par-indent-00.out
@@ -169,8 +169,8 @@
        , KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "Noto Sans Arabic")
-              , Literal (String "Linux Libertine")
+              [ Reg (Literal (String "Noto Sans Arabic"))
+              , Reg (Literal (String "Linux Libertine"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/layout/par-justify-cjk-03.out b/test/out/layout/par-justify-cjk-03.out
--- a/test/out/layout/par-justify-cjk-03.out
+++ b/test/out/layout/par-justify-cjk-03.out
@@ -52,7 +52,7 @@
            (Plus (Literal (Numeric 170.0 Pt)) (Literal (Numeric 10.0 Pt)))
        , KeyValArg
            (Identifier "margin")
-           (Dict [ ( Identifier "x" , Literal (Numeric 5.0 Pt) ) ])
+           (Dict [ Reg ( Identifier "x" , Literal (Numeric 5.0 Pt) ) ])
        ])
 , SoftBreak
 , Code
diff --git a/test/out/layout/repeat-00.out b/test/out/layout/repeat-00.out
--- a/test/out/layout/repeat-00.out
+++ b/test/out/layout/repeat-00.out
@@ -46,12 +46,24 @@
     (Let
        (BasicBind (Just (Identifier "sections")))
        (Array
-          [ Array [ Literal (String "Introduction") , Literal (Int 1) ]
-          , Array [ Literal (String "Approach") , Literal (Int 1) ]
-          , Array [ Literal (String "Evaluation") , Literal (Int 3) ]
-          , Array [ Literal (String "Discussion") , Literal (Int 15) ]
-          , Array [ Literal (String "Related Work") , Literal (Int 16) ]
-          , Array [ Literal (String "Conclusion") , Literal (Int 253) ]
+          [ Reg
+              (Array
+                 [ Reg (Literal (String "Introduction")) , Reg (Literal (Int 1)) ])
+          , Reg
+              (Array
+                 [ Reg (Literal (String "Approach")) , Reg (Literal (Int 1)) ])
+          , Reg
+              (Array
+                 [ Reg (Literal (String "Evaluation")) , Reg (Literal (Int 3)) ])
+          , Reg
+              (Array
+                 [ Reg (Literal (String "Discussion")) , Reg (Literal (Int 15)) ])
+          , Reg
+              (Array
+                 [ Reg (Literal (String "Related Work")) , Reg (Literal (Int 16)) ])
+          , Reg
+              (Array
+                 [ Reg (Literal (String "Conclusion")) , Reg (Literal (Int 253)) ])
           ]))
 , ParBreak
 , Code
diff --git a/test/out/layout/stack-1-00.out b/test/out/layout/stack-1-00.out
--- a/test/out/layout/stack-1-00.out
+++ b/test/out/layout/stack-1-00.out
@@ -46,14 +46,14 @@
     (Let
        (BasicBind (Just (Identifier "widths")))
        (Array
-          [ Literal (Numeric 30.0 Pt)
-          , Literal (Numeric 20.0 Pt)
-          , Literal (Numeric 40.0 Pt)
-          , Literal (Numeric 15.0 Pt)
-          , Literal (Numeric 30.0 Pt)
-          , Literal (Numeric 50.0 Percent)
-          , Literal (Numeric 20.0 Pt)
-          , Literal (Numeric 100.0 Percent)
+          [ Reg (Literal (Numeric 30.0 Pt))
+          , Reg (Literal (Numeric 20.0 Pt))
+          , Reg (Literal (Numeric 40.0 Pt))
+          , Reg (Literal (Numeric 15.0 Pt))
+          , Reg (Literal (Numeric 30.0 Pt))
+          , Reg (Literal (Numeric 50.0 Percent))
+          , Reg (Literal (Numeric 20.0 Pt))
+          , Reg (Literal (Numeric 100.0 Percent))
           ]))
 , ParBreak
 , Code
@@ -101,16 +101,17 @@
           (Block
              (CodeBlock
                 [ Array
-                    [ FuncCall
-                        (Ident (Identifier "align"))
-                        [ NormalArg (Ident (Identifier "right"))
-                        , NormalArg
-                            (FuncCall
-                               (Ident (Identifier "shaded"))
-                               [ NormalArg (Ident (Identifier "i"))
-                               , NormalArg (Ident (Identifier "w"))
-                               ])
-                        ]
+                    [ Reg
+                        (FuncCall
+                           (Ident (Identifier "align"))
+                           [ NormalArg (Ident (Identifier "right"))
+                           , NormalArg
+                               (FuncCall
+                                  (Ident (Identifier "shaded"))
+                                  [ NormalArg (Ident (Identifier "i"))
+                                  , NormalArg (Ident (Identifier "w"))
+                                  ])
+                           ])
                     ]
                 ]))))
 , ParBreak
diff --git a/test/out/layout/stack-2-00.out b/test/out/layout/stack-2-00.out
--- a/test/out/layout/stack-2-00.out
+++ b/test/out/layout/stack-2-00.out
@@ -60,13 +60,14 @@
               (Block
                  (CodeBlock
                     [ Array
-                        [ Block
-                            (Content
-                               [ Code
-                                   "test/typ/layout/stack-2-00.typ"
-                                   ( line 6 , column 30 )
-                                   (Ident (Identifier "c"))
-                               ])
+                        [ Reg
+                            (Block
+                               (Content
+                                  [ Code
+                                      "test/typ/layout/stack-2-00.typ"
+                                      ( line 6 , column 30 )
+                                      (Ident (Identifier "c"))
+                                  ]))
                         ]
                     ])))
        ])
diff --git a/test/out/layout/table-00.out b/test/out/layout/table-00.out
--- a/test/out/layout/table-00.out
+++ b/test/out/layout/table-00.out
@@ -78,7 +78,8 @@
        (Ident (Identifier "table"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Array [ Literal (Numeric 1.0 Fr) ]) (Literal (Int 3)))
+           (Times
+              (Array [ Reg (Literal (Numeric 1.0 Fr)) ]) (Literal (Int 3)))
        , KeyValArg
            (Identifier "stroke")
            (Plus
diff --git a/test/out/layout/table-02.out b/test/out/layout/table-02.out
--- a/test/out/layout/table-02.out
+++ b/test/out/layout/table-02.out
@@ -48,16 +48,16 @@
        [ KeyValArg
            (Identifier "columns")
            (Array
-              [ Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
+              [ Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
               ])
        , KeyValArg
            (Identifier "align")
            (Array
-              [ Ident (Identifier "left")
-              , Ident (Identifier "center")
-              , Ident (Identifier "right")
+              [ Reg (Ident (Identifier "left"))
+              , Reg (Ident (Identifier "center"))
+              , Reg (Ident (Identifier "right"))
               ])
        , NormalArg (Block (Content [ Text "A" ]))
        , NormalArg (Block (Content [ Text "B" ]))
@@ -80,9 +80,9 @@
        [ KeyValArg
            (Identifier "columns")
            (Array
-              [ Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
+              [ Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
               ])
        , KeyValArg (Identifier "align") (Array [])
        , NormalArg (Block (Content [ Text "A" ]))
diff --git a/test/out/layout/terms-00.out b/test/out/layout/terms-00.out
--- a/test/out/layout/terms-00.out
+++ b/test/out/layout/terms-00.out
@@ -47,13 +47,13 @@
        (Ident (Identifier "terms"))
        [ NormalArg
            (Array
-              [ Block (Content [ Text "One" ])
-              , Block (Content [ Text "First" ])
+              [ Reg (Block (Content [ Text "One" ]))
+              , Reg (Block (Content [ Text "First" ]))
               ])
        , NormalArg
            (Array
-              [ Block (Content [ Text "Two" ])
-              , Block (Content [ Text "Second" ])
+              [ Reg (Block (Content [ Text "Two" ]))
+              , Reg (Block (Content [ Text "Second" ]))
               ])
        ])
 , ParBreak
diff --git a/test/out/layout/terms-04.out b/test/out/layout/terms-04.out
--- a/test/out/layout/terms-04.out
+++ b/test/out/layout/terms-04.out
@@ -64,14 +64,18 @@
                               (FuncExpr
                                  [ NormalParam (Identifier "v") ]
                                  (Array
-                                    [ FuncCall
-                                        (Ident (Identifier "emph"))
-                                        [ NormalArg
-                                            (FieldAccess
-                                               (Ident (Identifier "term")) (Ident (Identifier "v")))
-                                        ]
-                                    , FieldAccess
-                                        (Ident (Identifier "description")) (Ident (Identifier "v"))
+                                    [ Reg
+                                        (FuncCall
+                                           (Ident (Identifier "emph"))
+                                           [ NormalArg
+                                               (FieldAccess
+                                                  (Ident (Identifier "term"))
+                                                  (Ident (Identifier "v")))
+                                           ])
+                                    , Reg
+                                        (FieldAccess
+                                           (Ident (Identifier "description"))
+                                           (Ident (Identifier "v")))
                                     ]))
                           ]))
                     [])
diff --git a/test/out/meta/bibliography-04.out b/test/out/meta/bibliography-04.out
--- a/test/out/meta/bibliography-04.out
+++ b/test/out/meta/bibliography-04.out
@@ -91,8 +91,8 @@
        (Ident (Identifier "bibliography"))
        [ NormalArg
            (Array
-              [ Literal (String "/works.bib")
-              , Literal (String "/works_too.bib")
+              [ Reg (Literal (String "/works.bib"))
+              , Reg (Literal (String "/works_too.bib"))
               ])
        ])
 , ParBreak
diff --git a/test/out/meta/counter-page-00.out b/test/out/meta/counter-page-00.out
--- a/test/out/meta/counter-page-00.out
+++ b/test/out/meta/counter-page-00.out
@@ -50,8 +50,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "bottom" , Literal (Numeric 20.0 Pt) )
-              , ( Identifier "rest" , Literal (Numeric 10.0 Pt) )
+              [ Reg ( Identifier "bottom" , Literal (Numeric 20.0 Pt) )
+              , Reg ( Identifier "rest" , Literal (Numeric 10.0 Pt) )
               ])
        ])
 , SoftBreak
diff --git a/test/out/meta/document-01.out b/test/out/meta/document-01.out
--- a/test/out/meta/document-01.out
+++ b/test/out/meta/document-01.out
@@ -48,7 +48,7 @@
        (Ident (Identifier "document"))
        [ KeyValArg
            (Identifier "author")
-           (Array [ Literal (String "A") , Literal (String "B") ])
+           (Array [ Reg (Literal (String "A")) , Reg (Literal (String "B")) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/meta/link-08.out b/test/out/meta/link-08.out
--- a/test/out/meta/link-08.out
+++ b/test/out/meta/link-08.out
@@ -47,9 +47,9 @@
        (Ident (Identifier "link"))
        [ NormalArg
            (Dict
-              [ ( Identifier "page" , Literal (Int 1) )
-              , ( Identifier "x" , Literal (Numeric 10.0 Pt) )
-              , ( Identifier "y" , Literal (Numeric 20.0 Pt) )
+              [ Reg ( Identifier "page" , Literal (Int 1) )
+              , Reg ( Identifier "x" , Literal (Numeric 10.0 Pt) )
+              , Reg ( Identifier "y" , Literal (Numeric 20.0 Pt) )
               ])
        , BlockArg
            [ Text "Back"
diff --git a/test/out/meta/query-before-after-00.out b/test/out/meta/query-before-after-00.out
--- a/test/out/meta/query-before-after-00.out
+++ b/test/out/meta/query-before-after-00.out
@@ -49,8 +49,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "bottom" , Literal (Numeric 1.0 Cm) )
-              , ( Identifier "rest" , Literal (Numeric 0.5 Cm) )
+              [ Reg ( Identifier "bottom" , Literal (Numeric 1.0 Cm) )
+              , Reg ( Identifier "rest" , Literal (Numeric 0.5 Cm) )
               ])
        ])
 , ParBreak
diff --git a/test/out/meta/query-before-after-01.out b/test/out/meta/query-before-after-01.out
--- a/test/out/meta/query-before-after-01.out
+++ b/test/out/meta/query-before-after-01.out
@@ -49,8 +49,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "bottom" , Literal (Numeric 1.0 Cm) )
-              , ( Identifier "rest" , Literal (Numeric 0.5 Cm) )
+              [ Reg ( Identifier "bottom" , Literal (Numeric 1.0 Cm) )
+              , Reg ( Identifier "rest" , Literal (Numeric 0.5 Cm) )
               ])
        ])
 , ParBreak
diff --git a/test/out/meta/query-figure-00.out b/test/out/meta/query-figure-00.out
--- a/test/out/meta/query-figure-00.out
+++ b/test/out/meta/query-figure-00.out
@@ -49,8 +49,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "bottom" , Literal (Numeric 1.0 Cm) )
-              , ( Identifier "rest" , Literal (Numeric 0.5 Cm) )
+              [ Reg ( Identifier "bottom" , Literal (Numeric 1.0 Cm) )
+              , Reg ( Identifier "rest" , Literal (Numeric 0.5 Cm) )
               ])
        ])
 , ParBreak
diff --git a/test/out/meta/query-header-00.out b/test/out/meta/query-header-00.out
--- a/test/out/meta/query-header-00.out
+++ b/test/out/meta/query-header-00.out
@@ -48,8 +48,8 @@
        , KeyValArg
            (Identifier "margin")
            (Dict
-              [ ( Identifier "y" , Literal (Numeric 1.0 Cm) )
-              , ( Identifier "x" , Literal (Numeric 0.5 Cm) )
+              [ Reg ( Identifier "y" , Literal (Numeric 1.0 Cm) )
+              , Reg ( Identifier "x" , Literal (Numeric 0.5 Cm) )
               ])
        , KeyValArg
            (Identifier "header")
diff --git a/test/out/regression/issue1.out b/test/out/regression/issue1.out
new file mode 100644
--- /dev/null
+++ b/test/out/regression/issue1.out
@@ -0,0 +1,71 @@
+--- parse tree ---
+[ Code
+    "test/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
+                                 "test/typ/regression/issue1.typ"
+                                 ( line 1 , column 47 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "x")) ])
+                             , Space
+                             , Text "/"
+                             , Text "="
+                             , Space
+                             , Code
+                                 "test/typ/regression/issue1.typ"
+                                 ( line 1 , column 59 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "y")) ])
+                             , Text ")"
+                             ])
+                      )
+                    ]
+                ]))))
+, SoftBreak
+, Code
+    "test/typ/regression/issue1.typ"
+    ( line 2 , column 2 )
+    (LetFunc
+       (Identifier "foo")
+       [ NormalParam (Identifier "x") ]
+       (Block
+          (CodeBlock
+             [ Return
+                 (Just
+                    (Array [ Spr (Ident (Identifier "x")) , Reg (Literal (Int 5)) ]))
+             ])))
+, SoftBreak
+, Code
+    "test/typ/regression/issue1.typ"
+    ( line 7 , column 2 )
+    (FuncCall
+       (Ident (Identifier "foo"))
+       [ NormalArg
+           (Array [ Reg (Literal (Int 3)) , Reg (Literal (Int 4)) ])
+       ])
+, ParBreak
+]
+--- evaluated ---
+{ text(body: [
+]), 
+  text(body: [
+]), 
+  text(body: [(3, 4, 5)]), 
+  parbreak() }
diff --git a/test/out/regression/issue2.out b/test/out/regression/issue2.out
new file mode 100644
--- /dev/null
+++ b/test/out/regression/issue2.out
@@ -0,0 +1,72 @@
+--- parse tree ---
+[ Code
+    "test/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
+                                 "test/typ/regression/issue2.typ"
+                                 ( line 1 , column 47 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "x")) ])
+                             , Space
+                             , Text "/"
+                             , Text "="
+                             , Space
+                             , Code
+                                 "test/typ/regression/issue2.typ"
+                                 ( line 1 , column 59 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "y")) ])
+                             , Text ")"
+                             ])
+                      )
+                    ]
+                ]))))
+, SoftBreak
+, Equation
+    False
+    [ Code
+        "test/typ/regression/issue2.typ"
+        ( line 2 , column 2 )
+        (FuncCall
+           (Ident (Identifier "lr"))
+           [ BlockArg
+               [ Code
+                   "test/typ/regression/issue2.typ"
+                   ( line 2 , column 6 )
+                   (FieldAccess
+                      (Ident (Identifier "alpha")) (Ident (Identifier "sym")))
+               , Code
+                   "test/typ/regression/issue2.typ"
+                   ( line 2 , column 16 )
+                   (FieldAccess
+                      (Ident (Identifier "beta")) (Ident (Identifier "sym")))
+               ]
+           ])
+    ]
+, ParBreak
+]
+--- evaluated ---
+{ text(body: [
+]), 
+  math.equation(block: false, 
+                body: math.lr(body: ({ text(body: [α]), 
+                                       text(body: [β]) })), 
+                numbering: none), 
+  parbreak() }
diff --git a/test/out/regression/issue3.out b/test/out/regression/issue3.out
new file mode 100644
--- /dev/null
+++ b/test/out/regression/issue3.out
@@ -0,0 +1,74 @@
+--- parse tree ---
+[ Code
+    "test/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
+                                 "test/typ/regression/issue3.typ"
+                                 ( line 1 , column 47 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "x")) ])
+                             , Space
+                             , Text "/"
+                             , Text "="
+                             , Space
+                             , Code
+                                 "test/typ/regression/issue3.typ"
+                                 ( line 1 , column 59 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "y")) ])
+                             , Text ")"
+                             ])
+                      )
+                    ]
+                ]))))
+, SoftBreak
+, Code
+    "test/typ/regression/issue3.typ"
+    ( line 2 , column 2 )
+    (Let
+       (BasicBind (Just (Identifier "alpha")))
+       (Dict
+          [ Reg
+              ( Identifier "named"
+              , Dict
+                  [ Reg ( Identifier "a" , Literal (Int 1) )
+                  , Reg ( Identifier "b" , Literal (Int 2) )
+                  ]
+              )
+          ]))
+, SoftBreak
+, Code
+    "test/typ/regression/issue3.typ"
+    ( line 3 , column 2 )
+    (Dict
+       [ Spr
+           (FieldAccess
+              (Ident (Identifier "named")) (Ident (Identifier "alpha")))
+       , Reg ( Identifier "c" , Literal (Int 3) )
+       ])
+, ParBreak
+]
+--- evaluated ---
+{ text(body: [
+]), 
+  text(body: [
+]), 
+  text(body: [(a: 1, b: 2, c: 3)]), 
+  parbreak() }
diff --git a/test/out/regression/issue5.out b/test/out/regression/issue5.out
new file mode 100644
--- /dev/null
+++ b/test/out/regression/issue5.out
@@ -0,0 +1,52 @@
+--- parse tree ---
+[ Code
+    "test/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
+                                 "test/typ/regression/issue5.typ"
+                                 ( line 1 , column 47 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "x")) ])
+                             , Space
+                             , Text "/"
+                             , Text "="
+                             , Space
+                             , Code
+                                 "test/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 "!" ] ]
+, ParBreak
+]
+--- evaluated ---
+{ text(body: [
+]), 
+  math.equation(block: true, 
+                body: { text(body: [3]), 
+                        text(body: [!]) }, 
+                numbering: none), 
+  parbreak() }
diff --git a/test/out/regression/issue6.out b/test/out/regression/issue6.out
new file mode 100644
--- /dev/null
+++ b/test/out/regression/issue6.out
@@ -0,0 +1,65 @@
+--- parse tree ---
+[ Code
+    "test/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
+                                 "test/typ/regression/issue6.typ"
+                                 ( line 1 , column 47 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "x")) ])
+                             , Space
+                             , Text "/"
+                             , Text "="
+                             , Space
+                             , Code
+                                 "test/typ/regression/issue6.typ"
+                                 ( line 1 , column 59 )
+                                 (FuncCall
+                                    (Ident (Identifier "repr"))
+                                    [ NormalArg (Ident (Identifier "y")) ])
+                             , Text ")"
+                             ])
+                      )
+                    ]
+                ]))))
+, SoftBreak
+, Equation
+    True
+    [ Code
+        "test/typ/regression/issue6.typ"
+        ( line 2 , column 4 )
+        (Let
+           (BasicBind (Just (Identifier "g")))
+           (Block (Content [ Equation False [ Text "3" ] ])))
+    , Code
+        "test/typ/regression/issue6.typ"
+        ( line 3 , column 2 )
+        (Ident (Identifier "g"))
+    ]
+, ParBreak
+]
+--- evaluated ---
+{ text(body: [
+]), 
+  math.equation(block: true, 
+                body: math.equation(block: false, 
+                                    body: text(body: [3]), 
+                                    numbering: none), 
+                numbering: none), 
+  parbreak() }
diff --git a/test/out/text/features-07.out b/test/out/text/features-07.out
--- a/test/out/text/features-07.out
+++ b/test/out/text/features-07.out
@@ -46,7 +46,7 @@
     (FuncCall
        (Ident (Identifier "text"))
        [ KeyValArg
-           (Identifier "features") (Array [ Literal (String "smcp") ])
+           (Identifier "features") (Array [ Reg (Literal (String "smcp")) ])
        , BlockArg [ Text "Smcp" ]
        ])
 , Space
@@ -63,7 +63,7 @@
        (Ident (Identifier "text"))
        [ KeyValArg
            (Identifier "features")
-           (Dict [ ( Identifier "liga" , Literal (Int 0) ) ])
+           (Dict [ Reg ( Identifier "liga" , Literal (Int 0) ) ])
        , BlockArg [ Text "No" , Space , Text "fi" ]
        ])
 , ParBreak
diff --git a/test/out/text/font-00.out b/test/out/text/font-00.out
--- a/test/out/text/font-00.out
+++ b/test/out/text/font-00.out
@@ -167,8 +167,8 @@
        [ KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "PT Sans")
-              , Literal (String "Twitter Color Emoji")
+              [ Reg (Literal (String "PT Sans"))
+              , Reg (Literal (String "Twitter Color Emoji"))
               ])
        , KeyValArg (Identifier "fallback") (Literal (Boolean False))
        ])
diff --git a/test/out/text/hyphenate-00.out b/test/out/text/hyphenate-00.out
--- a/test/out/text/hyphenate-00.out
+++ b/test/out/text/hyphenate-00.out
@@ -61,7 +61,10 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Array [ Literal (Numeric 50.0 Pt) , Literal (Numeric 50.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 50.0 Pt))
+              , Reg (Literal (Numeric 50.0 Pt))
+              ])
        , NormalArg
            (Block
               (Content
diff --git a/test/out/text/hyphenate-03.out b/test/out/text/hyphenate-03.out
--- a/test/out/text/hyphenate-03.out
+++ b/test/out/text/hyphenate-03.out
@@ -56,7 +56,8 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Literal (Int 2)) (Array [ Literal (Numeric 20.0 Pt) ]))
+           (Times
+              (Literal (Int 2)) (Array [ Reg (Literal (Numeric 20.0 Pt)) ]))
        , KeyValArg (Identifier "gutter") (Literal (Numeric 20.0 Pt))
        , NormalArg (Block (Content [ Text "Barankauf" ]))
        , NormalArg (Block (Content [ Text "Bar" , Shy , Text "ankauf" ]))
diff --git a/test/out/text/lang-00.out b/test/out/text/lang-00.out
--- a/test/out/text/lang-00.out
+++ b/test/out/text/lang-00.out
@@ -54,7 +54,8 @@
        (Ident (Identifier "grid"))
        [ KeyValArg
            (Identifier "columns")
-           (Times (Literal (Int 2)) (Array [ Literal (Numeric 20.0 Pt) ]))
+           (Times
+              (Literal (Int 2)) (Array [ Reg (Literal (Numeric 20.0 Pt)) ]))
        , KeyValArg (Identifier "gutter") (Literal (Numeric 1.0 Fr))
        , NormalArg
            (FuncCall
diff --git a/test/out/text/microtype-00.out b/test/out/text/microtype-00.out
--- a/test/out/text/microtype-00.out
+++ b/test/out/text/microtype-00.out
@@ -149,8 +149,8 @@
        , KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "PT Sans")
-              , Literal (String "Noto Serif Hebrew")
+              [ Reg (Literal (String "PT Sans"))
+              , Reg (Literal (String "Noto Serif Hebrew"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/text/raw-code-04.out b/test/out/text/raw-code-04.out
--- a/test/out/text/raw-code-04.out
+++ b/test/out/text/raw-code-04.out
@@ -61,8 +61,8 @@
        [ KeyValArg
            (Identifier "inset")
            (Dict
-              [ ( Identifier "x" , Literal (Numeric 4.0 Pt) )
-              , ( Identifier "y" , Literal (Numeric 5.0 Pt) )
+              [ Reg ( Identifier "x" , Literal (Numeric 4.0 Pt) )
+              , Reg ( Identifier "y" , Literal (Numeric 5.0 Pt) )
               ])
        , KeyValArg (Identifier "radius") (Literal (Numeric 4.0 Pt))
        , KeyValArg
diff --git a/test/out/text/space-00.out b/test/out/text/space-00.out
--- a/test/out/text/space-00.out
+++ b/test/out/text/space-00.out
@@ -163,7 +163,7 @@
     ( line 10 , column 3 )
     (For
        (BasicBind Nothing)
-       (Array [ Literal None ])
+       (Array [ Reg (Literal None) ])
        (Block (CodeBlock [ Literal (String "U") ])))
 , Text "V"
 , SoftBreak
diff --git a/test/out/text/tracking-spacing-02.out b/test/out/text/tracking-spacing-02.out
--- a/test/out/text/tracking-spacing-02.out
+++ b/test/out/text/tracking-spacing-02.out
@@ -48,8 +48,8 @@
        [ KeyValArg
            (Identifier "font")
            (Array
-              [ Literal (String "PT Sans")
-              , Literal (String "Noto Serif Hebrew")
+              [ Reg (Literal (String "PT Sans"))
+              , Reg (Literal (String "Noto Serif Hebrew"))
               ])
        ])
 , SoftBreak
diff --git a/test/out/visualize/image-02.out b/test/out/visualize/image-02.out
--- a/test/out/visualize/image-02.out
+++ b/test/out/visualize/image-02.out
@@ -57,9 +57,9 @@
        [ KeyValArg
            (Identifier "columns")
            (Array
-              [ Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
-              , Literal (Numeric 1.0 Fr)
+              [ Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
               ])
        , KeyValArg (Identifier "rows") (Literal (Numeric 100.0 Percent))
        , KeyValArg (Identifier "gutter") (Literal (Numeric 3.0 Pt))
diff --git a/test/out/visualize/line-00.out b/test/out/visualize/line-00.out
--- a/test/out/visualize/line-00.out
+++ b/test/out/visualize/line-00.out
@@ -64,7 +64,10 @@
                             (Ident (Identifier "line"))
                             [ KeyValArg
                                 (Identifier "end")
-                                (Array [ Literal (Numeric 0.4 Em) , Literal (Numeric 0.0 Pt) ])
+                                (Array
+                                   [ Reg (Literal (Numeric 0.4 Em))
+                                   , Reg (Literal (Numeric 0.0 Pt))
+                                   ])
                             ])
                      ]
                  , FuncCall
@@ -74,17 +77,26 @@
                             (Ident (Identifier "line"))
                             [ KeyValArg
                                 (Identifier "start")
-                                (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.4 Em) ])
+                                (Array
+                                   [ Reg (Literal (Numeric 0.0 Pt))
+                                   , Reg (Literal (Numeric 0.4 Em))
+                                   ])
                             , KeyValArg
                                 (Identifier "end")
-                                (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                                (Array
+                                   [ Reg (Literal (Numeric 0.0 Pt))
+                                   , Reg (Literal (Numeric 0.0 Pt))
+                                   ])
                             ])
                      ]
                  , FuncCall
                      (Ident (Identifier "line"))
                      [ KeyValArg
                          (Identifier "end")
-                         (Array [ Literal (Numeric 0.6 Em) , Literal (Numeric 0.6 Em) ])
+                         (Array
+                            [ Reg (Literal (Numeric 0.6 Em))
+                            , Reg (Literal (Numeric 0.6 Em))
+                            ])
                      ]
                  ]))
        ])
@@ -111,8 +123,8 @@
        [ KeyValArg
            (Identifier "end")
            (Array
-              [ Literal (Numeric 70.0 Percent)
-              , Literal (Numeric 50.0 Percent)
+              [ Reg (Literal (Numeric 70.0 Percent))
+              , Reg (Literal (Numeric 50.0 Percent))
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/line-01.out b/test/out/visualize/line-01.out
--- a/test/out/visualize/line-01.out
+++ b/test/out/visualize/line-01.out
@@ -115,8 +115,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 9.0 Percent)
-                                   , Literal (Numeric 2.0 Percent)
+                                   [ Reg (Literal (Numeric 9.0 Percent))
+                                   , Reg (Literal (Numeric 2.0 Percent))
                                    ])
                             ])
                      ])
@@ -133,8 +133,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 38.7 Percent)
-                                   , Literal (Numeric 2.0 Percent)
+                                   [ Reg (Literal (Numeric 38.7 Percent))
+                                   , Reg (Literal (Numeric 2.0 Percent))
                                    ])
                             , KeyValArg
                                 (Identifier "angle") (Negated (Literal (Numeric 72.0 Deg)))
@@ -153,8 +153,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 57.5 Percent)
-                                   , Literal (Numeric 2.0 Percent)
+                                   [ Reg (Literal (Numeric 57.5 Percent))
+                                   , Reg (Literal (Numeric 2.0 Percent))
                                    ])
                             , KeyValArg (Identifier "angle") (Literal (Numeric 252.0 Deg))
                             ])
@@ -172,8 +172,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 57.3 Percent)
-                                   , Literal (Numeric 2.0 Percent)
+                                   [ Reg (Literal (Numeric 57.3 Percent))
+                                   , Reg (Literal (Numeric 2.0 Percent))
                                    ])
                             ])
                      ])
@@ -191,8 +191,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 88.0 Percent)
-                                   , Literal (Numeric 2.0 Percent)
+                                   [ Reg (Literal (Numeric 88.0 Percent))
+                                   , Reg (Literal (Numeric 2.0 Percent))
                                    ])
                             , KeyValArg
                                 (Identifier "angle") (Negated (Literal (Numeric 36.0 Deg)))
@@ -211,8 +211,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 73.3 Percent)
-                                   , Literal (Numeric 48.0 Percent)
+                                   [ Reg (Literal (Numeric 73.3 Percent))
+                                   , Reg (Literal (Numeric 48.0 Percent))
                                    ])
                             , KeyValArg (Identifier "angle") (Literal (Numeric 252.0 Deg))
                             ])
@@ -231,8 +231,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 73.5 Percent)
-                                   , Literal (Numeric 48.0 Percent)
+                                   [ Reg (Literal (Numeric 73.5 Percent))
+                                   , Reg (Literal (Numeric 48.0 Percent))
                                    ])
                             , KeyValArg (Identifier "angle") (Literal (Numeric 36.0 Deg))
                             ])
@@ -250,8 +250,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 25.4 Percent)
-                                   , Literal (Numeric 48.0 Percent)
+                                   [ Reg (Literal (Numeric 25.4 Percent))
+                                   , Reg (Literal (Numeric 48.0 Percent))
                                    ])
                             , KeyValArg
                                 (Identifier "angle") (Negated (Literal (Numeric 36.0 Deg)))
@@ -270,8 +270,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 25.6 Percent)
-                                   , Literal (Numeric 48.0 Percent)
+                                   [ Reg (Literal (Numeric 25.6 Percent))
+                                   , Reg (Literal (Numeric 48.0 Percent))
                                    ])
                             , KeyValArg
                                 (Identifier "angle") (Negated (Literal (Numeric 72.0 Deg)))
@@ -290,8 +290,8 @@
                             , KeyValArg
                                 (Identifier "start")
                                 (Array
-                                   [ Literal (Numeric 8.5 Percent)
-                                   , Literal (Numeric 2.0 Percent)
+                                   [ Reg (Literal (Numeric 8.5 Percent))
+                                   , Reg (Literal (Numeric 2.0 Percent))
                                    ])
                             , KeyValArg (Identifier "angle") (Literal (Numeric 34.0 Deg))
                             ])
@@ -315,11 +315,12 @@
               , SpreadArg
                   (Times
                      (Array
-                        [ FuncCall
-                            (Ident (Identifier "star"))
-                            [ NormalArg (Literal (Numeric 20.0 Pt))
-                            , KeyValArg (Identifier "stroke") (Literal (Numeric 0.5 Pt))
-                            ]
+                        [ Reg
+                            (FuncCall
+                               (Ident (Identifier "star"))
+                               [ NormalArg (Literal (Numeric 20.0 Pt))
+                               , KeyValArg (Identifier "stroke") (Literal (Numeric 0.5 Pt))
+                               ])
                         ])
                      (Literal (Int 9)))
               ])
diff --git a/test/out/visualize/path-00.out b/test/out/visualize/path-00.out
--- a/test/out/visualize/path-00.out
+++ b/test/out/visualize/path-00.out
@@ -55,10 +55,16 @@
        (Ident (Identifier "table"))
        [ KeyValArg
            (Identifier "columns")
-           (Array [ Literal (Numeric 1.0 Fr) , Literal (Numeric 1.0 Fr) ])
+           (Array
+              [ Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              ])
        , KeyValArg
            (Identifier "rows")
-           (Array [ Literal (Numeric 1.0 Fr) , Literal (Numeric 1.0 Fr) ])
+           (Array
+              [ Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal (Numeric 1.0 Fr))
+              ])
        , KeyValArg
            (Identifier "align")
            (Plus (Ident (Identifier "center")) (Ident (Identifier "horizon")))
@@ -69,35 +75,55 @@
               , KeyValArg (Identifier "closed") (Literal (Boolean True))
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 0.0 Percent) , Literal (Numeric 0.0 Percent) ]
-                     , Array
-                         [ Literal (Numeric 4.0 Percent)
-                         , Negated (Literal (Numeric 4.0 Percent))
-                         ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 0.0 Percent))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 4.0 Percent))
+                            , Reg (Negated (Literal (Numeric 4.0 Percent)))
+                            ])
                      ])
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 50.0 Percent) , Literal (Numeric 50.0 Percent) ]
-                     , Array
-                         [ Literal (Numeric 4.0 Percent)
-                         , Negated (Literal (Numeric 4.0 Percent))
-                         ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 50.0 Percent))
+                            , Reg (Literal (Numeric 50.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 4.0 Percent))
+                            , Reg (Negated (Literal (Numeric 4.0 Percent)))
+                            ])
                      ])
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 0.0 Percent) , Literal (Numeric 50.0 Percent) ]
-                     , Array
-                         [ Literal (Numeric 4.0 Percent) , Literal (Numeric 4.0 Percent) ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 0.0 Percent))
+                            , Reg (Literal (Numeric 50.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 4.0 Percent))
+                            , Reg (Literal (Numeric 4.0 Percent))
+                            ])
                      ])
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 50.0 Percent) , Literal (Numeric 0.0 Percent) ]
-                     , Array
-                         [ Literal (Numeric 4.0 Percent) , Literal (Numeric 4.0 Percent) ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 50.0 Percent))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 4.0 Percent))
+                            , Reg (Literal (Numeric 4.0 Percent))
+                            ])
                      ])
               ])
        , NormalArg
@@ -106,13 +132,25 @@
               [ KeyValArg (Identifier "fill") (Ident (Identifier "purple"))
               , KeyValArg (Identifier "stroke") (Literal (Numeric 1.0 Pt))
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 30.0 Pt) , Literal (Numeric 30.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 30.0 Pt))
+                     , Reg (Literal (Numeric 30.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 30.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 30.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 30.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 30.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               ])
        , NormalArg
            (FuncCall
@@ -122,36 +160,57 @@
               , KeyValArg (Identifier "closed") (Literal (Boolean True))
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 30.0 Percent) , Literal (Numeric 0.0 Percent) ]
-                     , Array
-                         [ Literal (Numeric 35.0 Percent) , Literal (Numeric 30.0 Percent) ]
-                     , Array
-                         [ Negated (Literal (Numeric 20.0 Percent))
-                         , Literal (Numeric 0.0 Percent)
-                         ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 30.0 Percent))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 35.0 Percent))
+                            , Reg (Literal (Numeric 30.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Negated (Literal (Numeric 20.0 Percent)))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
                      ])
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 30.0 Percent) , Literal (Numeric 60.0 Percent) ]
-                     , Array
-                         [ Negated (Literal (Numeric 20.0 Percent))
-                         , Literal (Numeric 0.0 Percent)
-                         ]
-                     , Array
-                         [ Literal (Numeric 0.0 Percent) , Literal (Numeric 0.0 Percent) ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 30.0 Percent))
+                            , Reg (Literal (Numeric 60.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Negated (Literal (Numeric 20.0 Percent)))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 0.0 Percent))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
                      ])
               , NormalArg
                   (Array
-                     [ Array
-                         [ Literal (Numeric 50.0 Percent) , Literal (Numeric 30.0 Percent) ]
-                     , Array
-                         [ Literal (Numeric 60.0 Percent)
-                         , Negated (Literal (Numeric 30.0 Percent))
-                         ]
-                     , Array
-                         [ Literal (Numeric 60.0 Percent) , Literal (Numeric 0.0 Percent) ]
+                     [ Reg
+                         (Array
+                            [ Reg (Literal (Numeric 50.0 Percent))
+                            , Reg (Literal (Numeric 30.0 Percent))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 60.0 Percent))
+                            , Reg (Negated (Literal (Numeric 30.0 Percent)))
+                            ])
+                     , Reg
+                         (Array
+                            [ Reg (Literal (Numeric 60.0 Percent))
+                            , Reg (Literal (Numeric 0.0 Percent))
+                            ])
                      ])
               ])
        , NormalArg
@@ -160,11 +219,20 @@
               [ KeyValArg (Identifier "stroke") (Literal (Numeric 5.0 Pt))
               , KeyValArg (Identifier "closed") (Literal (Boolean True))
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 30.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 30.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 30.0 Pt) , Literal (Numeric 30.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 30.0 Pt))
+                     , Reg (Literal (Numeric 30.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/polygon-00.out b/test/out/visualize/polygon-00.out
--- a/test/out/visualize/polygon-00.out
+++ b/test/out/visualize/polygon-00.out
@@ -67,7 +67,10 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 0.0 Em) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Em))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        ])
 , SoftBreak
 , Code
@@ -76,9 +79,15 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 10.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 10.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        ])
 , ParBreak
 , Code
@@ -87,11 +96,20 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 10.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 10.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        ])
 , SoftBreak
 , Code
@@ -100,15 +118,30 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 5.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 5.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 10.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 10.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 5.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 15.0 Pt))
+              , Reg (Literal (Numeric 5.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        ])
 , SoftBreak
 , Code
@@ -118,11 +151,20 @@
        (Ident (Identifier "polygon"))
        [ KeyValArg (Identifier "stroke") (Literal None)
        , NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 10.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 10.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        ])
 , SoftBreak
 , Code
@@ -133,11 +175,20 @@
        [ KeyValArg (Identifier "stroke") (Literal (Numeric 3.0 Pt))
        , KeyValArg (Identifier "fill") (Literal None)
        , NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 10.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 10.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        ])
 , ParBreak
 , Comment
@@ -147,13 +198,20 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
            (Array
-              [ Literal (Numeric 100.0 Percent) , Literal (Numeric 5.0 Pt) ])
+              [ Reg (Literal (Numeric 100.0 Percent))
+              , Reg (Literal (Numeric 5.0 Pt))
+              ])
        , NormalArg
            (Array
-              [ Literal (Numeric 50.0 Percent) , Literal (Numeric 10.0 Pt) ])
+              [ Reg (Literal (Numeric 50.0 Percent))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        ])
 , ParBreak
 , Comment
@@ -163,13 +221,25 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 5.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 5.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 5.0 Pt) , Literal (Numeric 15.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 5.0 Pt))
+              , Reg (Literal (Numeric 15.0 Pt))
+              ])
        ])
 , ParBreak
 , Comment
@@ -179,15 +249,30 @@
     (FuncCall
        (Ident (Identifier "polygon"))
        [ NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 10.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 10.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 30.0 Pt) , Literal (Numeric 20.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 30.0 Pt))
+              , Reg (Literal (Numeric 20.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 30.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 0.0 Pt))
+              , Reg (Literal (Numeric 30.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 20.0 Pt) , Literal (Numeric 0.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 20.0 Pt))
+              , Reg (Literal (Numeric 0.0 Pt))
+              ])
        , NormalArg
-           (Array [ Literal (Numeric 20.0 Pt) , Literal (Numeric 35.0 Pt) ])
+           (Array
+              [ Reg (Literal (Numeric 20.0 Pt))
+              , Reg (Literal (Numeric 35.0 Pt))
+              ])
        ])
 , ParBreak
 ]
diff --git a/test/out/visualize/shape-ellipse-01.out b/test/out/visualize/shape-ellipse-01.out
--- a/test/out/visualize/shape-ellipse-01.out
+++ b/test/out/visualize/shape-ellipse-01.out
@@ -173,8 +173,8 @@
               , KeyValArg
                   (Identifier "outset")
                   (Dict
-                     [ ( Identifier "top" , Literal (Numeric 3.0 Pt) )
-                     , ( Identifier "rest" , Literal (Numeric 5.5 Pt) )
+                     [ Reg ( Identifier "top" , Literal (Numeric 3.0 Pt) )
+                     , Reg ( Identifier "rest" , Literal (Numeric 5.5 Pt) )
                      ])
               ])
        ])
diff --git a/test/out/visualize/shape-fill-stroke-00.out b/test/out/visualize/shape-fill-stroke-00.out
--- a/test/out/visualize/shape-fill-stroke-00.out
+++ b/test/out/visualize/shape-fill-stroke-00.out
@@ -65,75 +65,87 @@
              (FieldAccess
                 (Ident (Identifier "enumerate"))
                 (Array
-                   [ FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "stroke") (Literal None) ]
-                   , FuncCall (Ident (Identifier "variant")) []
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Literal None) ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "stroke") (Literal (Numeric 2.0 Pt)) ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "stroke") (Ident (Identifier "eastern")) ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg
-                           (Identifier "stroke")
-                           (Plus (Ident (Identifier "eastern")) (Literal (Numeric 2.0 Pt)))
-                       ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern")) ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern"))
-                       , KeyValArg (Identifier "stroke") (Literal None)
-                       ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
-                       , KeyValArg (Identifier "stroke") (Literal None)
-                       ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
-                       , KeyValArg (Identifier "stroke") (Ident (Identifier "green"))
-                       ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
-                       , KeyValArg
-                           (Identifier "stroke")
-                           (Plus (Ident (Identifier "black")) (Literal (Numeric 2.0 Pt)))
-                       ]
-                   , FuncCall
-                       (Ident (Identifier "variant"))
-                       [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
-                       , KeyValArg
-                           (Identifier "stroke")
-                           (Plus (Ident (Identifier "green")) (Literal (Numeric 2.0 Pt)))
-                       ]
+                   [ Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "stroke") (Literal None) ])
+                   , Reg (FuncCall (Ident (Identifier "variant")) [])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Literal None) ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "stroke") (Literal (Numeric 2.0 Pt)) ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "stroke") (Ident (Identifier "eastern")) ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg
+                              (Identifier "stroke")
+                              (Plus (Ident (Identifier "eastern")) (Literal (Numeric 2.0 Pt)))
+                          ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern")) ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Ident (Identifier "eastern"))
+                          , KeyValArg (Identifier "stroke") (Literal None)
+                          ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
+                          , KeyValArg (Identifier "stroke") (Literal None)
+                          ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
+                          , KeyValArg (Identifier "stroke") (Ident (Identifier "green"))
+                          ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
+                          , KeyValArg
+                              (Identifier "stroke")
+                              (Plus (Ident (Identifier "black")) (Literal (Numeric 2.0 Pt)))
+                          ])
+                   , Reg
+                       (FuncCall
+                          (Ident (Identifier "variant"))
+                          [ KeyValArg (Identifier "fill") (Ident (Identifier "red"))
+                          , KeyValArg
+                              (Identifier "stroke")
+                              (Plus (Ident (Identifier "green")) (Literal (Numeric 2.0 Pt)))
+                          ])
                    ]))
              [])
           (Block
              (CodeBlock
                 [ Array
-                    [ FuncCall
-                        (Ident (Identifier "align"))
-                        [ NormalArg (Ident (Identifier "horizon"))
-                        , BlockArg
-                            [ Code
-                                "test/typ/visualize/shape-fill-stroke-00.typ"
-                                ( line 17 , column 20 )
-                                (Plus (Ident (Identifier "i")) (Literal (Int 1)))
-                            , Text "."
-                            ]
-                        ]
-                    , Ident (Identifier "item")
-                    , Block (Content [])
+                    [ Reg
+                        (FuncCall
+                           (Ident (Identifier "align"))
+                           [ NormalArg (Ident (Identifier "horizon"))
+                           , BlockArg
+                               [ Code
+                                   "test/typ/visualize/shape-fill-stroke-00.typ"
+                                   ( line 17 , column 20 )
+                                   (Plus (Ident (Identifier "i")) (Literal (Int 1)))
+                               , Text "."
+                               ]
+                           ])
+                    , Reg (Ident (Identifier "item"))
+                    , Reg (Block (Content []))
                     ]
                 ]))))
 , ParBreak
@@ -145,12 +157,12 @@
        [ KeyValArg
            (Identifier "columns")
            (Array
-              [ Literal Auto
-              , Literal Auto
-              , Literal (Numeric 1.0 Fr)
-              , Literal Auto
-              , Literal Auto
-              , Literal (Numeric 0.0 Fr)
+              [ Reg (Literal Auto)
+              , Reg (Literal Auto)
+              , Reg (Literal (Numeric 1.0 Fr))
+              , Reg (Literal Auto)
+              , Reg (Literal Auto)
+              , Reg (Literal (Numeric 0.0 Fr))
               ])
        , KeyValArg (Identifier "gutter") (Literal (Numeric 5.0 Pt))
        , SpreadArg (Ident (Identifier "items"))
diff --git a/test/out/visualize/shape-fill-stroke-02.out b/test/out/visualize/shape-fill-stroke-02.out
--- a/test/out/visualize/shape-fill-stroke-02.out
+++ b/test/out/visualize/shape-fill-stroke-02.out
@@ -62,10 +62,10 @@
        [ KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "left" , Ident (Identifier "red") )
-              , ( Identifier "top" , Ident (Identifier "yellow") )
-              , ( Identifier "right" , Ident (Identifier "green") )
-              , ( Identifier "bottom" , Ident (Identifier "blue") )
+              [ Reg ( Identifier "left" , Ident (Identifier "red") )
+              , Reg ( Identifier "top" , Ident (Identifier "yellow") )
+              , Reg ( Identifier "right" , Ident (Identifier "green") )
+              , Reg ( Identifier "bottom" , Ident (Identifier "blue") )
               ])
        , KeyValArg (Identifier "radius") (Literal (Numeric 100.0 Percent))
        , NormalArg
diff --git a/test/out/visualize/shape-rect-01.out b/test/out/visualize/shape-rect-01.out
--- a/test/out/visualize/shape-rect-01.out
+++ b/test/out/visualize/shape-rect-01.out
@@ -191,8 +191,8 @@
               , KeyValArg
                   (Identifier "radius")
                   (Dict
-                     [ ( Identifier "left" , Literal (Numeric 10.0 Pt) )
-                     , ( Identifier "right" , Literal (Numeric 5.0 Pt) )
+                     [ Reg ( Identifier "left" , Literal (Numeric 10.0 Pt) )
+                     , Reg ( Identifier "right" , Literal (Numeric 5.0 Pt) )
                      ])
               ])
        , NormalArg
@@ -202,10 +202,10 @@
               , KeyValArg
                   (Identifier "radius")
                   (Dict
-                     [ ( Identifier "top-left" , Literal (Numeric 2.0 Pt) )
-                     , ( Identifier "top-right" , Literal (Numeric 5.0 Pt) )
-                     , ( Identifier "bottom-right" , Literal (Numeric 8.0 Pt) )
-                     , ( Identifier "bottom-left" , Literal (Numeric 11.0 Pt) )
+                     [ Reg ( Identifier "top-left" , Literal (Numeric 2.0 Pt) )
+                     , Reg ( Identifier "top-right" , Literal (Numeric 5.0 Pt) )
+                     , Reg ( Identifier "bottom-right" , Literal (Numeric 8.0 Pt) )
+                     , Reg ( Identifier "bottom-left" , Literal (Numeric 11.0 Pt) )
                      ])
               ])
        ])
@@ -218,7 +218,7 @@
        (Ident (Identifier "rect"))
        [ KeyValArg
            (Identifier "stroke")
-           (Dict [ ( Identifier "right" , Ident (Identifier "red") ) ])
+           (Dict [ Reg ( Identifier "right" , Ident (Identifier "red") ) ])
        ])
 , SoftBreak
 , Code
@@ -231,8 +231,8 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "x" , Literal (Numeric 5.0 Pt) )
-              , ( Identifier "y" , Literal (Numeric 1.0 Pt) )
+              [ Reg ( Identifier "x" , Literal (Numeric 5.0 Pt) )
+              , Reg ( Identifier "y" , Literal (Numeric 1.0 Pt) )
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/stroke-00.out b/test/out/visualize/stroke-00.out
--- a/test/out/visualize/stroke-00.out
+++ b/test/out/visualize/stroke-00.out
@@ -96,9 +96,9 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "dash" , Literal (String "dashed") )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg ( Identifier "dash" , Literal (String "dashed") )
               ])
        ])
 , SoftBreak
@@ -117,9 +117,9 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
-              , ( Identifier "cap" , Literal (String "round") )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
+              , Reg ( Identifier "cap" , Literal (String "round") )
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/stroke-01.out b/test/out/visualize/stroke-01.out
--- a/test/out/visualize/stroke-01.out
+++ b/test/out/visualize/stroke-01.out
@@ -48,10 +48,10 @@
        [ KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "cap" , Literal (String "butt") )
-              , ( Identifier "dash" , Literal (String "dash-dotted") )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg ( Identifier "cap" , Literal (String "butt") )
+              , Reg ( Identifier "dash" , Literal (String "dash-dotted") )
               ])
        ])
 , SoftBreak
@@ -91,7 +91,7 @@
        [ KeyValArg (Identifier "length") (Literal (Numeric 60.0 Pt))
        , KeyValArg
            (Identifier "stroke")
-           (Dict [ ( Identifier "dash" , Literal None ) ])
+           (Dict [ Reg ( Identifier "dash" , Literal None ) ])
        ])
 , ParBreak
 ]
diff --git a/test/out/visualize/stroke-02.out b/test/out/visualize/stroke-02.out
--- a/test/out/visualize/stroke-02.out
+++ b/test/out/visualize/stroke-02.out
@@ -66,13 +66,14 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "rest" , Ident (Identifier "red") )
-              , ( Identifier "top"
-                , Dict
-                    [ ( Identifier "paint" , Ident (Identifier "blue") )
-                    , ( Identifier "dash" , Literal (String "dashed") )
-                    ]
-                )
+              [ Reg ( Identifier "rest" , Ident (Identifier "red") )
+              , Reg
+                  ( Identifier "top"
+                  , Dict
+                      [ Reg ( Identifier "paint" , Ident (Identifier "blue") )
+                      , Reg ( Identifier "dash" , Literal (String "dashed") )
+                      ]
+                  )
               ])
        ])
 , SoftBreak
@@ -92,8 +93,8 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "thickness" , Literal (Numeric 5.0 Pt) )
-              , ( Identifier "join" , Literal (String "round") )
+              [ Reg ( Identifier "thickness" , Literal (Numeric 5.0 Pt) )
+              , Reg ( Identifier "join" , Literal (String "round") )
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/stroke-03.out b/test/out/visualize/stroke-03.out
--- a/test/out/visualize/stroke-03.out
+++ b/test/out/visualize/stroke-03.out
@@ -49,11 +49,13 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "dash"
-                , Array [ Literal (String "dot") , Literal (Numeric 1.0 Pt) ]
-                )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg
+                  ( Identifier "dash"
+                  , Array
+                      [ Reg (Literal (String "dot")) , Reg (Literal (Numeric 1.0 Pt)) ]
+                  )
               ])
        ])
 , SoftBreak
@@ -72,16 +74,17 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "dash"
-                , Array
-                    [ Literal (String "dot")
-                    , Literal (Numeric 1.0 Pt)
-                    , Literal (Numeric 4.0 Pt)
-                    , Literal (Numeric 2.0 Pt)
-                    ]
-                )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg
+                  ( Identifier "dash"
+                  , Array
+                      [ Reg (Literal (String "dot"))
+                      , Reg (Literal (Numeric 1.0 Pt))
+                      , Reg (Literal (Numeric 4.0 Pt))
+                      , Reg (Literal (Numeric 2.0 Pt))
+                      ]
+                  )
               ])
        ])
 , SoftBreak
@@ -100,21 +103,23 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "dash"
-                , Dict
-                    [ ( Identifier "array"
-                      , Array
-                          [ Literal (String "dot")
-                          , Literal (Numeric 1.0 Pt)
-                          , Literal (Numeric 4.0 Pt)
-                          , Literal (Numeric 2.0 Pt)
-                          ]
-                      )
-                    , ( Identifier "phase" , Literal (Numeric 5.0 Pt) )
-                    ]
-                )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg
+                  ( Identifier "dash"
+                  , Dict
+                      [ Reg
+                          ( Identifier "array"
+                          , Array
+                              [ Reg (Literal (String "dot"))
+                              , Reg (Literal (Numeric 1.0 Pt))
+                              , Reg (Literal (Numeric 4.0 Pt))
+                              , Reg (Literal (Numeric 2.0 Pt))
+                              ]
+                          )
+                      , Reg ( Identifier "phase" , Literal (Numeric 5.0 Pt) )
+                      ]
+                  )
               ])
        ])
 , SoftBreak
@@ -133,9 +138,9 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "dash" , Array [] )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg ( Identifier "dash" , Array [] )
               ])
        ])
 , SoftBreak
@@ -154,15 +159,16 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
-              , ( Identifier "dash"
-                , Array
-                    [ Literal (Numeric 1.0 Pt)
-                    , Literal (Numeric 3.0 Pt)
-                    , Literal (Numeric 9.0 Pt)
-                    ]
-                )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 1.0 Pt) )
+              , Reg
+                  ( Identifier "dash"
+                  , Array
+                      [ Reg (Literal (Numeric 1.0 Pt))
+                      , Reg (Literal (Numeric 3.0 Pt))
+                      , Reg (Literal (Numeric 9.0 Pt))
+                      ]
+                  )
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/stroke-04.out b/test/out/visualize/stroke-04.out
--- a/test/out/visualize/stroke-04.out
+++ b/test/out/visualize/stroke-04.out
@@ -53,18 +53,30 @@
               [ KeyValArg
                   (Identifier "stroke")
                   (Dict
-                     [ ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
-                     , ( Identifier "paint" , Ident (Identifier "blue") )
-                     , ( Identifier "join" , Literal (String "round") )
+                     [ Reg ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
+                     , Reg ( Identifier "paint" , Ident (Identifier "blue") )
+                     , Reg ( Identifier "join" , Literal (String "round") )
                      ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 20.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 20.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 40.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 40.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 45.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 45.0 Pt))
+                     ])
               ])
        , NormalArg
            (FuncCall
@@ -72,18 +84,30 @@
               [ KeyValArg
                   (Identifier "stroke")
                   (Dict
-                     [ ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
-                     , ( Identifier "paint" , Ident (Identifier "blue") )
-                     , ( Identifier "join" , Literal (String "bevel") )
+                     [ Reg ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
+                     , Reg ( Identifier "paint" , Ident (Identifier "blue") )
+                     , Reg ( Identifier "join" , Literal (String "bevel") )
                      ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 20.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 20.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 40.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 40.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 45.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 45.0 Pt))
+                     ])
               ])
        , NormalArg
            (FuncCall
@@ -91,18 +115,30 @@
               [ KeyValArg
                   (Identifier "stroke")
                   (Dict
-                     [ ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
-                     , ( Identifier "paint" , Ident (Identifier "blue") )
-                     , ( Identifier "join" , Literal (String "miter") )
+                     [ Reg ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
+                     , Reg ( Identifier "paint" , Ident (Identifier "blue") )
+                     , Reg ( Identifier "join" , Literal (String "miter") )
                      ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 20.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 20.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 40.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 40.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 45.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 45.0 Pt))
+                     ])
               ])
        , NormalArg
            (FuncCall
@@ -110,19 +146,31 @@
               [ KeyValArg
                   (Identifier "stroke")
                   (Dict
-                     [ ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
-                     , ( Identifier "paint" , Ident (Identifier "blue") )
-                     , ( Identifier "join" , Literal (String "miter") )
-                     , ( Identifier "miter-limit" , Literal (Float 20.0) )
+                     [ Reg ( Identifier "thickness" , Literal (Numeric 4.0 Pt) )
+                     , Reg ( Identifier "paint" , Ident (Identifier "blue") )
+                     , Reg ( Identifier "join" , Literal (String "miter") )
+                     , Reg ( Identifier "miter-limit" , Literal (Float 20.0) )
                      ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 20.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 20.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 0.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 0.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 0.0 Pt) , Literal (Numeric 40.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Pt))
+                     , Reg (Literal (Numeric 40.0 Pt))
+                     ])
               , NormalArg
-                  (Array [ Literal (Numeric 15.0 Pt) , Literal (Numeric 45.0 Pt) ])
+                  (Array
+                     [ Reg (Literal (Numeric 15.0 Pt))
+                     , Reg (Literal (Numeric 45.0 Pt))
+                     ])
               ])
        ])
 , ParBreak
diff --git a/test/out/visualize/stroke-07.out b/test/out/visualize/stroke-07.out
--- a/test/out/visualize/stroke-07.out
+++ b/test/out/visualize/stroke-07.out
@@ -103,11 +103,13 @@
        , KeyValArg
            (Identifier "stroke")
            (Dict
-              [ ( Identifier "paint" , Ident (Identifier "red") )
-              , ( Identifier "thickness" , Literal (Numeric 0.0 Pt) )
-              , ( Identifier "dash"
-                , Array [ Literal (String "dot") , Literal (Numeric 1.0 Pt) ]
-                )
+              [ Reg ( Identifier "paint" , Ident (Identifier "red") )
+              , Reg ( Identifier "thickness" , Literal (Numeric 0.0 Pt) )
+              , Reg
+                  ( Identifier "dash"
+                  , Array
+                      [ Reg (Literal (String "dot")) , Reg (Literal (Numeric 1.0 Pt)) ]
+                  )
               ])
        ])
 , ParBreak
@@ -143,35 +145,55 @@
        , KeyValArg (Identifier "closed") (Literal (Boolean True))
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 0.0 Percent) , Literal (Numeric 0.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent)
-                  , Negated (Literal (Numeric 4.0 Percent))
-                  ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Percent))
+                     , Reg (Literal (Numeric 0.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Negated (Literal (Numeric 4.0 Percent)))
+                     ])
               ])
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 50.0 Percent) , Literal (Numeric 50.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent)
-                  , Negated (Literal (Numeric 4.0 Percent))
-                  ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 50.0 Percent))
+                     , Reg (Literal (Numeric 50.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Negated (Literal (Numeric 4.0 Percent)))
+                     ])
               ])
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 0.0 Percent) , Literal (Numeric 50.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent) , Literal (Numeric 4.0 Percent) ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Percent))
+                     , Reg (Literal (Numeric 50.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Literal (Numeric 4.0 Percent))
+                     ])
               ])
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 50.0 Percent) , Literal (Numeric 0.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent) , Literal (Numeric 4.0 Percent) ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 50.0 Percent))
+                     , Reg (Literal (Numeric 0.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Literal (Numeric 4.0 Percent))
+                     ])
               ])
        ])
 , ParBreak
@@ -185,35 +207,55 @@
        , KeyValArg (Identifier "closed") (Literal (Boolean True))
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 0.0 Percent) , Literal (Numeric 0.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent)
-                  , Negated (Literal (Numeric 4.0 Percent))
-                  ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Percent))
+                     , Reg (Literal (Numeric 0.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Negated (Literal (Numeric 4.0 Percent)))
+                     ])
               ])
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 50.0 Percent) , Literal (Numeric 50.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent)
-                  , Negated (Literal (Numeric 4.0 Percent))
-                  ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 50.0 Percent))
+                     , Reg (Literal (Numeric 50.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Negated (Literal (Numeric 4.0 Percent)))
+                     ])
               ])
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 0.0 Percent) , Literal (Numeric 50.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent) , Literal (Numeric 4.0 Percent) ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 0.0 Percent))
+                     , Reg (Literal (Numeric 50.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Literal (Numeric 4.0 Percent))
+                     ])
               ])
        , NormalArg
            (Array
-              [ Array
-                  [ Literal (Numeric 50.0 Percent) , Literal (Numeric 0.0 Percent) ]
-              , Array
-                  [ Literal (Numeric 4.0 Percent) , Literal (Numeric 4.0 Percent) ]
+              [ Reg
+                  (Array
+                     [ Reg (Literal (Numeric 50.0 Percent))
+                     , Reg (Literal (Numeric 0.0 Percent))
+                     ])
+              , Reg
+                  (Array
+                     [ Reg (Literal (Numeric 4.0 Percent))
+                     , Reg (Literal (Numeric 4.0 Percent))
+                     ])
               ])
        ])
 , ParBreak
diff --git a/test/typ/regression/issue1.typ b/test/typ/regression/issue1.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue1.typ
@@ -0,0 +1,6 @@
+#(
+  let foo(x) = {
+  return (..x, 5);
+  }
+)
+#foo((3,4))
diff --git a/test/typ/regression/issue2.typ b/test/typ/regression/issue2.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue2.typ
@@ -0,0 +1,1 @@
+$lr(#sym.alpha#sym.beta)$
diff --git a/test/typ/regression/issue3.typ b/test/typ/regression/issue3.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue3.typ
@@ -0,0 +1,2 @@
+#let alpha=(named:(a:1,b:2))
+#(..alpha.named, c: 3)
diff --git a/test/typ/regression/issue5.typ b/test/typ/regression/issue5.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue5.typ
@@ -0,0 +1,1 @@
+$ 3! $
diff --git a/test/typ/regression/issue6.typ b/test/typ/regression/issue6.typ
new file mode 100644
--- /dev/null
+++ b/test/typ/regression/issue6.typ
@@ -0,0 +1,2 @@
+$ #let g = $3$
+#g $
diff --git a/typst.cabal b/typst.cabal
--- a/typst.cabal
+++ b/typst.cabal
@@ -1,10 +1,10 @@
 cabal-version:      2.4
 name:               typst
-version:            0.2.0.0
+version:            0.3.0.0
 synopsis:           Parsing and evaluating typst syntax.
 description:        A library for parsing and evaluating typst syntax.
                     Typst (<https://typst.app>) is a document layout and
-                    formatting language. This library targets typst 0.5
+                    formatting language. This library targets typst 0.6
                     and currently offers only partial support.
 license:            BSD-3-Clause
 license-file:       LICENSE
@@ -55,12 +55,13 @@
 
     -- other-extensions:
     build-depends:    base >= 4.14 && <= 5,
-                      typst-symbols >= 0.1.1 && < 0.2,
+                      typst-symbols >= 0.1.2 && < 0.2,
                       mtl,
                       vector,
                       parsec,
                       filepath,
                       containers,
+                      directory >= 1.2.3,
                       ordered-containers,
                       text,
                       bytestring,
@@ -69,12 +70,17 @@
                       scientific,
                       xml-conduit,
                       yaml,
+                      toml-parser,
                       regex-tdfa,
                       array,
                       time,
                       pretty,
                       digits
     hs-source-dirs:   src
+    if os(darwin)
+      cpp-options: -D__MACOS__
+    if os(windows)
+      cpp-options: -D__WINDOWS__
     default-language: Haskell2010
 
 Flag executable
@@ -91,6 +97,7 @@
       Build-depends:
         base,
         typst,
+        directory >= 1.2.3,
         parsec,
         mtl,
         vector,
@@ -112,6 +119,7 @@
     build-depends:
         base,
         typst,
+        directory >= 1.2.3,
         text,
         bytestring,
         filepath,