Merge pull request #624 from github/direct-codegen

AOT codegen
2024-11-22 23:29:37 +03:00 · 2020-09-18 10:21:46 -04:00 · 2020-09-18 10:21:46 -04:00 · a2902fd27f
commit a2902fd27f
parent aca39e8668 f1e22be192
21 changed files with 51109 additions and 131 deletions
--- a/.github/workflows/bazel.yml
+++ b/.github/workflows/bazel.yml
@ -24,7 +24,6 @@ jobs:
        path: |
          .bazel-cache
          bin
-          /home/runner/.cache
        key: ${{ runner.os }}-bazel-${{ github.run_id }}
        restore-keys: |
          ${{ runner.os }}-bazel-
--- a/.github/workflows/haskell.yml
+++ b/.github/workflows/haskell.yml
@ -14,7 +14,7 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        ghc: ["8.8.3", "8.10.1"]
+        ghc: ["8.10.1"]
        cabal: ["3.2.0.0"]

    steps:
--- a/README.md
+++ b/README.md
@ -58,7 +58,7 @@ Available options:

 ## Development

-`semantic` requires at least GHC 8.8.3 and Cabal 3.0. We strongly recommend using [`ghcup`][ghcup] to sandbox GHC versions, as GHC packages installed through your OS's package manager may not install statically-linked versions of the GHC boot libraries. `semantic` currently builds only on Unix systems; users of other operating systems may wish to use the [Docker images](https://github.com/github/semantic/packages/11609).
+`semantic` requires at least GHC 8.10.1 and Cabal 3.0. We strongly recommend using [`ghcup`][ghcup] to sandbox GHC versions, as GHC packages installed through your OS's package manager may not install statically-linked versions of the GHC boot libraries. `semantic` currently builds only on Unix systems; users of other operating systems may wish to use the [Docker images](https://github.com/github/semantic/packages/11609).

 We use `cabal's` [Nix-style local builds][nix] for development. To get started quickly:

--- a/3
+++ b/3
@ -96,9 +96,11 @@ stack_snapshot(
        "hspec-expectations",
        "lens",
        "lingo",
+        "neat-interpolation",
        "network",
        "network-uri",
        "optparse-applicative",
+        "optparse-generic",
        "parsers",
        "pathtype",
        "pretty-show",
@ -138,6 +140,7 @@ stack_snapshot(
        "vector",
        "yaml",
    ],
+    stack_snapshot_json = "//:stackage_snapshot.json",
    tools = ["@happy"],
    vendored_packages = {
        "tree-sitter-{}".format(name): "@tree-sitter-{name}//:tree-sitter-{name}".format(name = name)
--- a/script/astgen
+++ b/script/astgen
@ -0,0 +1,2 @@
+#!/bin/bash
+bazel run //semantic-ast:generate-ast -- --language=all --rootdir=$PWD
--- a/semantic-ast/BUILD.bazel
+++ b/semantic-ast/BUILD.bazel
@ -12,6 +12,7 @@ load(
 )
 load(
    "//:build/common.bzl",
+    "EXECUTABLE_FLAGS",
    "GHC_FLAGS",
 )

@ -46,3 +47,52 @@ haskell_library(
        "@stackage//:unordered-containers",
    ],
 )
+
+all_ts_deps = ["@tree-sitter-{name}".format(name = name) for name in [
+    "go",
+    "java",
+    "json",
+    "php",
+    "python",
+    "ql",
+    "ruby",
+    "rust",
+    "tsx",
+    "typescript",
+]]
+
+all_file_deps = ["@tree-sitter-{name}//:src/node-types.json".format(name = name) for name in [
+    "go",
+    "java",
+    "json",
+    "php",
+    "python",
+    "ql",
+    "ruby",
+    "rust",
+    "tsx",
+    "typescript",
+]]
+
+haskell_binary(
+    name = "generate-ast",
+    srcs = glob(["app/**/*.hs"]),
+    compiler_flags = GHC_FLAGS + EXECUTABLE_FLAGS + ["-XStrictData"],
+    data = all_file_deps,
+    deps = [
+        ":semantic-ast",
+        "//:base",
+        "//:filepath",
+        "//:process",
+        "//:template-haskell",
+        "//:text",
+        "//semantic-source",
+        "@stackage//:bazel-runfiles",
+        "@stackage//:directory",
+        "@stackage//:generic-lens",
+        "@stackage//:lens",
+        "@stackage//:neat-interpolation",
+        "@stackage//:optparse-generic",
+        "@stackage//:tree-sitter",
+    ] + all_ts_deps,
+)
--- a/semantic-ast/README.md
+++ b/semantic-ast/README.md
@ -1,5 +1,17 @@
 # semantic-ast

-This package is concerned with the CodeGen generation of strongly-typed ASTs. 
+This package is concerned with the CodeGen generation of strongly-typed ASTs.
+
+The provided `semantic-ast` executable is responsible for generating ASTs from language definitions. You can run it like so:
+
+```
+cabal run semantic-ast -- --language=JSON
+```
+
+You can also pass `all` to regenerate every language definition:
+
+```
+cabal run semantic-ast -- --language=all
+```

 [Documentation](https://github.com/github/semantic/blob/master/docs/codegen.md)
--- a/semantic-ast/app/Main.hs
+++ b/semantic-ast/app/Main.hs
@ -0,0 +1,203 @@
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Main (main) where
+
+import AST.GenerateSyntax
+import qualified Bazel.Runfiles as Bazel
+import Control.Lens (Traversal', mapped, (%~))
+import Control.Monad
+import Data.Foldable
+import Data.Generics.Product.Typed (typed)
+import Data.Maybe
+import Data.Text (Text)
+import qualified Data.Text as T
+import qualified Data.Text.IO as T
+import Foreign
+import GHC.Generics (Generic)
+import Language.Haskell.TH hiding (JavaScript)
+import Language.Haskell.TH.Lens
+import NeatInterpolation
+import qualified Options.Generic as Opt
+import Source.Language
+import System.FilePath
+import System.Directory
+import System.Exit
+import System.IO
+import System.Process
+import Text.Printf
+import qualified TreeSitter.Go as Go (tree_sitter_go)
+import qualified TreeSitter.JSON as JSON (tree_sitter_json)
+import qualified TreeSitter.Java as Java (tree_sitter_java)
+import qualified TreeSitter.Language
+import qualified TreeSitter.PHP as PHP (tree_sitter_php)
+import qualified TreeSitter.Python as Python (tree_sitter_python)
+import qualified TreeSitter.QL as CodeQL (tree_sitter_ql)
+import qualified TreeSitter.Ruby as Ruby (tree_sitter_ruby)
+import qualified TreeSitter.TSX as TSX (tree_sitter_tsx)
+import qualified TreeSitter.TypeScript as TypeScript (tree_sitter_typescript)
+
+-- As a special case, you can pass
+data Config = Config {language :: Text, rootdir :: FilePath}
+  deriving stock (Show, Generic)
+  deriving anyclass (Opt.ParseRecord)
+
+-- There are a few cases where the output emitted by TH's 'pprint' doesn't
+-- create entirely valid Haskell syntax, because sometimes we get
+-- a qualified name on the LHS of a typeclass declaration, which Haskell
+-- doesn't like at all. I haven't figured out quite why we get this qualified
+-- name, but for now the easiest thing to do is some nested updates with lens.
+adjust :: Dec -> Dec
+adjust = _InstanceD . typed . mapped %~ (values %~ truncate) . (functions %~ truncate)
+  where
+    -- Need to handle functions with no arguments, which are parsed as ValD entities,
+    -- as well as those with arguments, which are FunD.
+    values, functions :: Traversal' Dec Name
+    values = _ValD . typed . _VarP
+    functions = _FunD . typed
+
+    truncate :: Name -> Name
+    truncate = mkName . nameBase
+
+pathForLanguage :: Bazel.Runfiles -> Language -> FilePath
+pathForLanguage rf =
+  let loc = Bazel.rlocation rf
+   in \case
+        CodeQL -> loc "tree-sitter-ql/vendor/tree-sitter-ql/src/node-types.json"
+        Go -> loc "tree-sitter-go/vendor/tree-sitter-go/src/node-types.json"
+        PHP -> loc "tree-sitter-php/vendor/tree-sitter-php/src/node-types.json"
+        Python -> loc "tree-sitter-python/vendor/tree-sitter-python/src/node-types.json"
+        Ruby -> loc "tree-sitter-ruby/vendor/tree-sitter-ruby/src/node-types.json"
+        TypeScript -> loc "tree-sitter-typescript/vendor/tree-sitter-typescript/typescript/src/node-types.json"
+        TSX -> loc "tree-sitter-tsx/vendor/tree-sitter-typescript/tsx/src/node-types.json"
+        JavaScript -> loc "tree-sitter-typescript/vendor/tree-sitter-typescript/typescript/src/node-types.json"
+        JSX -> loc "tree-sitter-typescript/vendor/tree-sitter-typescript/src/tsx/node-types.json"
+        Java -> loc "tree-sitter-java/vendor/tree-sitter-java/src/node-types.json"
+        other -> error ("Couldn't find path for " <> show other)
+
+targetForLanguage :: Language -> FilePath
+targetForLanguage x =
+  let go lc = printf "semantic-%s/src/Language/%s/AST.hs" (lc :: String) (show x)
+   in case x of
+        CodeQL -> go "codeql"
+        Go -> go "go"
+        PHP -> go "php"
+        Python -> go "python"
+        Ruby -> go "ruby"
+        TypeScript -> go "typescript"
+        TSX -> go "tsx"
+        JavaScript -> go "javascript"
+        Java -> go "java"
+        other -> error ("Couldn't find path for " <> show other)
+
+parserForLanguage :: Language -> Ptr TreeSitter.Language.Language
+parserForLanguage = \case
+  Unknown -> error "Unknown language encountered"
+  CodeQL -> (CodeQL.tree_sitter_ql)
+  Go -> Go.tree_sitter_go
+  Haskell -> error "Haskell backend not implemented yet"
+  Java -> Java.tree_sitter_java
+  JavaScript -> TypeScript.tree_sitter_typescript
+  JSON -> JSON.tree_sitter_json
+  JSX -> TSX.tree_sitter_tsx
+  Markdown -> error "Markdown backend deprecated"
+  PHP -> PHP.tree_sitter_php
+  Python -> Python.tree_sitter_python
+  Ruby -> Ruby.tree_sitter_ruby
+  TypeScript -> TypeScript.tree_sitter_typescript
+  TSX -> TSX.tree_sitter_tsx
+
+-- nodeTypesPathForLanguage :: Bazel.Runfiles -> Language -> FilePath
+-- nodeTypesPathForLanguage rf = \case
+--   CodeQL -> r
+
+validLanguages :: [Language]
+validLanguages = [CodeQL, Go, Java, PHP, Python, Ruby, TypeScript, TSX]
+
+emit :: FilePath -> Language -> IO ()
+emit root lang = do
+  rf <- Bazel.create
+  let language = languageToText lang
+  let languageHack = case lang of
+        CodeQL -> "QL"
+        _ -> language
+  let path = pathForLanguage rf lang
+  decls <- T.pack . pprint . fmap adjust <$> astDeclarationsIO (parserForLanguage lang) path
+
+  let programText =
+        [trimming|
+-- Language definition for $language, generated by ast-generate. Do not edit!
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveTraversable #-}
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE QuantifiedConstraints #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+
+module Language.$language.AST (module Language.$language.AST, getTestCorpusDir) where
+
+import qualified AST.Parse
+import qualified AST.Token
+import qualified AST.Traversable1.Class
+import qualified AST.Unmarshal
+import qualified Data.Foldable
+import qualified Data.List as Data.OldList
+import qualified Data.Maybe as GHC.Maybe
+import qualified Data.Text.Internal
+import qualified Data.Traversable
+import qualified GHC.Base
+import qualified GHC.Generics
+import qualified GHC.Records
+import qualified GHC.Show
+import qualified Prelude as GHC.Classes
+import qualified TreeSitter.Node
+
+import TreeSitter.$languageHack (getTestCorpusDir)
+
+debugSymbolNames :: [GHC.Base.String]
+debugSymbolNames = debugSymbolNames_0
+
+$decls
+  |]
+  hasOrmolu <- findExecutable "ormolu"
+  if isNothing hasOrmolu
+    then do
+      T.putStrLn programText
+      hPutStrLn stderr "generate-ast: No `ormolu` executable found, output will look janky."
+    else do
+      (path, tf) <- openTempFile "/tmp" "generated.hs"
+      T.hPutStrLn tf programText
+      hClose tf
+      callProcess "ormolu" ["--mode", "inplace", path]
+      callProcess "cp" [path, root </> targetForLanguage lang]
+
+main :: IO ()
+main = do
+  Config language root <- Opt.getRecord "generate-ast"
+  if language == "all"
+    then traverse_ (emit root) validLanguages
+    else do
+      let lang = textToLanguage language
+      when (lang == Unknown) (die ("Couldn't determine language for " <> T.unpack language))
+      emit root lang
--- a/semantic-ast/semantic-ast.cabal
+++ b/semantic-ast/semantic-ast.cabal
@ -80,4 +80,3 @@ library
    , unordered-containers ^>= 0.2.10

  hs-source-dirs:      src
-  default-language:    Haskell2010
--- a/semantic-ast/src/AST/GenerateSyntax.hs
+++ b/semantic-ast/src/AST/GenerateSyntax.hs
@ -9,6 +9,7 @@
 module AST.GenerateSyntax
 ( syntaxDatatype
 , astDeclarationsForLanguage
+, astDeclarationsIO
 ) where

 import           AST.Deserialize (Children (..), Datatype (..), DatatypeName (..), Field (..), Multiple (..), Named (..), Required (..), Type (..))
@ -44,13 +45,20 @@ astDeclarationsForLanguage language filePath = do
  currentFilename <- loc_filename <$> location
  pwd             <- runIO getCurrentDirectory
  let invocationRelativePath = takeDirectory (pwd </> currentFilename) </> filePath
+  astDeclarationsRelative lookupTypeName language invocationRelativePath
+
+astDeclarationsIO :: Ptr TS.Language -> FilePath -> IO [Dec]
+astDeclarationsIO lang p = runQ (astDeclarationsRelative (const (pure Nothing)) lang p)
+
+astDeclarationsRelative :: (String -> Q (Maybe Name)) -> Ptr TS.Language -> FilePath -> Q [Dec]
+astDeclarationsRelative lookupName language invocationRelativePath = do
  input <- runIO (eitherDecodeFileStrict' invocationRelativePath) >>= either fail pure
  allSymbols <- runIO (getAllSymbols language)
  debugSymbolNames <- [d|
    debugSymbolNames :: [String]
    debugSymbolNames = $(listE (map (litE . stringL . debugPrefix) allSymbols))
    |]
-  mappend debugSymbolNames . concat @[] <$> traverse (syntaxDatatype language allSymbols) input
+  mappend debugSymbolNames . concat @[] <$> traverse (syntaxDatatype lookupName language allSymbols) input

 -- Build a list of all symbols
 getAllSymbols :: Ptr TS.Language -> IO [(String, Named)]
@ -69,14 +77,14 @@ annParameterName :: Name
 annParameterName = mkName "a"

 -- Auto-generate Haskell datatypes for sums, products and leaf types
-syntaxDatatype :: Ptr TS.Language -> [(String, Named)] -> Datatype -> Q [Dec]
-syntaxDatatype language allSymbols datatype = skipDefined $ do
+syntaxDatatype :: (String -> Q (Maybe Name)) -> Ptr TS.Language -> [(String, Named)] -> Datatype -> Q [Dec]
+syntaxDatatype lookupType language allSymbols datatype = skipDefined $ do
  let traversalInstances = mappend <$> makeStandaloneDerivings (conT name) <*> makeTraversalInstances (conT name)
      glue a b c = a : b <> c
      name = mkName nameStr
      generatedDatatype cons = dataD (cxt []) name [plainTV annParameterName] Nothing cons [deriveStockClause, deriveAnyClassClause]
      deriveStockClause = derivClause (Just StockStrategy) [conT ''Generic, conT ''Generic1]
-      deriveAnyClassClause = derivClause (Just AnyclassStrategy) [conT ''Traversable1 `appT` varT (mkName "someConstraint")]
+      deriveAnyClassClause = derivClause (Just AnyclassStrategy) [ [t| (forall a. Traversable1 a) |] ]
      deriveGN = derivClause (Just NewtypeStrategy) [conT ''TS.SymbolMatching]
  case datatype of
    SumType (DatatypeName _) _ subtypes ->
@ -101,7 +109,7 @@ syntaxDatatype language allSymbols datatype = skipDefined $ do
  where
    -- Skip generating datatypes that have already been defined (overridden) in the module where the splice is running.
    skipDefined m = do
-      isLocal <- lookupTypeName nameStr >>= maybe (pure False) isLocalName
+      isLocal <- lookupType nameStr >>= maybe (pure False) isLocalName
      if isLocal then pure [] else m
    nameStr = toNameString (datatypeNameStatus datatype) (getDatatypeName (AST.Deserialize.datatypeName datatype))

--- a/semantic-codeql/src/Language/CodeQL/AST.hs
+++ b/semantic-codeql/src/Language/CodeQL/AST.hs
--- a/semantic-go/src/Language/Go/AST.hs
+++ b/semantic-go/src/Language/Go/AST.hs
--- a/semantic-java/src/Language/Java/AST.hs
+++ b/semantic-java/src/Language/Java/AST.hs
--- a/semantic-json/src/Language/JSON/AST.hs
+++ b/semantic-json/src/Language/JSON/AST.hs
@ -1,3 +1,4 @@
+-- Language definition for JSON, generated by ast-generate. Do not edit!
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DeriveAnyClass #-}
@ -17,18 +18,589 @@
 {-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -fno-warn-unused-imports #-}

-module Language.JSON.AST
-( module Language.JSON.AST
-, JSON.getTestCorpusDir
-) where
+module Language.JSON.AST (module Language.JSON.AST, getTestCorpusDir) where

-import           AST.GenerateSyntax
-import           Language.Haskell.TH.Syntax (runIO)
-import           Prelude hiding (String)
-import qualified TreeSitter.JSON as JSON (getNodeTypesPath, getTestCorpusDir, tree_sitter_json)
+import qualified AST.Parse
+import qualified AST.Token
+import qualified AST.Traversable1.Class
+import qualified AST.Unmarshal
+import qualified Data.Foldable
+import qualified Data.List as Data.OldList
+import qualified Data.Maybe as GHC.Maybe
+import qualified Data.Text.Internal
+import qualified Data.Traversable
+import qualified GHC.Base
+import qualified GHC.Generics
+import qualified GHC.Records
+import qualified GHC.Show
+import TreeSitter.JSON (getTestCorpusDir)
+import qualified TreeSitter.Node
+import qualified Prelude as GHC.Classes
+
+debugSymbolNames :: [GHC.Base.String]
+debugSymbolNames = debugSymbolNames_0
+
+debugSymbolNames_0 :: [GHC.Base.String]
+debugSymbolNames_0 =
+  [ "end",
+    "_{",
+    "_,",
+    "_}",
+    "_:",
+    "_[",
+    "_]",
+    "_\"",
+    "_string_content_token1",
+    "escape_sequence",
+    "number",
+    "true",
+    "false",
+    "null",
+    "document",
+    "_value",
+    "object",
+    "pair",
+    "array",
+    "string",
+    "string_content",
+    "_object_repeat1",
+    "_array_repeat1",
+    "_string_content_repeat1"
+  ]
+
+newtype Value a = Value {getValue :: ((Array GHC.Generics.:+: False GHC.Generics.:+: Null GHC.Generics.:+: Number GHC.Generics.:+: Object GHC.Generics.:+: String GHC.Generics.:+: True) a)}
+  deriving newtype (AST.Unmarshal.SymbolMatching)
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_1.
+      AST.Traversable1.Class.Traversable1 a_1
+    )
+
+instance GHC.Records.HasField "ann" (Value a_2) a_2 where
+  getField = AST.Unmarshal.gann GHC.Base.. getValue
+
+deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (Value a_3)
+
+deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (Value a_4)
+
+deriving instance GHC.Show.Show a_5 => GHC.Show.Show (Value a_5)
+
+instance AST.Unmarshal.Unmarshal Value
+
+instance Data.Foldable.Foldable Value where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Value where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Value where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data Array a = Array {ann :: a, extraChildren :: ([AST.Parse.Err (Value a)])}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_6.
+      AST.Traversable1.Class.Traversable1 a_6
+    )
+
+instance AST.Unmarshal.SymbolMatching Array where
+  matchedSymbols _ = [18]
+  showFailure _ node_7 =
+    "expected "
+      GHC.Base.<> ( "array"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_7 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_7) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_8 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_9 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_10 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_11 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_8
+        c1_9 = TreeSitter.Node.nodeStartPoint node_7
+      TreeSitter.Node.TSPoint
+        r2_10
+        c2_11 = TreeSitter.Node.nodeEndPoint node_7
+
+deriving instance GHC.Classes.Eq a_12 => GHC.Classes.Eq (Array a_12)
+
+deriving instance GHC.Classes.Ord a_13 => GHC.Classes.Ord (Array a_13)
+
+deriving instance GHC.Show.Show a_14 => GHC.Show.Show (Array a_14)
+
+instance AST.Unmarshal.Unmarshal Array
+
+instance Data.Foldable.Foldable Array where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Array where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Array where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data Document a = Document {ann :: a, extraChildren :: (AST.Parse.Err (Value a))}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_15.
+      AST.Traversable1.Class.Traversable1 a_15
+    )
+
+instance AST.Unmarshal.SymbolMatching Document where
+  matchedSymbols _ = [14]
+  showFailure _ node_16 =
+    "expected "
+      GHC.Base.<> ( "document"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_16 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_16) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_17 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_18 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_19 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_20 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_17
+        c1_18 = TreeSitter.Node.nodeStartPoint node_16
+      TreeSitter.Node.TSPoint
+        r2_19
+        c2_20 = TreeSitter.Node.nodeEndPoint node_16
+
+deriving instance GHC.Classes.Eq a_21 => GHC.Classes.Eq (Document a_21)
+
+deriving instance GHC.Classes.Ord a_22 => GHC.Classes.Ord (Document a_22)
+
+deriving instance GHC.Show.Show a_23 => GHC.Show.Show (Document a_23)
+
+instance AST.Unmarshal.Unmarshal Document
+
+instance Data.Foldable.Foldable Document where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Document where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Document where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data Object a = Object {ann :: a, extraChildren :: ([AST.Parse.Err (Pair a)])}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_24.
+      AST.Traversable1.Class.Traversable1 a_24
+    )
+
+instance AST.Unmarshal.SymbolMatching Object where
+  matchedSymbols _ = [16]
+  showFailure _ node_25 =
+    "expected "
+      GHC.Base.<> ( "object"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_25 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_25) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_26 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_27 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_28 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_29 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_26
+        c1_27 = TreeSitter.Node.nodeStartPoint node_25
+      TreeSitter.Node.TSPoint
+        r2_28
+        c2_29 = TreeSitter.Node.nodeEndPoint node_25
+
+deriving instance GHC.Classes.Eq a_30 => GHC.Classes.Eq (Object a_30)
+
+deriving instance GHC.Classes.Ord a_31 => GHC.Classes.Ord (Object a_31)
+
+deriving instance GHC.Show.Show a_32 => GHC.Show.Show (Object a_32)
+
+instance AST.Unmarshal.Unmarshal Object
+
+instance Data.Foldable.Foldable Object where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Object where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Object where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data Pair a = Pair
+  { ann :: a,
+    value :: (AST.Parse.Err (Value a)),
+    key :: (AST.Parse.Err ((Number GHC.Generics.:+: String) a))
+  }
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_33.
+      AST.Traversable1.Class.Traversable1 a_33
+    )
+
+instance AST.Unmarshal.SymbolMatching Pair where
+  matchedSymbols _ = [17]
+  showFailure _ node_34 =
+    "expected "
+      GHC.Base.<> ( "pair"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_34 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_34) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_35 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_36 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_37 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_38 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_35
+        c1_36 = TreeSitter.Node.nodeStartPoint node_34
+      TreeSitter.Node.TSPoint
+        r2_37
+        c2_38 = TreeSitter.Node.nodeEndPoint node_34
+
+deriving instance GHC.Classes.Eq a_39 => GHC.Classes.Eq (Pair a_39)
+
+deriving instance GHC.Classes.Ord a_40 => GHC.Classes.Ord (Pair a_40)
+
+deriving instance GHC.Show.Show a_41 => GHC.Show.Show (Pair a_41)
+
+instance AST.Unmarshal.Unmarshal Pair
+
+instance Data.Foldable.Foldable Pair where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Pair where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Pair where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data String a = String
+  { ann :: a,
+    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (StringContent a)))
+  }
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_42.
+      AST.Traversable1.Class.Traversable1 a_42
+    )
+
+instance AST.Unmarshal.SymbolMatching String where
+  matchedSymbols _ = [19]
+  showFailure _ node_43 =
+    "expected "
+      GHC.Base.<> ( "string"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_43 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_43) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_44 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_45 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_46 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_47 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_44
+        c1_45 = TreeSitter.Node.nodeStartPoint node_43
+      TreeSitter.Node.TSPoint
+        r2_46
+        c2_47 = TreeSitter.Node.nodeEndPoint node_43
+
+deriving instance GHC.Classes.Eq a_48 => GHC.Classes.Eq (String a_48)
+
+deriving instance GHC.Classes.Ord a_49 => GHC.Classes.Ord (String a_49)
+
+deriving instance GHC.Show.Show a_50 => GHC.Show.Show (String a_50)
+
+instance AST.Unmarshal.Unmarshal String
+
+instance Data.Foldable.Foldable String where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor String where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable String where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data StringContent a = StringContent
+  { ann :: a,
+    extraChildren :: ([AST.Parse.Err (EscapeSequence a)])
+  }
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_51.
+      AST.Traversable1.Class.Traversable1 a_51
+    )
+
+instance AST.Unmarshal.SymbolMatching StringContent where
+  matchedSymbols _ = [20]
+  showFailure _ node_52 =
+    "expected "
+      GHC.Base.<> ( "string_content"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_52 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_52) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_53 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_54 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_55 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_56 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_53
+        c1_54 = TreeSitter.Node.nodeStartPoint node_52
+      TreeSitter.Node.TSPoint
+        r2_55
+        c2_56 = TreeSitter.Node.nodeEndPoint node_52
+
+deriving instance GHC.Classes.Eq a_57 => GHC.Classes.Eq (StringContent a_57)
+
+deriving instance GHC.Classes.Ord a_58 => GHC.Classes.Ord (StringContent a_58)
+
+deriving instance GHC.Show.Show a_59 => GHC.Show.Show (StringContent a_59)
+
+instance AST.Unmarshal.Unmarshal StringContent
+
+instance Data.Foldable.Foldable StringContent where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor StringContent where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable StringContent where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+type AnonymousDQuote = AST.Token.Token "\"" 7
+
+type AnonymousComma = AST.Token.Token "," 2
+
+type AnonymousColon = AST.Token.Token ":" 4
+
+type AnonymousLBracket = AST.Token.Token "[" 5
+
+type AnonymousRBracket = AST.Token.Token "]" 6
+
+data EscapeSequence a = EscapeSequence {ann :: a, text :: Data.Text.Internal.Text}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_60.
+      AST.Traversable1.Class.Traversable1 a_60
+    )
+
+instance AST.Unmarshal.SymbolMatching EscapeSequence where
+  matchedSymbols _ = [9]
+  showFailure _ node_61 =
+    "expected "
+      GHC.Base.<> ( "escape_sequence"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_61 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_61) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_62 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_63 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_64 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_65 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_62
+        c1_63 = TreeSitter.Node.nodeStartPoint node_61
+      TreeSitter.Node.TSPoint
+        r2_64
+        c2_65 = TreeSitter.Node.nodeEndPoint node_61
+
+deriving instance GHC.Classes.Eq a_66 => GHC.Classes.Eq (EscapeSequence a_66)
+
+deriving instance GHC.Classes.Ord a_67 => GHC.Classes.Ord (EscapeSequence a_67)
+
+deriving instance GHC.Show.Show a_68 => GHC.Show.Show (EscapeSequence a_68)
+
+instance AST.Unmarshal.Unmarshal EscapeSequence
+
+instance Data.Foldable.Foldable EscapeSequence where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor EscapeSequence where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable EscapeSequence where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data False a = False {ann :: a, text :: Data.Text.Internal.Text}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_69.
+      AST.Traversable1.Class.Traversable1 a_69
+    )
+
+instance AST.Unmarshal.SymbolMatching False where
+  matchedSymbols _ = [12]
+  showFailure _ node_70 =
+    "expected "
+      GHC.Base.<> ( "false"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_70 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_70) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_71 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_72 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_73 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_74 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_71
+        c1_72 = TreeSitter.Node.nodeStartPoint node_70
+      TreeSitter.Node.TSPoint
+        r2_73
+        c2_74 = TreeSitter.Node.nodeEndPoint node_70
+
+deriving instance GHC.Classes.Eq a_75 => GHC.Classes.Eq (False a_75)
+
+deriving instance GHC.Classes.Ord a_76 => GHC.Classes.Ord (False a_76)
+
+deriving instance GHC.Show.Show a_77 => GHC.Show.Show (False a_77)
+
+instance AST.Unmarshal.Unmarshal False
+
+instance Data.Foldable.Foldable False where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor False where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable False where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data Null a = Null {ann :: a, text :: Data.Text.Internal.Text}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_78.
+      AST.Traversable1.Class.Traversable1 a_78
+    )
+
+instance AST.Unmarshal.SymbolMatching Null where
+  matchedSymbols _ = [13]
+  showFailure _ node_79 =
+    "expected "
+      GHC.Base.<> ( "null"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_79 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_79) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_80 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_81 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_82 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_83 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_80
+        c1_81 = TreeSitter.Node.nodeStartPoint node_79
+      TreeSitter.Node.TSPoint
+        r2_82
+        c2_83 = TreeSitter.Node.nodeEndPoint node_79
+
+deriving instance GHC.Classes.Eq a_84 => GHC.Classes.Eq (Null a_84)
+
+deriving instance GHC.Classes.Ord a_85 => GHC.Classes.Ord (Null a_85)
+
+deriving instance GHC.Show.Show a_86 => GHC.Show.Show (Null a_86)
+
+instance AST.Unmarshal.Unmarshal Null
+
+instance Data.Foldable.Foldable Null where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Null where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Null where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data Number a = Number {ann :: a, text :: Data.Text.Internal.Text}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_87.
+      AST.Traversable1.Class.Traversable1 a_87
+    )
+
+instance AST.Unmarshal.SymbolMatching Number where
+  matchedSymbols _ = [10]
+  showFailure _ node_88 =
+    "expected "
+      GHC.Base.<> ( "number"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_88 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_88) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_89 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_90 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_91 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_92 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_89
+        c1_90 = TreeSitter.Node.nodeStartPoint node_88
+      TreeSitter.Node.TSPoint
+        r2_91
+        c2_92 = TreeSitter.Node.nodeEndPoint node_88
+
+deriving instance GHC.Classes.Eq a_93 => GHC.Classes.Eq (Number a_93)
+
+deriving instance GHC.Classes.Ord a_94 => GHC.Classes.Ord (Number a_94)
+
+deriving instance GHC.Show.Show a_95 => GHC.Show.Show (Number a_95)
+
+instance AST.Unmarshal.Unmarshal Number
+
+instance Data.Foldable.Foldable Number where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor Number where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable Number where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+data True a = True {ann :: a, text :: Data.Text.Internal.Text}
+  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
+  deriving anyclass
+    ( forall a_96.
+      AST.Traversable1.Class.Traversable1 a_96
+    )
+
+instance AST.Unmarshal.SymbolMatching True where
+  matchedSymbols _ = [11]
+  showFailure _ node_97 =
+    "expected "
+      GHC.Base.<> ( "true"
+                      GHC.Base.<> ( " but got "
+                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_97 GHC.Classes.== 65535
+                                                      then "ERROR"
+                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_97) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_98 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_99 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_100 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_101 GHC.Base.<> "]")))))))))
+                                                  )
+                                  )
+                  )
+    where
+      TreeSitter.Node.TSPoint
+        r1_98
+        c1_99 = TreeSitter.Node.nodeStartPoint node_97
+      TreeSitter.Node.TSPoint
+        r2_100
+        c2_101 = TreeSitter.Node.nodeEndPoint node_97
+
+deriving instance GHC.Classes.Eq a_102 => GHC.Classes.Eq (True a_102)
+
+deriving instance GHC.Classes.Ord a_103 => GHC.Classes.Ord (True a_103)
+
+deriving instance GHC.Show.Show a_104 => GHC.Show.Show (True a_104)
+
+instance AST.Unmarshal.Unmarshal True
+
+instance Data.Foldable.Foldable True where
+  foldMap = AST.Traversable1.Class.foldMapDefault1
+
+instance GHC.Base.Functor True where
+  fmap = AST.Traversable1.Class.fmapDefault1
+
+instance Data.Traversable.Traversable True where
+  traverse = AST.Traversable1.Class.traverseDefault1
+
+type AnonymousLBrace = AST.Token.Token "{" 1
+
+type AnonymousRBrace = AST.Token.Token "}" 3

-#ifdef NODE_TYPES_PATH
-astDeclarationsForLanguage JSON.tree_sitter_json NODE_TYPES_PATH
-#else
-runIO JSON.getNodeTypesPath >>= astDeclarationsForLanguage JSON.tree_sitter_json
-#endif
--- a/semantic-php/src/Language/PHP/AST.hs
+++ b/semantic-php/src/Language/PHP/AST.hs
--- a/semantic-python/src/Language/Python/AST.hs
+++ b/semantic-python/src/Language/Python/AST.hs
--- a/semantic-ruby/src/Language/Ruby/AST.hs
+++ b/semantic-ruby/src/Language/Ruby/AST.hs
--- a/semantic-tsx/src/Language/TSX/AST.hs
+++ b/semantic-tsx/src/Language/TSX/AST.hs
--- a/semantic-typescript/src/Language/TypeScript/AST.hs
+++ b/semantic-typescript/src/Language/TypeScript/AST.hs
--- a/stack-snapshot.yaml
+++ b/stack-snapshot.yaml
@ -3,12 +3,13 @@ packages:
  - github: antitypical/fused-syntax
    commit: "4a383d57c8fd7592f54a33f43eb9666314a6e80e"
    sha256: "aa345f8f04a12beaf8f07620467dee06370b72c763cf2d1c60556878b226fafc"
+  - Interpolation-0.3.0
  - fused-effects-1.1.0.0
  - fused-effects-exceptions-1.1.0.0
  - fused-effects-readline-0.1.0.0
-  - semilattices-0.0.0.4
  - haskeline-0.8.0.0
-  - tree-sitter-0.9.0.2
-  - unliftio-core-0.2.0.1
  - lingo-0.5.0.1
  - proto-lens-jsonpb-0.2.0.2
+  - semilattices-0.0.0.4
+  - tree-sitter-0.9.0.2
+  - unliftio-core-0.2.0.1
--- a/stackage_snapshot.json
+++ b/stackage_snapshot.json
@ -0,0 +1,198 @@
+{
+  "__GENERATED_FILE_DO_NOT_MODIFY_MANUALLY": -274529831,
+  "all-cabal-hashes": "https://raw.githubusercontent.com/commercialhaskell/all-cabal-hashes/a43da66660b6aa52432dc7fc34835ff9b347921b",
+  "resolved": {
+    "Cabal": {"dependencies":[],"location":{"type":"core"},"name":"Cabal","version":"3.2.0.0"},
+    "Glob": {"dependencies":["base","containers","directory","dlist","filepath","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/Glob-0.10.1/Glob-0.10.1.tar.gz"},"name":"Glob","pinned":{"url":["https://hackage.haskell.org/package/Glob-0.10.1/Glob-0.10.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/Glob-0.10.1.tar.gz"],"sha256":"cae4476d944947010705e0b00cf3e36c90ef407f968861f6771b931056b6d315","cabal-sha256":"424bf82768d0471562b34ffcac6b73e658f655aac957dfbcbb945603899a40fd"},"version":"0.10.1"},
+    "HUnit": {"dependencies":["base","call-stack","deepseq"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/HUnit-1.6.0.0/HUnit-1.6.0.0.tar.gz"},"name":"HUnit","pinned":{"url":["https://hackage.haskell.org/package/HUnit-1.6.0.0/HUnit-1.6.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/HUnit-1.6.0.0.tar.gz"],"sha256":"7448e6b966e98e84b7627deba23f71b508e9a61e7bc571d74304a25d30e6d0de","cabal-sha256":"8014b27c884becd8041214a1ab263fa92244ca62700a911aff604a1047869298"},"version":"1.6.0.0"},
+    "Only": {"dependencies":["base","deepseq"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/Only-0.1/Only-0.1.tar.gz"},"name":"Only","pinned":{"url":["https://hackage.haskell.org/package/Only-0.1/Only-0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/Only-0.1.tar.gz"],"sha256":"ab7aa193e8c257d3bda6b0b3c1cbcf74cdaa85ab08cb20c2dd62ba248c1ab265","cabal-sha256":"f92f5da97e647451f1ee7f5bf44914fb75062d08ccd3f36b2000d649c63d13aa"},"version":"0.1"},
+    "QuickCheck": {"dependencies":["base","containers","deepseq","random","splitmix","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/QuickCheck-2.13.2/QuickCheck-2.13.2.tar.gz"},"name":"QuickCheck","pinned":{"url":["https://hackage.haskell.org/package/QuickCheck-2.13.2/QuickCheck-2.13.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/QuickCheck-2.13.2.tar.gz"],"sha256":"7b560baa5853de777702dc23a6f2126ae4adbfdab163295bc56323a706914610","cabal-sha256":"636e7265bf75122e7e2f97627c47aad3b772ee3b35b134cafb6095116ce8d07a"},"version":"2.13.2"},
+    "StateVar": {"dependencies":["base","stm","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/StateVar-1.2/StateVar-1.2.tar.gz"},"name":"StateVar","pinned":{"url":["https://hackage.haskell.org/package/StateVar-1.2/StateVar-1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/StateVar-1.2.tar.gz"],"sha256":"afc036021fcd38f15fcc4af392a3e57017d5ddcc926e99391dbfc8c4e6375f8b","cabal-sha256":"9ab3e4a0e252d28bc2f799c83e0725c3e23e8d3b722cff0fdb9822e64b6c16ac"},"version":"1.2"},
+    "adjunctions": {"dependencies":["array","base","comonad","containers","contravariant","distributive","free","mtl","profunctors","semigroupoids","semigroups","tagged","transformers","transformers-compat","void"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/adjunctions-4.4/adjunctions-4.4.tar.gz"},"name":"adjunctions","pinned":{"url":["https://hackage.haskell.org/package/adjunctions-4.4/adjunctions-4.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/adjunctions-4.4.tar.gz"],"sha256":"507c2ef55337ae61c805f8cbc1213dfd7d2b85187342675d662254b8d8a16ae9","cabal-sha256":"2738dd5f5d5e93749adb14a05472e58a96a75d0f299e46371c6f46dc4e97daf9"},"version":"4.4"},
+    "aeson": {"dependencies":["attoparsec","base","base-compat-batteries","bytestring","containers","data-fix","deepseq","dlist","ghc-prim","hashable","primitive","scientific","strict","tagged","template-haskell","text","th-abstraction","these","time","time-compat","unordered-containers","uuid-types","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-1.5.3.0/aeson-1.5.3.0.tar.gz"},"name":"aeson","pinned":{"url":["https://hackage.haskell.org/package/aeson-1.5.3.0/aeson-1.5.3.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-1.5.3.0.tar.gz"],"sha256":"958ef96a31ad0807e307f92d61a2b51827f7b06afed52cf06f76c64c6aed986a","cabal-sha256":"05496710de6ae694e55dc77dbdaf7503f56c24e4aecc06045e42e75a02df8bc4"},"version":"1.5.3.0"},
+    "aeson-pretty": {"dependencies":["aeson","attoparsec","base","base-compat","bytestring","cmdargs","scientific","text","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/aeson-pretty-0.8.8/aeson-pretty-0.8.8.tar.gz"},"name":"aeson-pretty","pinned":{"url":["https://hackage.haskell.org/package/aeson-pretty-0.8.8/aeson-pretty-0.8.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/aeson-pretty-0.8.8.tar.gz"],"sha256":"81cea61cb6dcf32c3f0529ea5cfc98dbea3894152d7f2d9fe1cb051f927ec726","cabal-sha256":"9924a16d0c362ff59dd6d5b875749ff5d599d2688f89d080388a0014714441ef"},"version":"0.8.8"},
+    "algebraic-graphs": {"dependencies":["array","base","containers","deepseq","mtl","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/algebraic-graphs-0.5/algebraic-graphs-0.5.tar.gz"},"name":"algebraic-graphs","pinned":{"url":["https://hackage.haskell.org/package/algebraic-graphs-0.5/algebraic-graphs-0.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/algebraic-graphs-0.5.tar.gz"],"sha256":"89b9fecf8245476ec823355125fcb95decf41fd9784e807d7bd0d09f0a79c50b","cabal-sha256":"6eeec5ed1687ff7aa916e7bf9f02f51aaabde6f314dc0b7b1a84156974d7da73"},"version":"0.5"},
+    "ansi-terminal": {"dependencies":["base","colour"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-terminal-0.10.3/ansi-terminal-0.10.3.tar.gz"},"name":"ansi-terminal","pinned":{"url":["https://hackage.haskell.org/package/ansi-terminal-0.10.3/ansi-terminal-0.10.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-terminal-0.10.3.tar.gz"],"sha256":"fa2e2e32dfad29835aa7fd442bbe233e07d97e933223a001fe5efa562535b57c","cabal-sha256":"e2fbcef5f980dc234c7ad8e2fa433b0e8109132c9e643bc40ea5608cd5697797"},"version":"0.10.3"},
+    "ansi-wl-pprint": {"dependencies":["ansi-terminal","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz"},"name":"ansi-wl-pprint","pinned":{"url":["https://hackage.haskell.org/package/ansi-wl-pprint-0.6.9/ansi-wl-pprint-0.6.9.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ansi-wl-pprint-0.6.9.tar.gz"],"sha256":"a7b2e8e7cd3f02f2954e8b17dc60a0ccd889f49e2068ebb15abfa1d42f7a4eac","cabal-sha256":"20d30674f137d43aa0279c2c2cc5e45a5f1c3c57e301852494906158b6313bf7"},"version":"0.6.9"},
+    "array": {"dependencies":[],"location":{"type":"core"},"name":"array","version":"0.5.4.0"},
+    "assoc": {"dependencies":["base","bifunctors","tagged"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/assoc-1.0.2/assoc-1.0.2.tar.gz"},"name":"assoc","pinned":{"url":["https://hackage.haskell.org/package/assoc-1.0.2/assoc-1.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/assoc-1.0.2.tar.gz"],"sha256":"d8988dc6e8718c7a3456515b769c9336aeeec730cf86fc5175247969ff8f144f","cabal-sha256":"0be532f389dcaf4969c9e1066e1dca41b08ca4272d1b88450f552281d93106cb"},"version":"1.0.2"},
+    "async": {"dependencies":["base","hashable","stm"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/async-2.2.2/async-2.2.2.tar.gz"},"name":"async","pinned":{"url":["https://hackage.haskell.org/package/async-2.2.2/async-2.2.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/async-2.2.2.tar.gz"],"sha256":"4b4ab1ac82c45144d82c6daf6cb6ba45eab9957dad44787fa5e869e23d73bbff","cabal-sha256":"a178c166856da7ff22fe4500337b54812e94fd2059409452187d72e057ede9cd"},"version":"2.2.2"},
+    "attoparsec": {"dependencies":["array","base","bytestring","containers","deepseq","scientific","text","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/attoparsec-0.13.2.4/attoparsec-0.13.2.4.tar.gz"},"name":"attoparsec","pinned":{"url":["https://hackage.haskell.org/package/attoparsec-0.13.2.4/attoparsec-0.13.2.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/attoparsec-0.13.2.4.tar.gz"],"sha256":"ba66cd6de1749ec92568db1b9c905b43a849f0ad918d45d7b594407a02ebefb2","cabal-sha256":"e10c2a5070a344a0973e6f9486d148c690b6955468cfd61ee09a41b5adc48873"},"version":"0.13.2.4"},
+    "base": {"dependencies":[],"location":{"type":"core"},"name":"base","version":"4.14.0.0"},
+    "base-compat": {"dependencies":["base","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/base-compat-0.11.1/base-compat-0.11.1.tar.gz"},"name":"base-compat","pinned":{"url":["https://hackage.haskell.org/package/base-compat-0.11.1/base-compat-0.11.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/base-compat-0.11.1.tar.gz"],"sha256":"356f1542ec93e7192a9073d32a8ef1e48194275495dcec7fb0d241f4baaf6d36","cabal-sha256":"e49c1ce84f556621ef1142a169e4349049c516f5b3e3c3ec6830be503e7d4a93"},"version":"0.11.1"},
+    "base-compat-batteries": {"dependencies":["base","base-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/base-compat-batteries-0.11.1/base-compat-batteries-0.11.1.tar.gz"},"name":"base-compat-batteries","pinned":{"url":["https://hackage.haskell.org/package/base-compat-batteries-0.11.1/base-compat-batteries-0.11.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/base-compat-batteries-0.11.1.tar.gz"],"sha256":"caf66fed3c0a3b0437692cad18c93a7074e8524a86b8be1ce04d0a18cbf6aed8","cabal-sha256":"2763af26f6bd118dc278b805988acc792443f08bd77da03ac5c438c2b1ab4aab"},"version":"0.11.1"},
+    "base-orphans": {"dependencies":["base","ghc-prim"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/base-orphans-0.8.2/base-orphans-0.8.2.tar.gz"},"name":"base-orphans","pinned":{"url":["https://hackage.haskell.org/package/base-orphans-0.8.2/base-orphans-0.8.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/base-orphans-0.8.2.tar.gz"],"sha256":"2a8062385e5d5dee418428a22c72b9391557bc1fe2f93bd643f7754b36b9eb01","cabal-sha256":"40ef37ed043aac2cbb6c538fdebfc62e601ee65ee161e4a6327452133b574d7e"},"version":"0.8.2"},
+    "base-prelude": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/base-prelude-1.4/base-prelude-1.4.tar.gz"},"name":"base-prelude","pinned":{"url":["https://hackage.haskell.org/package/base-prelude-1.4/base-prelude-1.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/base-prelude-1.4.tar.gz"],"sha256":"3a7fc639f3e5293509369d0b217f9d9b9662373b151411841df1d099bcd8c55a","cabal-sha256":"feea99326853023fa9f908308383a7f9802e40f2d241b83dac57b266b202bda6"},"version":"1.4"},
+    "base64-bytestring": {"dependencies":["base","bytestring"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/base64-bytestring-1.1.0.0/base64-bytestring-1.1.0.0.tar.gz"},"name":"base64-bytestring","pinned":{"url":["https://hackage.haskell.org/package/base64-bytestring-1.1.0.0/base64-bytestring-1.1.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/base64-bytestring-1.1.0.0.tar.gz"],"sha256":"210d6c9042241ca52ee5d89cf221dbeb4d0e64b37391345369035ad2d9b4aca9","cabal-sha256":"190264fef9e65d9085f00ccda419137096d1dc94777c58272bc96821dc7f37c3"},"version":"1.1.0.0"},
+    "basement": {"dependencies":["base","ghc-prim"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/basement-0.0.11/basement-0.0.11.tar.gz"},"name":"basement","pinned":{"url":["https://hackage.haskell.org/package/basement-0.0.11/basement-0.0.11.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/basement-0.0.11.tar.gz"],"sha256":"67582b3475a5547925399f719df21f8bbbd0ca4d4db27795c22a474f8ee6346b","cabal-sha256":"af43e2e334e515b52ca309919b135c51b5e9411e6d4c68d0e8950d61eb5f25d1"},"version":"0.0.11"},
+    "bazel-runfiles": {"dependencies":["base","directory","filepath","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/bazel-runfiles-0.12/bazel-runfiles-0.12.tar.gz"},"name":"bazel-runfiles","pinned":{"url":["https://hackage.haskell.org/package/bazel-runfiles-0.12/bazel-runfiles-0.12.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/bazel-runfiles-0.12.tar.gz"],"sha256":"758abec4b6d9256dd17a3d9d3de1279e01f04a8662ef5fbd523d83e58b343cf5","cabal-sha256":"ea0e555a0c3fa67b0009a5f97d72cb1a0e9f03fe20ee2f6025b49a8117537298"},"version":"0.12"},
+    "bifunctors": {"dependencies":["base","base-orphans","comonad","containers","tagged","template-haskell","th-abstraction","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/bifunctors-5.5.7/bifunctors-5.5.7.tar.gz"},"name":"bifunctors","pinned":{"url":["https://hackage.haskell.org/package/bifunctors-5.5.7/bifunctors-5.5.7.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/bifunctors-5.5.7.tar.gz"],"sha256":"88b3a2d4504e1139a3aef7027913faa0870631477d0a2ebb6fa67d494cdb3532","cabal-sha256":"179970d8cabaa760df74d40e1f81b3633c78b569f2d058e24dac31b5a1865406"},"version":"5.5.7"},
+    "binary": {"dependencies":[],"location":{"type":"core"},"name":"binary","version":"0.8.8.0"},
+    "blaze-builder": {"dependencies":["base","bytestring","deepseq","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/blaze-builder-0.4.1.0/blaze-builder-0.4.1.0.tar.gz"},"name":"blaze-builder","pinned":{"url":["https://hackage.haskell.org/package/blaze-builder-0.4.1.0/blaze-builder-0.4.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/blaze-builder-0.4.1.0.tar.gz"],"sha256":"91fc8b966f3e9dc9461e1675c7566b881740f99abc906495491a3501630bc814","cabal-sha256":"fa992674ea28f6ea6569d93388d757aef928af1e2f0ce80a35c29fb782252a2d"},"version":"0.4.1.0"},
+    "blaze-html": {"dependencies":["base","blaze-builder","blaze-markup","bytestring","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/blaze-html-0.9.1.2/blaze-html-0.9.1.2.tar.gz"},"name":"blaze-html","pinned":{"url":["https://hackage.haskell.org/package/blaze-html-0.9.1.2/blaze-html-0.9.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/blaze-html-0.9.1.2.tar.gz"],"sha256":"60503f42546c6c1b954014d188ea137e43d74dcffd2bf6157c113fd91a0c394c","cabal-sha256":"5cd99ebdbf18e096f548f49ccabad0ec1338a1e7dd5165ab304b25e2efb1cb54"},"version":"0.9.1.2"},
+    "blaze-markup": {"dependencies":["base","blaze-builder","bytestring","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/blaze-markup-0.8.2.7/blaze-markup-0.8.2.7.tar.gz"},"name":"blaze-markup","pinned":{"url":["https://hackage.haskell.org/package/blaze-markup-0.8.2.7/blaze-markup-0.8.2.7.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/blaze-markup-0.8.2.7.tar.gz"],"sha256":"8b6489ed422d98e4372f41be1f40f772b8d4ed925f3203b36be4078d918c8ee4","cabal-sha256":"66a4a250ef6597e3d147256ee3f3123d3b4848f2d2494f676ec293267e286f63"},"version":"0.8.2.7"},
+    "bytestring": {"dependencies":[],"location":{"type":"core"},"name":"bytestring","version":"0.10.10.0"},
+    "cabal-doctest": {"dependencies":["Cabal","base","directory","filepath"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/cabal-doctest-1.0.8/cabal-doctest-1.0.8.tar.gz"},"name":"cabal-doctest","pinned":{"url":["https://hackage.haskell.org/package/cabal-doctest-1.0.8/cabal-doctest-1.0.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/cabal-doctest-1.0.8.tar.gz"],"sha256":"2026a6a87d410202ce091412ca6bc33c5aca787025326b4a3d13425a23392e0e","cabal-sha256":"8bd1d614fb65f0d52609da30bf8e5ec71a4b6adf8ff5610edb3cb4d114576117"},"version":"1.0.8"},
+    "call-stack": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/call-stack-0.2.0/call-stack-0.2.0.tar.gz"},"name":"call-stack","pinned":{"url":["https://hackage.haskell.org/package/call-stack-0.2.0/call-stack-0.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/call-stack-0.2.0.tar.gz"],"sha256":"95c693c93958758d714dee22edc56d4ebb2dcefa4412264e941e32ccd6e4e0c7","cabal-sha256":"5ce796b78d5f964468ec6fe0717b4e7d0430817f37370c47b3e6b38e345b6643"},"version":"0.2.0"},
+    "case-insensitive": {"dependencies":["base","bytestring","deepseq","hashable","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/case-insensitive-1.2.1.0/case-insensitive-1.2.1.0.tar.gz"},"name":"case-insensitive","pinned":{"url":["https://hackage.haskell.org/package/case-insensitive-1.2.1.0/case-insensitive-1.2.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/case-insensitive-1.2.1.0.tar.gz"],"sha256":"296dc17e0c5f3dfb3d82ced83e4c9c44c338ecde749b278b6eae512f1d04e406","cabal-sha256":"9dfd3171fc7698cf8d931727d3af3a7b389135b583e46b5adac1f9d2026fff61"},"version":"1.2.1.0"},
+    "charset": {"dependencies":["array","base","bytestring","containers","semigroups","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/charset-0.3.7.1/charset-0.3.7.1.tar.gz"},"name":"charset","pinned":{"url":["https://hackage.haskell.org/package/charset-0.3.7.1/charset-0.3.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/charset-0.3.7.1.tar.gz"],"sha256":"3d415d2883bd7bf0cc9f038e8323f19c71e07dd12a3c712f449ccb8b4daac0be","cabal-sha256":"feeb8e992c080205ad2f3b96f8fbe71419c92b9a3a95f00096faedf404efd6fc"},"version":"0.3.7.1"},
+    "clock": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/clock-0.8/clock-0.8.tar.gz"},"name":"clock","pinned":{"url":["https://hackage.haskell.org/package/clock-0.8/clock-0.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/clock-0.8.tar.gz"],"sha256":"08a35c5294009040f1e5eb721a21b60df7af6584092bb3d376ab1b2e57e26914","cabal-sha256":"b4ae207e2d3761450060a0d0feb873269233898039c76fceef9cc1a544067767"},"version":"0.8"},
+    "cmdargs": {"dependencies":["base","filepath","process","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/cmdargs-0.10.20/cmdargs-0.10.20.tar.gz"},"name":"cmdargs","pinned":{"url":["https://hackage.haskell.org/package/cmdargs-0.10.20/cmdargs-0.10.20.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/cmdargs-0.10.20.tar.gz"],"sha256":"0e269dc48c3d4c0447c96ffd772a6fe69dfa1260c323f4cd7bf171cbf2ab7331","cabal-sha256":"76cf238367e669833929dd264b4fc2278145ddf5b743624f2d5558cca16a08a9"},"version":"0.10.20"},
+    "code-page": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/code-page-0.2/code-page-0.2.tar.gz"},"name":"code-page","pinned":{"url":["https://hackage.haskell.org/package/code-page-0.2/code-page-0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/code-page-0.2.tar.gz"],"sha256":"bfe32a8c4be9cf0d5a088267bf3fdf4adda8ba3f109e85675c93e70d575e1844","cabal-sha256":"f701393cb1ff7b3ec7880816abc44387647811be31670e884e02d6a20c4aa508"},"version":"0.2"},
+    "colour": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/colour-2.3.5/colour-2.3.5.tar.gz"},"name":"colour","pinned":{"url":["https://hackage.haskell.org/package/colour-2.3.5/colour-2.3.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/colour-2.3.5.tar.gz"],"sha256":"3b8d471979617dce7c193523743c9782df63433d8e87e3ef6d97922e0da104e7","cabal-sha256":"b27db0a3ad40d70bdbd8510a104269f8707592e80757a1abc66a22ba25e5a42f"},"version":"2.3.5"},
+    "comonad": {"dependencies":["Cabal","base","cabal-doctest","containers","distributive","tagged","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/comonad-5.0.6/comonad-5.0.6.tar.gz"},"name":"comonad","pinned":{"url":["https://hackage.haskell.org/package/comonad-5.0.6/comonad-5.0.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/comonad-5.0.6.tar.gz"],"sha256":"77cfb016acd1747b892c31b82daf0de93f508ba775d62562d376b354adb88fae","cabal-sha256":"fdf1b529a79765a8549ac7e9d439b769cca852778742db8702a9d9b2dc27e4a4"},"version":"5.0.6"},
+    "concurrent-output": {"dependencies":["ansi-terminal","async","base","directory","exceptions","process","stm","terminal-size","text","transformers","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/concurrent-output-1.10.12/concurrent-output-1.10.12.tar.gz"},"name":"concurrent-output","pinned":{"url":["https://hackage.haskell.org/package/concurrent-output-1.10.12/concurrent-output-1.10.12.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/concurrent-output-1.10.12.tar.gz"],"sha256":"87f8a1cf54e6eaf146750fa6bf11aa2620da496073cb6c3dc8f697169eba3c20","cabal-sha256":"50e14131c486611055e2fa4f01a2ed03e63051e6d6707650f0a8f2f4ca618477"},"version":"1.10.12"},
+    "conduit": {"dependencies":["base","bytestring","directory","exceptions","filepath","mono-traversable","mtl","primitive","resourcet","text","transformers","unix","unliftio-core","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/conduit-1.3.2/conduit-1.3.2.tar.gz"},"name":"conduit","pinned":{"url":["https://hackage.haskell.org/package/conduit-1.3.2/conduit-1.3.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/conduit-1.3.2.tar.gz"],"sha256":"e3d97970f9bdead7e9e5a71b6f6c32d5d08c1551d5b36b28350b20e146f4ac6e","cabal-sha256":"f85b5dc1d7d30e9122ac15975e7f59fe846b42ef952e2beddd32520a753c2fc4"},"version":"1.3.2"},
+    "constraints": {"dependencies":["base","binary","deepseq","ghc-prim","hashable","mtl","semigroups","transformers","transformers-compat","type-equality"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/constraints-0.12/constraints-0.12.tar.gz"},"name":"constraints","pinned":{"url":["https://hackage.haskell.org/package/constraints-0.12/constraints-0.12.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/constraints-0.12.tar.gz"],"sha256":"f26b531a15f013f15b4b5df46c4f89b13927253a4195494c50320adf05760223","cabal-sha256":"71c7999d7fa01d8941f08d37d4c107c6b1bcbd0306e234157557b9b096b7f1be"},"version":"0.12"},
+    "containers": {"dependencies":[],"location":{"type":"core"},"name":"containers","version":"0.6.2.1"},
+    "contravariant": {"dependencies":["StateVar","base","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/contravariant-1.5.2/contravariant-1.5.2.tar.gz"},"name":"contravariant","pinned":{"url":["https://hackage.haskell.org/package/contravariant-1.5.2/contravariant-1.5.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/contravariant-1.5.2.tar.gz"],"sha256":"c4262c24e3dcc2ba8ca221ed52a6390818a715301e4f13135d8d732e0c7dc60c","cabal-sha256":"853259271870000c007a281f0bf0bf6e1aaa97c5fd5cd5734d7b0d79b9de2af5"},"version":"1.5.2"},
+    "data-default-class": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/data-default-class-0.1.2.0/data-default-class-0.1.2.0.tar.gz"},"name":"data-default-class","pinned":{"url":["https://hackage.haskell.org/package/data-default-class-0.1.2.0/data-default-class-0.1.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/data-default-class-0.1.2.0.tar.gz"],"sha256":"4f01b423f000c3e069aaf52a348564a6536797f31498bb85c3db4bd2d0973e56","cabal-sha256":"63e62120b7efd733a5a17cf59ceb43268e9a929c748127172d7d42f4a336e327"},"version":"0.1.2.0"},
+    "data-fix": {"dependencies":["base","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/data-fix-0.3.0/data-fix-0.3.0.tar.gz"},"name":"data-fix","pinned":{"url":["https://hackage.haskell.org/package/data-fix-0.3.0/data-fix-0.3.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/data-fix-0.3.0.tar.gz"],"sha256":"9e59b3ed694b5139316093b3767842e60ad4821858459e7cd763e5773dfa99a0","cabal-sha256":"058a266d1e658500e0ffb8babe68195b0ce06a081dcfc3814afc784b083fd9a5"},"version":"0.3.0"},
+    "deepseq": {"dependencies":[],"location":{"type":"core"},"name":"deepseq","version":"1.4.4.0"},
+    "directory": {"dependencies":[],"location":{"type":"core"},"name":"directory","version":"1.3.6.0"},
+    "directory-tree": {"dependencies":["base","directory","filepath"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/directory-tree-0.12.1/directory-tree-0.12.1.tar.gz"},"name":"directory-tree","pinned":{"url":["https://hackage.haskell.org/package/directory-tree-0.12.1/directory-tree-0.12.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/directory-tree-0.12.1.tar.gz"],"sha256":"e2084495b3a226cf54d949635c86fc14e89daa09d86cce39e3c3cf898ae6e517","cabal-sha256":"6f24ee1eca965a199a96f853582e61a338f1a529c87bc02c7f1451e2f2ed03fe"},"version":"0.12.1"},
+    "distributive": {"dependencies":["Cabal","base","base-orphans","cabal-doctest","tagged","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/distributive-0.6.2/distributive-0.6.2.tar.gz"},"name":"distributive","pinned":{"url":["https://hackage.haskell.org/package/distributive-0.6.2/distributive-0.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/distributive-0.6.2.tar.gz"],"sha256":"824ee271ded433ce6c61fe890c784642b7e20ffa4082fca609da54e7dcfc23c9","cabal-sha256":"2ace9babcdbd1c2db28638c200405fb85e3660fe19ceae4f03082590adc2c487"},"version":"0.6.2"},
+    "dlist": {"dependencies":["base","deepseq"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/dlist-0.8.0.8/dlist-0.8.0.8.tar.gz"},"name":"dlist","pinned":{"url":["https://hackage.haskell.org/package/dlist-0.8.0.8/dlist-0.8.0.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/dlist-0.8.0.8.tar.gz"],"sha256":"7129cf18068d3384e305708a10426ab8f573bee1030b023a114f45f1d0ec496d","cabal-sha256":"90ca348bffdc62d7070bcf0e97c728f8d01b24fbc7ea08d2909157d0da76534c"},"version":"0.8.0.8"},
+    "doctest": {"dependencies":["base","base-compat","code-page","deepseq","directory","filepath","ghc","ghc-paths","process","syb","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/doctest-0.16.3/doctest-0.16.3.tar.gz"},"name":"doctest","pinned":{"url":["https://hackage.haskell.org/package/doctest-0.16.3/doctest-0.16.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/doctest-0.16.3.tar.gz"],"sha256":"cfe9629f9c4d0aa24a11b5c4dd216fb5b9ebce7b3f6a8a7e58716280943a34f8","cabal-sha256":"a4d5e71440a95034ad206eb9f3a27b2f5253896a15124574a00fea98c5b2f5c1"},"version":"0.16.3"},
+    "erf": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/erf-2.0.0.0/erf-2.0.0.0.tar.gz"},"name":"erf","pinned":{"url":["https://hackage.haskell.org/package/erf-2.0.0.0/erf-2.0.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/erf-2.0.0.0.tar.gz"],"sha256":"24f0b79c7e1d25cb2cd44c2258d7a464bf6db8079775b50b60b54a254616b337","cabal-sha256":"11c5d3747d17b589009cbe9656ca792e4b5b2560d4aa44f6f1e80044794b1a8b"},"version":"2.0.0.0"},
+    "exceptions": {"dependencies":["base","mtl","stm","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/exceptions-0.10.4/exceptions-0.10.4.tar.gz"},"name":"exceptions","pinned":{"url":["https://hackage.haskell.org/package/exceptions-0.10.4/exceptions-0.10.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/exceptions-0.10.4.tar.gz"],"sha256":"4d0bfb4355cffcd67d300811df9d5fe44ea3594ed63750795bfc1f797abd84cf","cabal-sha256":"1729ef26a611ae78aa58cdd34192aff710cbaa6d631dd042ddfb63556d00b52c"},"version":"0.10.4"},
+    "fail": {"dependencies":[],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fail-4.9.0.0/fail-4.9.0.0.tar.gz"},"name":"fail","pinned":{"url":["https://hackage.haskell.org/package/fail-4.9.0.0/fail-4.9.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fail-4.9.0.0.tar.gz"],"sha256":"6d5cdb1a5c539425a9665f740e364722e1d9d6ae37fbc55f30fe3dbbbb91d4a2","cabal-sha256":"35d1ee29364447c1b7d616bb1ee31f162b73e85fea91d7ca6441cf901398f572"},"version":"4.9.0.0"},
+    "filepath": {"dependencies":[],"location":{"type":"core"},"name":"filepath","version":"1.4.2.1"},
+    "fingertree": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fingertree-0.1.4.2/fingertree-0.1.4.2.tar.gz"},"name":"fingertree","pinned":{"url":["https://hackage.haskell.org/package/fingertree-0.1.4.2/fingertree-0.1.4.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fingertree-0.1.4.2.tar.gz"],"sha256":"95a948341570bad5a9b2468c388c0eb2c20c57e10dd8fbfc994c7b8764b36a7f","cabal-sha256":"b368fda61b14073bd798f45c8fa91e1c5331628193a8b88d93fb5a4341849c64"},"version":"0.1.4.2"},
+    "foldl": {"dependencies":["base","bytestring","comonad","containers","contravariant","hashable","mwc-random","primitive","profunctors","semigroupoids","text","transformers","unordered-containers","vector","vector-builder"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/foldl-1.4.8/foldl-1.4.8.tar.gz"},"name":"foldl","pinned":{"url":["https://hackage.haskell.org/package/foldl-1.4.8/foldl-1.4.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/foldl-1.4.8.tar.gz"],"sha256":"ed1a59f210d4e732dc5b0a0dbe7e60348ea87e74df196f75a6bc236c936499ca","cabal-sha256":"2f6611b3a2ce92d2279c93a60cd8ef3bed98c17bd814e5b943ede53578005f26"},"version":"1.4.8"},
+    "free": {"dependencies":["base","comonad","containers","distributive","exceptions","mtl","profunctors","semigroupoids","template-haskell","transformers","transformers-base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/free-5.1.3/free-5.1.3.tar.gz"},"name":"free","pinned":{"url":["https://hackage.haskell.org/package/free-5.1.3/free-5.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/free-5.1.3.tar.gz"],"sha256":"2c70d66e3a1ad52ce4b22d5510ffc6d7b3db950bd7f43bc61801cfe7b24c2e2d","cabal-sha256":"604c27b6ba0a560c8a1377ad76e5bbb8528e924d6b0590215d815faddbec0b70"},"version":"5.1.3"},
+    "fused-effects": {"dependencies":["base","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fused-effects-1.1.0.0/fused-effects-1.1.0.0.tar.gz"},"name":"fused-effects","pinned":{"url":["https://hackage.haskell.org/package/fused-effects-1.1.0.0/fused-effects-1.1.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fused-effects-1.1.0.0.tar.gz"],"sha256":"9de604f9bbae418ff81767c173933945d1dd61c2889c124775dcbfa90780415b","cabal-sha256":"29d03c73b585920c0999a18b73c9a0bf9e61e1fa58c5c2bed3f89423c8078f4a"},"version":"1.1.0.0"},
+    "fused-effects-exceptions": {"dependencies":["base","fused-effects","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fused-effects-exceptions-1.1.0.0/fused-effects-exceptions-1.1.0.0.tar.gz"},"name":"fused-effects-exceptions","pinned":{"url":["https://hackage.haskell.org/package/fused-effects-exceptions-1.1.0.0/fused-effects-exceptions-1.1.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fused-effects-exceptions-1.1.0.0.tar.gz"],"sha256":"51d67c952b4d0799fe99f6b82d6e534b9fd26447ea321c7710bfdbc9ca76bd64","cabal-sha256":"c1880f55360deaa4441bda9ff09a4ce6dbd63df8c175c7ada16a5d67a3717bee"},"version":"1.1.0.0"},
+    "fused-effects-readline": {"dependencies":["base","directory","exceptions","filepath","fused-effects","haskeline","prettyprinter","prettyprinter-ansi-terminal","terminal-size","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/fused-effects-readline-0.1.0.0/fused-effects-readline-0.1.0.0.tar.gz"},"name":"fused-effects-readline","pinned":{"url":["https://hackage.haskell.org/package/fused-effects-readline-0.1.0.0/fused-effects-readline-0.1.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/fused-effects-readline-0.1.0.0.tar.gz"],"sha256":"5514b7022231fc2e040bbdc7550cb080a03ebdf567e16719f0443f20572b3ae9","cabal-sha256":"668b390d418baf0e4f611a021e92a12b9bdebbab2e6a75a8b6c7434cfd019856"},"version":"0.1.0.0"},
+    "fused-syntax": {"dependencies":["base","transformers"],"location":{"type":"archive","url":"https://github.com/antitypical/fused-syntax/archive/4a383d57c8fd7592f54a33f43eb9666314a6e80e.tar.gz"},"name":"fused-syntax","pinned":{"sha256":"aa345f8f04a12beaf8f07620467dee06370b72c763cf2d1c60556878b226fafc","strip-prefix":"fused-syntax-4a383d57c8fd7592f54a33f43eb9666314a6e80e"},"version":"0.0.0.0"},
+    "gauge": {"dependencies":["base","basement","deepseq","directory","process","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/gauge-0.2.5/gauge-0.2.5.tar.gz"},"name":"gauge","pinned":{"url":["https://hackage.haskell.org/package/gauge-0.2.5/gauge-0.2.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/gauge-0.2.5.tar.gz"],"sha256":"d520fd677890c1bf2b1601331d003f976d85420811c3db4a72cff4d3bdb7f5a7","cabal-sha256":"8d60450bdec985c146d5632d4f5a8d60cec27d71ba6787ed1ee64d945d4c7c33"},"version":"0.2.5"},
+    "generic-lens": {"dependencies":["base","generic-lens-core","profunctors","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generic-lens-2.0.0.0/generic-lens-2.0.0.0.tar.gz"},"name":"generic-lens","pinned":{"url":["https://hackage.haskell.org/package/generic-lens-2.0.0.0/generic-lens-2.0.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generic-lens-2.0.0.0.tar.gz"],"sha256":"b816e55dbdf96ed04b7ad01193fce3dec36397aff3036e34a89ee2884b02093a","cabal-sha256":"7409fa0ce540d0bd41acf596edd1c5d0c0ab1cd1294d514cf19c5c24e8ef2550"},"version":"2.0.0.0"},
+    "generic-lens-core": {"dependencies":["base","indexed-profunctors","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generic-lens-core-2.0.0.0/generic-lens-core-2.0.0.0.tar.gz"},"name":"generic-lens-core","pinned":{"url":["https://hackage.haskell.org/package/generic-lens-core-2.0.0.0/generic-lens-core-2.0.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generic-lens-core-2.0.0.0.tar.gz"],"sha256":"51628204350380be7d46a53a9e3e47d9d6f5c4797cf0215b9d93a2f90794ee40","cabal-sha256":"40b063c4a1399b3cdb19f2df1fae5a1a82f3313015c7c3e47fc23b8ef1b3e443"},"version":"2.0.0.0"},
+    "generic-monoid": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/generic-monoid-0.1.0.1/generic-monoid-0.1.0.1.tar.gz"},"name":"generic-monoid","pinned":{"url":["https://hackage.haskell.org/package/generic-monoid-0.1.0.1/generic-monoid-0.1.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/generic-monoid-0.1.0.1.tar.gz"],"sha256":"cfd072ad70af41c1b94ac24e42e2635f37ed2a54e8f4be871be78b18b66b2adf","cabal-sha256":"d2ddcb359d05156e5654a309759dbf1de887e591d9afdabfb343b2e66403890c"},"version":"0.1.0.1"},
+    "ghc": {"dependencies":[],"location":{"type":"core"},"name":"ghc","version":"8.10.1"},
+    "ghc-paths": {"dependencies":["Cabal","base","directory"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/ghc-paths-0.1.0.12/ghc-paths-0.1.0.12.tar.gz"},"name":"ghc-paths","pinned":{"url":["https://hackage.haskell.org/package/ghc-paths-0.1.0.12/ghc-paths-0.1.0.12.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/ghc-paths-0.1.0.12.tar.gz"],"sha256":"6ecbe676d073cb07989c61ce4c5709c4e67cbefdd2d55a4095f9388b6fe2c484","cabal-sha256":"85370fdc615d4be5e09d9269eebb9a3fc7017c40b1a9e0050b121d75908564bd"},"version":"0.1.0.12"},
+    "ghc-prim": {"dependencies":[],"location":{"type":"core"},"name":"ghc-prim","version":"0.6.1"},
+    "happy": {"dependencies":["array","base","containers","mtl"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/happy-1.19.12/happy-1.19.12.tar.gz"},"name":"happy","pinned":{"url":["https://hackage.haskell.org/package/happy-1.19.12/happy-1.19.12.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/happy-1.19.12.tar.gz"],"sha256":"fb9a23e41401711a3b288f93cf0a66db9f97da1ce32ec4fffea4b78a0daeb40f","cabal-sha256":"acc67bfbf3af87892766781dd064c9447181ea81269a7a1e5fc9ace4a8fa4768"},"version":"1.19.12"},
+    "hashable": {"dependencies":["base","bytestring","deepseq","ghc-prim","integer-gmp","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hashable-1.3.0.0/hashable-1.3.0.0.tar.gz"},"name":"hashable","pinned":{"url":["https://hackage.haskell.org/package/hashable-1.3.0.0/hashable-1.3.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hashable-1.3.0.0.tar.gz"],"sha256":"822e5413fbccca6ae884d3aba4066422c8b5d58d23d18b9ecb5c03273bb19ab4","cabal-sha256":"4c70f1407881059e93550d3742191254296b2737b793a742bd901348fb3e1fb1"},"version":"1.3.0.0"},
+    "haskeline": {"dependencies":["base","bytestring","containers","directory","exceptions","filepath","process","stm","terminfo","transformers","unix"],"location":{"type":"core"},"name":"haskeline","version":"0.8.0.0"},
+    "haskell-lexer": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/haskell-lexer-1.1/haskell-lexer-1.1.tar.gz"},"name":"haskell-lexer","pinned":{"url":["https://hackage.haskell.org/package/haskell-lexer-1.1/haskell-lexer-1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/haskell-lexer-1.1.tar.gz"],"sha256":"313a15cc643322c8badd148867ce25ca1ffc191df9e7eeec5b10bc08c4b563d5","cabal-sha256":"9e0a7633f6bdb59004c6f3144ebfad1edb9e440fc6a94215c3a1d11bcd8656ef"},"version":"1.1"},
+    "hedgehog": {"dependencies":["ansi-terminal","async","base","bytestring","concurrent-output","containers","deepseq","directory","erf","exceptions","fail","lifted-async","mmorph","monad-control","mtl","pretty-show","primitive","random","resourcet","semigroups","stm","template-haskell","text","time","transformers","transformers-base","wl-pprint-annotated"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hedgehog-1.0.3/hedgehog-1.0.3.tar.gz"},"name":"hedgehog","pinned":{"url":["https://hackage.haskell.org/package/hedgehog-1.0.3/hedgehog-1.0.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hedgehog-1.0.3.tar.gz"],"sha256":"35f9e96578c09734243a4e423d367083e08937f863101b3f6ef48744c8299b82","cabal-sha256":"dd9a25bf904fe444d5de471d0933261ef2c9a1110330460e037e0fef86fac89e"},"version":"1.0.3"},
+    "hostname": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hostname-1.0/hostname-1.0.tar.gz"},"name":"hostname","pinned":{"url":["https://hackage.haskell.org/package/hostname-1.0/hostname-1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hostname-1.0.tar.gz"],"sha256":"9b43dab1b6da521f35685b20555da00738c8e136eb972458c786242406a9cf5c","cabal-sha256":"8203b6ecd14ca1ef12f73a471b0a6a4be3ad4568d8b84f2bc4bc9e0abb8c4153"},"version":"1.0"},
+    "hscolour": {"dependencies":["base","containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hscolour-1.24.4/hscolour-1.24.4.tar.gz"},"name":"hscolour","pinned":{"url":["https://hackage.haskell.org/package/hscolour-1.24.4/hscolour-1.24.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hscolour-1.24.4.tar.gz"],"sha256":"243332b082294117f37b2c2c68079fa61af68b36223b3fc07594f245e0e5321d","cabal-sha256":"3a329fa0ea9138f651088f1fa25522aabeab0eb591932d3fd56c66736bbe78be"},"version":"1.24.4"},
+    "hspec": {"dependencies":["QuickCheck","base","hspec-core","hspec-discover","hspec-expectations"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-2.7.2/hspec-2.7.2.tar.gz"},"name":"hspec","pinned":{"url":["https://hackage.haskell.org/package/hspec-2.7.2/hspec-2.7.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-2.7.2.tar.gz"],"sha256":"a97ebd050d5667d78dbe83348b8b1b4f579c2ea71ccfcc3eea9e9fbe0b5a697d","cabal-sha256":"4758e1af9cf534429cde9f5f6495e5922ad1c05ca5b8344a0a459d320cd1cd28"},"version":"2.7.2"},
+    "hspec-core": {"dependencies":["HUnit","QuickCheck","ansi-terminal","array","base","call-stack","clock","deepseq","directory","filepath","hspec-expectations","quickcheck-io","random","setenv","stm","tf-random","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-core-2.7.2/hspec-core-2.7.2.tar.gz"},"name":"hspec-core","pinned":{"url":["https://hackage.haskell.org/package/hspec-core-2.7.2/hspec-core-2.7.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-core-2.7.2.tar.gz"],"sha256":"d33afadc5602545c832bf5a7d73815ee9cc6c50e4b17847b35d7e5f11eeffa6f","cabal-sha256":"4302aeeaafd24309b8c32dace6b6c1a32124a721c0be10ab0f23ec40db38333e"},"version":"2.7.2"},
+    "hspec-discover": {"dependencies":["base","directory","filepath"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-discover-2.7.2/hspec-discover-2.7.2.tar.gz"},"name":"hspec-discover","pinned":{"url":["https://hackage.haskell.org/package/hspec-discover-2.7.2/hspec-discover-2.7.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-discover-2.7.2.tar.gz"],"sha256":"888604783e48c6a5f49f3de5eb8c4f83841119b13d99144283f9e56a7fdb7458","cabal-sha256":"9b21f4211c0553f2f50e50b2231dbdc89e37acb0fbb60b91b890cc2ec81e7bf7"},"version":"2.7.2"},
+    "hspec-expectations": {"dependencies":["HUnit","base","call-stack"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/hspec-expectations-0.8.2/hspec-expectations-0.8.2.tar.gz"},"name":"hspec-expectations","pinned":{"url":["https://hackage.haskell.org/package/hspec-expectations-0.8.2/hspec-expectations-0.8.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/hspec-expectations-0.8.2.tar.gz"],"sha256":"819607ea1faf35ce5be34be61c6f50f3389ea43892d56fb28c57a9f5d54fb4ef","cabal-sha256":"e2db24881baadc2d9d23b03cb629e80dcbda89a6b04ace9adb5f4d02ef8b31aa"},"version":"0.8.2"},
+    "indexed-profunctors": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/indexed-profunctors-0.1/indexed-profunctors-0.1.tar.gz"},"name":"indexed-profunctors","pinned":{"url":["https://hackage.haskell.org/package/indexed-profunctors-0.1/indexed-profunctors-0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/indexed-profunctors-0.1.tar.gz"],"sha256":"31dfb4319dff84199344000b1efad75158eeac17ddcbb27f91735e958591bb65","cabal-sha256":"ddf618d0d4c58319c1e735e746bc69a1021f13b6f475dc9614b80af03432e6d4"},"version":"0.1"},
+    "integer-gmp": {"dependencies":[],"location":{"type":"core"},"name":"integer-gmp","version":"1.0.3.0"},
+    "integer-logarithms": {"dependencies":["array","base","ghc-prim","integer-gmp"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/integer-logarithms-1.0.3/integer-logarithms-1.0.3.tar.gz"},"name":"integer-logarithms","pinned":{"url":["https://hackage.haskell.org/package/integer-logarithms-1.0.3/integer-logarithms-1.0.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/integer-logarithms-1.0.3.tar.gz"],"sha256":"5ae262018698af35bb74916fad170d96d3eb44669c72ed36db9a19a3392cec16","cabal-sha256":"63d42595ec92b71ac98a07b984b0a2eb3d4956f4ad2d856c3bf6fc3dc218d228"},"version":"1.0.3"},
+    "invariant": {"dependencies":["StateVar","array","base","bifunctors","comonad","containers","contravariant","ghc-prim","profunctors","stm","tagged","template-haskell","th-abstraction","transformers","transformers-compat","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/invariant-0.5.3/invariant-0.5.3.tar.gz"},"name":"invariant","pinned":{"url":["https://hackage.haskell.org/package/invariant-0.5.3/invariant-0.5.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/invariant-0.5.3.tar.gz"],"sha256":"d73e5def38da9fdd85def073857aa5f4b1d3b0c2df05c43d58a677cca02d440c","cabal-sha256":"e430340b5f4248159f9fd217c506946887b4ff8f2c7a3819c3d4f06bcb195e6a"},"version":"0.5.3"},
+    "kan-extensions": {"dependencies":["adjunctions","array","base","comonad","containers","contravariant","distributive","free","invariant","mtl","profunctors","semigroupoids","tagged","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/kan-extensions-5.2/kan-extensions-5.2.tar.gz"},"name":"kan-extensions","pinned":{"url":["https://hackage.haskell.org/package/kan-extensions-5.2/kan-extensions-5.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/kan-extensions-5.2.tar.gz"],"sha256":"6b727e586f744b96529415eeabc745dfe05feea61f6b6bad90c224c879f4dbd3","cabal-sha256":"2407501562039dad6a3d19aacd0bbcca07aa28497cbd1cdaaf5aabc30146899d"},"version":"5.2"},
+    "lens": {"dependencies":["Cabal","array","base","base-orphans","bifunctors","bytestring","cabal-doctest","call-stack","comonad","containers","contravariant","distributive","exceptions","filepath","free","ghc-prim","hashable","kan-extensions","mtl","parallel","profunctors","reflection","semigroupoids","tagged","template-haskell","text","th-abstraction","transformers","transformers-compat","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/lens-4.19.2/lens-4.19.2.tar.gz"},"name":"lens","pinned":{"url":["https://hackage.haskell.org/package/lens-4.19.2/lens-4.19.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/lens-4.19.2.tar.gz"],"sha256":"52f858ae3971a5104cdba5e81a27d154fda11fe65a54a4ac328c85904bdec23b","cabal-sha256":"f0570ca0e4624d9daa57256f00f514e87be155401583fa1665faba47376c63a7"},"version":"4.19.2"},
+    "lens-family": {"dependencies":["base","containers","lens-family-core","mtl","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/lens-family-2.0.0/lens-family-2.0.0.tar.gz"},"name":"lens-family","pinned":{"url":["https://hackage.haskell.org/package/lens-family-2.0.0/lens-family-2.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/lens-family-2.0.0.tar.gz"],"sha256":"6793f2a5c5030f02258532043d57eac42318cd7f9cef47f6720a7b99276f03db","cabal-sha256":"b915001e862bda2ad5e0e5c17ba59f4483d02a02cbac020fd35f58e6736bc9a7"},"version":"2.0.0"},
+    "lens-family-core": {"dependencies":["base","containers","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/lens-family-core-2.0.0/lens-family-core-2.0.0.tar.gz"},"name":"lens-family-core","pinned":{"url":["https://hackage.haskell.org/package/lens-family-core-2.0.0/lens-family-core-2.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/lens-family-core-2.0.0.tar.gz"],"sha256":"19b4fcd3bd37dd0056c112a9b16cf405644fabd6652013c61a5078380ed2265a","cabal-sha256":"645b0553e16a3857b08fa44f11f0664296e1db5d6494a83634711c7f4f1707a7"},"version":"2.0.0"},
+    "libyaml": {"dependencies":["base","bytestring","conduit","resourcet"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/libyaml-0.1.2/libyaml-0.1.2.tar.gz"},"name":"libyaml","pinned":{"url":["https://hackage.haskell.org/package/libyaml-0.1.2/libyaml-0.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/libyaml-0.1.2.tar.gz"],"sha256":"8f42d66f199fcaee255326f8f770d88b0670df56b5eb78002d6058f3a45e97b5","cabal-sha256":"7f14f69ceb14659699974e8e47e1ea6f226ea21ff42a802db03e721c319d201d"},"version":"0.1.2"},
+    "lifted-async": {"dependencies":["async","base","constraints","lifted-base","monad-control","transformers-base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/lifted-async-0.10.1.2/lifted-async-0.10.1.2.tar.gz"},"name":"lifted-async","pinned":{"url":["https://hackage.haskell.org/package/lifted-async-0.10.1.2/lifted-async-0.10.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/lifted-async-0.10.1.2.tar.gz"],"sha256":"bd24cb197953701507680893b84df505eb58d1c31e1d45f9a0edae43cd965713","cabal-sha256":"525946f7f54feca4cf5207aaf56452be08a2b0d12e04e5fb5770a98b5a56b9fc"},"version":"0.10.1.2"},
+    "lifted-base": {"dependencies":["base","monad-control","transformers-base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/lifted-base-0.2.3.12/lifted-base-0.2.3.12.tar.gz"},"name":"lifted-base","pinned":{"url":["https://hackage.haskell.org/package/lifted-base-0.2.3.12/lifted-base-0.2.3.12.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/lifted-base-0.2.3.12.tar.gz"],"sha256":"c134a95f56750aae806e38957bb03c59627cda16034af9e00a02b699474317c5","cabal-sha256":"e94ad0692c9c5d85c373e508f23654f2da8ac8c3e475c2b65ffbc04fb165ad69"},"version":"0.2.3.12"},
+    "lingo": {"dependencies":["base","bytestring","containers","directory","filepath","raw-strings-qq","text","yaml"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/lingo-0.5.0.1/lingo-0.5.0.1.tar.gz"},"name":"lingo","pinned":{"url":["https://hackage.haskell.org/package/lingo-0.5.0.1/lingo-0.5.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/lingo-0.5.0.1.tar.gz"],"sha256":"1a354e753c18ee5c6fceed0acfd0b5b80c5bcb4536df32ba5608272bb279a740","cabal-sha256":"e57deaf3353725bbb84d5e7426d9b7039f191e46779c590f236851c75e94751a"},"version":"0.5.0.1"},
+    "logict": {"dependencies":["base","mtl"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/logict-0.7.0.2/logict-0.7.0.2.tar.gz"},"name":"logict","pinned":{"url":["https://hackage.haskell.org/package/logict-0.7.0.2/logict-0.7.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/logict-0.7.0.2.tar.gz"],"sha256":"ccc198a05563a4d8fc145ecde8b43a83599b3bcb032d2614a8e852f0ba6ecff5","cabal-sha256":"7edbddead124fb266f62f208ed56c4dbfdd8f20ce15be73b4fe1d2fc758f6e9d"},"version":"0.7.0.2"},
+    "math-functions": {"dependencies":["base","data-default-class","deepseq","primitive","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/math-functions-0.3.4.1/math-functions-0.3.4.1.tar.gz"},"name":"math-functions","pinned":{"url":["https://hackage.haskell.org/package/math-functions-0.3.4.1/math-functions-0.3.4.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/math-functions-0.3.4.1.tar.gz"],"sha256":"e20a0afc03d3431610d5f4e57ec3a71822bf6cb1c598e8f2ad1b336533e4a48f","cabal-sha256":"a6e458d2a78f03e83440062e8803c0baf7c1474dc2687489661690f4c6d46416"},"version":"0.3.4.1"},
+    "megaparsec": {"dependencies":["base","bytestring","case-insensitive","containers","deepseq","mtl","parser-combinators","scientific","text","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/megaparsec-8.0.0/megaparsec-8.0.0.tar.gz"},"name":"megaparsec","pinned":{"url":["https://hackage.haskell.org/package/megaparsec-8.0.0/megaparsec-8.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/megaparsec-8.0.0.tar.gz"],"sha256":"b5d7c64646016d12f540a6948396a86e0cd39865569d68fe2018fe9e3fce6318","cabal-sha256":"362f85e243ecbcb550e1de6e5c74ba5a50c09edaa1208c99bc5b9fd242227fc6"},"version":"8.0.0"},
+    "mmorph": {"dependencies":["base","mtl","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/mmorph-1.1.3/mmorph-1.1.3.tar.gz"},"name":"mmorph","pinned":{"url":["https://hackage.haskell.org/package/mmorph-1.1.3/mmorph-1.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/mmorph-1.1.3.tar.gz"],"sha256":"7923f7ad6260a05aaa8175b9f2a250f5bb63187427681171bd36d29a6cf2da65","cabal-sha256":"abfc95648fef0008f984b94137ce8e1635fb071c7bfaaa7393ba175a1b3bb12f"},"version":"1.1.3"},
+    "monad-control": {"dependencies":["base","stm","transformers","transformers-base","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/monad-control-1.0.2.3/monad-control-1.0.2.3.tar.gz"},"name":"monad-control","pinned":{"url":["https://hackage.haskell.org/package/monad-control-1.0.2.3/monad-control-1.0.2.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/monad-control-1.0.2.3.tar.gz"],"sha256":"6c1034189d237ae45368c70f0e68f714dd3beda715dd265b6c8a99fcc64022b1","cabal-sha256":"a3ae888d2fed2e2a0ca33ae11e2480219e07312bccf1a02ffe2ba2e3ec5913ee"},"version":"1.0.2.3"},
+    "mono-traversable": {"dependencies":["base","bytestring","containers","hashable","split","text","transformers","unordered-containers","vector","vector-algorithms"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/mono-traversable-1.0.15.1/mono-traversable-1.0.15.1.tar.gz"},"name":"mono-traversable","pinned":{"url":["https://hackage.haskell.org/package/mono-traversable-1.0.15.1/mono-traversable-1.0.15.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/mono-traversable-1.0.15.1.tar.gz"],"sha256":"c2df5b79ed2f88f2ee313e57c1d591d4463788e20d39e439297eec5ba5835ddf","cabal-sha256":"cad0e8681cd6c96d3303867fc68c80e2f5d55c2c4bf5277c06ca74402fda61c8"},"version":"1.0.15.1"},
+    "mtl": {"dependencies":[],"location":{"type":"core"},"name":"mtl","version":"2.2.2"},
+    "mwc-random": {"dependencies":["base","math-functions","primitive","time","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/mwc-random-0.14.0.0/mwc-random-0.14.0.0.tar.gz"},"name":"mwc-random","pinned":{"url":["https://hackage.haskell.org/package/mwc-random-0.14.0.0/mwc-random-0.14.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/mwc-random-0.14.0.0.tar.gz"],"sha256":"00370edaa60a51c86663868ecc2b1995824970001875cec458e9acc13511efa2","cabal-sha256":"6ae33e246e91f66f621caabb2323b431c8dab57427a417a98f5cac3d82eb7b21"},"version":"0.14.0.0"},
+    "neat-interpolation": {"dependencies":["base","megaparsec","template-haskell","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/neat-interpolation-0.5.1.1/neat-interpolation-0.5.1.1.tar.gz"},"name":"neat-interpolation","pinned":{"url":["https://hackage.haskell.org/package/neat-interpolation-0.5.1.1/neat-interpolation-0.5.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/neat-interpolation-0.5.1.1.tar.gz"],"sha256":"a4af35abf3f31168f7478eb334592b90e9a658efd26a5702e6780ab2c61454ae","cabal-sha256":"55f45d1737bcdf57dc9753996dd61819df335a542d8bad61b72b3700261c5b70"},"version":"0.5.1.1"},
+    "network": {"dependencies":["base","bytestring","deepseq"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/network-3.1.1.1/network-3.1.1.1.tar.gz"},"name":"network","pinned":{"url":["https://hackage.haskell.org/package/network-3.1.1.1/network-3.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/network-3.1.1.1.tar.gz"],"sha256":"d7ef590173fff2ab522fbc167f3fafb867e4ecfca279eb3ef0d137b51f142c9a","cabal-sha256":"b704cb6676c03e98267190df797497587576a2e96094550ea143415239bbe66e"},"version":"3.1.1.1"},
+    "network-uri": {"dependencies":["base","deepseq","parsec","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/network-uri-2.6.3.0/network-uri-2.6.3.0.tar.gz"},"name":"network-uri","pinned":{"url":["https://hackage.haskell.org/package/network-uri-2.6.3.0/network-uri-2.6.3.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/network-uri-2.6.3.0.tar.gz"],"sha256":"a01c1389f15d2cc2e847914737f706133bb11f0c5f8ee89711a36a25b7afa723","cabal-sha256":"d2d9ff3a80d9b2d1ff317a354bc0c56cc109c69a4c2449e5fc712d3ddce83ede"},"version":"2.6.3.0"},
+    "optparse-applicative": {"dependencies":["ansi-wl-pprint","base","process","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-applicative-0.15.1.0/optparse-applicative-0.15.1.0.tar.gz"},"name":"optparse-applicative","pinned":{"url":["https://hackage.haskell.org/package/optparse-applicative-0.15.1.0/optparse-applicative-0.15.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-applicative-0.15.1.0.tar.gz"],"sha256":"4db3675fd1e0594afdf079db46f4cd412d483835d703e7c07e1a1a37d6f046f3","cabal-sha256":"29ff6146aabf54d46c4c8788e8d1eadaea27c94f6d360c690c5f6c93dac4b07e"},"version":"0.15.1.0"},
+    "optparse-generic": {"dependencies":["Only","base","bytestring","optparse-applicative","system-filepath","text","time","transformers","void"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/optparse-generic-1.4.2/optparse-generic-1.4.2.tar.gz"},"name":"optparse-generic","pinned":{"url":["https://hackage.haskell.org/package/optparse-generic-1.4.2/optparse-generic-1.4.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/optparse-generic-1.4.2.tar.gz"],"sha256":"26fb7261cef593dd7c9534614dc858894e9f29148975a1505f13c43aec356401","cabal-sha256":"c019eb6dfc83476b8afb520afae6b3a6f95c8061a745fbe272a8e043cc7b3dc9"},"version":"1.4.2"},
+    "parallel": {"dependencies":["array","base","containers","deepseq","ghc-prim"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parallel-3.2.2.0/parallel-3.2.2.0.tar.gz"},"name":"parallel","pinned":{"url":["https://hackage.haskell.org/package/parallel-3.2.2.0/parallel-3.2.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parallel-3.2.2.0.tar.gz"],"sha256":"170453a71a2a8b31cca63125533f7771d7debeb639700bdabdd779c34d8a6ef6","cabal-sha256":"c69372af9a39a06739e1d0eaa1f2d8be6b86493a53dbbc455e7b30479c491c6a"},"version":"3.2.2.0"},
+    "parsec": {"dependencies":[],"location":{"type":"core"},"name":"parsec","version":"3.1.14.0"},
+    "parser-combinators": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parser-combinators-1.2.1/parser-combinators-1.2.1.tar.gz"},"name":"parser-combinators","pinned":{"url":["https://hackage.haskell.org/package/parser-combinators-1.2.1/parser-combinators-1.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parser-combinators-1.2.1.tar.gz"],"sha256":"03162e40cde50253529fa452165b681d5064d03ad07992800702156adfb6254d","cabal-sha256":"16c3490e007ec10b1255a2b36fb483d000156d555269107131241d9e0fa96412"},"version":"1.2.1"},
+    "parsers": {"dependencies":["attoparsec","base","base-orphans","binary","charset","containers","mtl","parsec","scientific","semigroups","text","transformers","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/parsers-0.12.10/parsers-0.12.10.tar.gz"},"name":"parsers","pinned":{"url":["https://hackage.haskell.org/package/parsers-0.12.10/parsers-0.12.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/parsers-0.12.10.tar.gz"],"sha256":"17b91f1318ca54679395b382a056df633fdb44fbb962eca66b1787f957af1a6c","cabal-sha256":"3b0d9f15a64cb9a0c66b79b8653e9074e21a1c96d96cfad63ef2984219323499"},"version":"0.12.10"},
+    "pathtype": {"dependencies":["QuickCheck","base","deepseq","directory","semigroups","tagged","time","transformers","utility-ht"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/pathtype-0.8.1.1/pathtype-0.8.1.1.tar.gz"},"name":"pathtype","pinned":{"url":["https://hackage.haskell.org/package/pathtype-0.8.1.1/pathtype-0.8.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/pathtype-0.8.1.1.tar.gz"],"sha256":"c7dce1871e65c6447bbe138d6ccecd5abcde84aba6fac7003e7755d238c2420c","cabal-sha256":"8561fa48933c1ebd53b48a37806e4d72de31fee0bca4794cb1cd486468987a30"},"version":"0.8.1.1"},
+    "pretty": {"dependencies":[],"location":{"type":"core"},"name":"pretty","version":"1.1.3.6"},
+    "pretty-show": {"dependencies":["array","base","filepath","ghc-prim","happy","haskell-lexer","pretty","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/pretty-show-1.10/pretty-show-1.10.tar.gz"},"name":"pretty-show","pinned":{"url":["https://hackage.haskell.org/package/pretty-show-1.10/pretty-show-1.10.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/pretty-show-1.10.tar.gz"],"sha256":"307f9086e0b063d439dc4f513e36a145e8a57f23de448aefae2a6c00f6da6fd2","cabal-sha256":"bfef8da0ac4db4fc7f41edfec9e9a701ac206418d70702bff1e40f20d6a2b1f1"},"version":"1.10"},
+    "pretty-simple": {"dependencies":["Cabal","ansi-terminal","base","cabal-doctest","containers","mtl","text","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/pretty-simple-3.3.0.0/pretty-simple-3.3.0.0.tar.gz"},"name":"pretty-simple","pinned":{"url":["https://hackage.haskell.org/package/pretty-simple-3.3.0.0/pretty-simple-3.3.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/pretty-simple-3.3.0.0.tar.gz"],"sha256":"d01637fcfb61911bdd7e85127d79a3e862634c05b5402a3ec64ce36b5149033d","cabal-sha256":"c74f9c3c7234daddddfe2f0567adaced9c40e7c72c24abc3224fc2dcb5a350a2"},"version":"3.3.0.0"},
+    "prettyprinter": {"dependencies":["base","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/prettyprinter-1.6.2/prettyprinter-1.6.2.tar.gz"},"name":"prettyprinter","pinned":{"url":["https://hackage.haskell.org/package/prettyprinter-1.6.2/prettyprinter-1.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/prettyprinter-1.6.2.tar.gz"],"sha256":"d193f1902630d0a652a7043aa37069224ea56a3ff0fa1b57f57ebf5ece777008","cabal-sha256":"d9fa76aebce33c5c179a66128dfb5639e9257325d11c68569c6574dd8e112cde"},"version":"1.6.2"},
+    "prettyprinter-ansi-terminal": {"dependencies":["ansi-terminal","base","prettyprinter","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/prettyprinter-ansi-terminal-1.1.2/prettyprinter-ansi-terminal-1.1.2.tar.gz"},"name":"prettyprinter-ansi-terminal","pinned":{"url":["https://hackage.haskell.org/package/prettyprinter-ansi-terminal-1.1.2/prettyprinter-ansi-terminal-1.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/prettyprinter-ansi-terminal-1.1.2.tar.gz"],"sha256":"e26b7338b90830a126e210ec164426bd3da7d099a319d1287a40e3efce2a1799","cabal-sha256":"90b3b7650bc5b9f0e58da43621d23c817acfc0cf5ce71244b9bd11b8c9f95e3a"},"version":"1.1.2"},
+    "primitive": {"dependencies":["base","deepseq","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz"},"name":"primitive","pinned":{"url":["https://hackage.haskell.org/package/primitive-0.7.1.0/primitive-0.7.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/primitive-0.7.1.0.tar.gz"],"sha256":"6bebecfdf2a57787d9fd5231bfd612b65a92edd7b33a973b2a0f11312b89a3f0","cabal-sha256":"6a237bb338bcc43193077ff8e8c0f0ce2de14c652231496a15672e8b563a07e2"},"version":"0.7.1.0"},
+    "process": {"dependencies":[],"location":{"type":"core"},"name":"process","version":"1.6.8.2"},
+    "profunctors": {"dependencies":["base","base-orphans","bifunctors","comonad","contravariant","distributive","tagged","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/profunctors-5.5.2/profunctors-5.5.2.tar.gz"},"name":"profunctors","pinned":{"url":["https://hackage.haskell.org/package/profunctors-5.5.2/profunctors-5.5.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/profunctors-5.5.2.tar.gz"],"sha256":"5f1579aab8afae377c7c7c0d0ed95b0bc58003b6dad2d494045f7472a398af7c","cabal-sha256":"55132b7e8a5461e8f7fdc4e06839109fe42ad581225cd151342753fddb824aa8"},"version":"5.5.2"},
+    "proto-lens": {"dependencies":["base","bytestring","containers","deepseq","ghc-prim","lens-family","parsec","pretty","primitive","profunctors","tagged","text","transformers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/proto-lens-0.7.0.0/proto-lens-0.7.0.0.tar.gz"},"name":"proto-lens","pinned":{"url":["https://hackage.haskell.org/package/proto-lens-0.7.0.0/proto-lens-0.7.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/proto-lens-0.7.0.0.tar.gz"],"sha256":"3aa3b6aa1a1fa51cc2b7a60dde79112a7d87d6846cc8d65f3c3ad6c4b81ce7b5","cabal-sha256":"2c44a62375f7712f9381f84b1d30cee2f94384f1c98801db2f4450359a8e5036"},"version":"0.7.0.0"},
+    "proto-lens-jsonpb": {"dependencies":["aeson","attoparsec","base","base64-bytestring","bytestring","proto-lens-runtime","text","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/proto-lens-jsonpb-0.2.0.2/proto-lens-jsonpb-0.2.0.2.tar.gz"},"name":"proto-lens-jsonpb","pinned":{"url":["https://hackage.haskell.org/package/proto-lens-jsonpb-0.2.0.2/proto-lens-jsonpb-0.2.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/proto-lens-jsonpb-0.2.0.2.tar.gz"],"sha256":"a2b6085c73d1315ee34a62be9131321d44536c093c4b1f482a6f76bf024128e5","cabal-sha256":"a361759d615e54a58a2f92eecd991ec8ad563dfdf0169bef2ea02054cf581da1"},"version":"0.2.0.2"},
+    "proto-lens-runtime": {"dependencies":["base","bytestring","containers","deepseq","filepath","lens-family","proto-lens","text","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/proto-lens-runtime-0.7.0.0/proto-lens-runtime-0.7.0.0.tar.gz"},"name":"proto-lens-runtime","pinned":{"url":["https://hackage.haskell.org/package/proto-lens-runtime-0.7.0.0/proto-lens-runtime-0.7.0.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/proto-lens-runtime-0.7.0.0.tar.gz"],"sha256":"4dc1aebe1755c0b831d3cb029c7bfea04f252d0b1cee8653dded37baeab3aa63","cabal-sha256":"d6cfab159a63f5c42a1a507638c674a714dfa5f69a06f559e8da840eaafde3ab"},"version":"0.7.0.0"},
+    "quickcheck-io": {"dependencies":["HUnit","QuickCheck","base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/quickcheck-io-0.2.0/quickcheck-io-0.2.0.tar.gz"},"name":"quickcheck-io","pinned":{"url":["https://hackage.haskell.org/package/quickcheck-io-0.2.0/quickcheck-io-0.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/quickcheck-io-0.2.0.tar.gz"],"sha256":"fb779119d79fe08ff4d502fb6869a70c9a8d5fd8ae0959f605c3c937efd96422","cabal-sha256":"7bf0b68fb90873825eb2e5e958c1b76126dcf984debb998e81673e6d837e0b2d"},"version":"0.2.0"},
+    "random": {"dependencies":["base","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/random-1.1/random-1.1.tar.gz"},"name":"random","pinned":{"url":["https://hackage.haskell.org/package/random-1.1/random-1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/random-1.1.tar.gz"],"sha256":"b718a41057e25a3a71df693ab0fe2263d492e759679b3c2fea6ea33b171d3a5a","cabal-sha256":"7b67624fd76ddf97c206de0801dc7e888097e9d572974be9b9ea6551d76965df"},"version":"1.1"},
+    "raw-strings-qq": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/raw-strings-qq-1.1/raw-strings-qq-1.1.tar.gz"},"name":"raw-strings-qq","pinned":{"url":["https://hackage.haskell.org/package/raw-strings-qq-1.1/raw-strings-qq-1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/raw-strings-qq-1.1.tar.gz"],"sha256":"2e011ec26aeaa53ab43c30b7d9b5b0f661f24b4ebef8884c12c571353c0fbed3","cabal-sha256":"3ea0f14f036649e3576749aef0db4dd0b1102c5331f2e0e2551250e2030ce669"},"version":"1.1"},
+    "recursion-schemes": {"dependencies":["base","base-orphans","comonad","free","template-haskell","th-abstraction","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/recursion-schemes-5.1.3/recursion-schemes-5.1.3.tar.gz"},"name":"recursion-schemes","pinned":{"url":["https://hackage.haskell.org/package/recursion-schemes-5.1.3/recursion-schemes-5.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/recursion-schemes-5.1.3.tar.gz"],"sha256":"b21736e54b1d5fb0149624e95f2d8d8fd3413bb0972eda6a70e5753d3c9f1528","cabal-sha256":"cbcf3c36e1733a83fb8cda305bde2de18a2fbab53692e3301263964def430107"},"version":"5.1.3"},
+    "reducers": {"dependencies":["array","base","bytestring","containers","fingertree","hashable","semigroupoids","semigroups","text","transformers","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/reducers-3.12.3/reducers-3.12.3.tar.gz"},"name":"reducers","pinned":{"url":["https://hackage.haskell.org/package/reducers-3.12.3/reducers-3.12.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/reducers-3.12.3.tar.gz"],"sha256":"7186733767405984c1eda96b18908f458b379f116a1589cd66f4319fe8458e27","cabal-sha256":"8ba7676deae4059bca9c162927c28fd5f3b767640f6be0c96e1d2a35793919ec"},"version":"3.12.3"},
+    "reflection": {"dependencies":["base","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz"},"name":"reflection","pinned":{"url":["https://hackage.haskell.org/package/reflection-2.1.6/reflection-2.1.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/reflection-2.1.6.tar.gz"],"sha256":"bf3e14917ebb329a53701a3cce0afe670f20037a0148dbfa5cbfa574ed6ba6cd","cabal-sha256":"044acb7caf41a9d8246878f849baed2dffbc4582d0a1e5c7c079d4287239e970"},"version":"2.1.6"},
+    "resourcet": {"dependencies":["base","containers","exceptions","mtl","primitive","transformers","unliftio-core"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/resourcet-1.2.4.2/resourcet-1.2.4.2.tar.gz"},"name":"resourcet","pinned":{"url":["https://hackage.haskell.org/package/resourcet-1.2.4.2/resourcet-1.2.4.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/resourcet-1.2.4.2.tar.gz"],"sha256":"17f20842043ad199961a801b6efb1233b9098eb3537f8395844268f6a223eb87","cabal-sha256":"d57516781d1721f70aa0b9ec8ea9200ab02bf76349cb76d73ad57729302289cc"},"version":"1.2.4.2"},
+    "safe-exceptions": {"dependencies":["base","deepseq","exceptions","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/safe-exceptions-0.1.7.0/safe-exceptions-0.1.7.0.tar.gz"},"name":"safe-exceptions","pinned":{"url":["https://hackage.haskell.org/package/safe-exceptions-0.1.7.0/safe-exceptions-0.1.7.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/safe-exceptions-0.1.7.0.tar.gz"],"sha256":"18cddc587b52b6faa0287fb6ad6c964d1562571ea2c8ff57a194dd54b5fba069","cabal-sha256":"416cad3470889813fbffd9dce83c7610268a4a52acadeb87a66e388e09a90275"},"version":"0.1.7.0"},
+    "scientific": {"dependencies":["base","binary","bytestring","containers","deepseq","hashable","integer-gmp","integer-logarithms","primitive","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/scientific-0.3.6.2/scientific-0.3.6.2.tar.gz"},"name":"scientific","pinned":{"url":["https://hackage.haskell.org/package/scientific-0.3.6.2/scientific-0.3.6.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/scientific-0.3.6.2.tar.gz"],"sha256":"278d0afc87450254f8a76eab21b5583af63954efc9b74844a17a21a68013140f","cabal-sha256":"dd49abc76bd8e2b57e7a057dc2bb742a00527b4bf9350f9374be03b5934e55d8"},"version":"0.3.6.2"},
+    "semigroupoids": {"dependencies":["Cabal","base","base-orphans","bifunctors","cabal-doctest","comonad","containers","contravariant","distributive","hashable","tagged","template-haskell","transformers","transformers-compat","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroupoids-5.3.4/semigroupoids-5.3.4.tar.gz"},"name":"semigroupoids","pinned":{"url":["https://hackage.haskell.org/package/semigroupoids-5.3.4/semigroupoids-5.3.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroupoids-5.3.4.tar.gz"],"sha256":"00d2e48973c3ab0a5d52616728ed63d0509454c8328148f698720014d7c58964","cabal-sha256":"3a6445a6105348d01c71aa608e1a8644ad78c01ec17dc70b87cf161cac92a100"},"version":"5.3.4"},
+    "semigroups": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semigroups-0.19.1/semigroups-0.19.1.tar.gz"},"name":"semigroups","pinned":{"url":["https://hackage.haskell.org/package/semigroups-0.19.1/semigroups-0.19.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semigroups-0.19.1.tar.gz"],"sha256":"79e761e64b862564a3470d5d356cb6b060b14452d675859aed3b2d1e14646648","cabal-sha256":"ecae129621e0d2f77bef2f01e4458c2e0567ab6e1f39579c61d7cec8058ebb0e"},"version":"0.19.1"},
+    "semilattices": {"dependencies":["base","containers","hashable","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/semilattices-0.0.0.4/semilattices-0.0.0.4.tar.gz"},"name":"semilattices","pinned":{"url":["https://hackage.haskell.org/package/semilattices-0.0.0.4/semilattices-0.0.0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/semilattices-0.0.0.4.tar.gz"],"sha256":"f2a2a40ea0ef2e0f0aebcb64c74897c5060a74234988535266d98dd79f406191","cabal-sha256":"333707e460923711d1edbdd02ebe1c3957d4e0808eab9886747b52ee3e443639"},"version":"0.0.0.4"},
+    "setenv": {"dependencies":["base","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/setenv-0.1.1.3/setenv-0.1.1.3.tar.gz"},"name":"setenv","pinned":{"url":["https://hackage.haskell.org/package/setenv-0.1.1.3/setenv-0.1.1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/setenv-0.1.1.3.tar.gz"],"sha256":"e358df39afc03d5a39e2ec650652d845c85c80cc98fe331654deafb4767ecb32","cabal-sha256":"c5916ac0d2a828473cd171261328a290afe0abd799db1ac8c310682fe778c45b"},"version":"0.1.1.3"},
+    "smallcheck": {"dependencies":["base","logict","mtl","pretty"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/smallcheck-1.2.0/smallcheck-1.2.0.tar.gz"},"name":"smallcheck","pinned":{"url":["https://hackage.haskell.org/package/smallcheck-1.2.0/smallcheck-1.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/smallcheck-1.2.0.tar.gz"],"sha256":"d6c79227c6138b287ee8113d2cb95b15a6487d3abb7531309629c57b5e80d9f8","cabal-sha256":"8b431572e6a0503223e0e52014d41084c1b01f2aeea3bd499f6f529b3f6dfa89"},"version":"1.2.0"},
+    "split": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/split-0.2.3.4/split-0.2.3.4.tar.gz"},"name":"split","pinned":{"url":["https://hackage.haskell.org/package/split-0.2.3.4/split-0.2.3.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/split-0.2.3.4.tar.gz"],"sha256":"271fe5104c9f40034aa9a1aad6269bcecc9454bc5a57c247e69e17de996c1f2a","cabal-sha256":"bad9bfc9e8e0aca4ac1f7b3a2767ee6b1c199d4a1b6960db5cc3d7674aee5d73"},"version":"0.2.3.4"},
+    "splitmix": {"dependencies":["base","deepseq","random","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/splitmix-0.0.5/splitmix-0.0.5.tar.gz"},"name":"splitmix","pinned":{"url":["https://hackage.haskell.org/package/splitmix-0.0.5/splitmix-0.0.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/splitmix-0.0.5.tar.gz"],"sha256":"19f2987ba707c935656371776639588c3252cbb44b66cae16107b13e73b4cd52","cabal-sha256":"4a49661be63f5aea0e132e9ab51be918789bb4dceb4ab9b15b85ba9cbbef5999"},"version":"0.0.5"},
+    "stm": {"dependencies":[],"location":{"type":"core"},"name":"stm","version":"2.5.0.0"},
+    "stm-chans": {"dependencies":["Cabal","base","stm"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/stm-chans-3.0.0.4/stm-chans-3.0.0.4.tar.gz"},"name":"stm-chans","pinned":{"url":["https://hackage.haskell.org/package/stm-chans-3.0.0.4/stm-chans-3.0.0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/stm-chans-3.0.0.4.tar.gz"],"sha256":"2344fc5bfa33d565bad7b009fc0e2c5a7a595060ba149c661f44419fc0d54738","cabal-sha256":"e2eef3cea5251628f7b2ad22c24a1e5d08b83c19be4bd886ab0d7fed58ef2a6d"},"version":"3.0.0.4"},
+    "streaming": {"dependencies":["base","containers","ghc-prim","mmorph","mtl","transformers","transformers-base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/streaming-0.2.3.0/streaming-0.2.3.0.tar.gz"},"name":"streaming","pinned":{"url":["https://hackage.haskell.org/package/streaming-0.2.3.0/streaming-0.2.3.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/streaming-0.2.3.0.tar.gz"],"sha256":"b4008eee1fcee6a9f63d0d31eebefd6cf72731fab65d943831338c3961fafd62","cabal-sha256":"26638a19039b2f447fdbeb430de1f7084c68b6ccd21eff288f5e45cf83670e47"},"version":"0.2.3.0"},
+    "strict": {"dependencies":["assoc","base","binary","bytestring","deepseq","ghc-prim","hashable","text","these","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/strict-0.4/strict-0.4.tar.gz"},"name":"strict","pinned":{"url":["https://hackage.haskell.org/package/strict-0.4/strict-0.4.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/strict-0.4.tar.gz"],"sha256":"279fee78690409ce0878beead4a620f0c0975dba215d6778f183699e3576453f","cabal-sha256":"1b50c7c9c636c3a1bbc7f8873b9be48f6ca0faca4df6eec6a014de6208fb1c0e"},"version":"0.4"},
+    "syb": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/syb-0.7.1/syb-0.7.1.tar.gz"},"name":"syb","pinned":{"url":["https://hackage.haskell.org/package/syb-0.7.1/syb-0.7.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/syb-0.7.1.tar.gz"],"sha256":"e04a9c7ae48d9fe25e9b7a064f7122d39c710753544511e15df7a6e87fdfe700","cabal-sha256":"8d37b1e4d04a9aa8512dc6c2a06e02afc015a2fd3e735bdfeeacb5e2e853323c"},"version":"0.7.1"},
+    "system-filepath": {"dependencies":["Cabal","base","bytestring","deepseq","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/system-filepath-0.4.14/system-filepath-0.4.14.tar.gz"},"name":"system-filepath","pinned":{"url":["https://hackage.haskell.org/package/system-filepath-0.4.14/system-filepath-0.4.14.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/system-filepath-0.4.14.tar.gz"],"sha256":"1656ce3c0d585650784ceb3f794748286e19fb635f557e7b29b0897f8956d993","cabal-sha256":"e8ce7d24d7008a825e5d03aa672950a0e8178ac54c3de7134f36c3a7e37694a2"},"version":"0.4.14"},
+    "tagged": {"dependencies":["base","deepseq","template-haskell","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tagged-0.8.6/tagged-0.8.6.tar.gz"},"name":"tagged","pinned":{"url":["https://hackage.haskell.org/package/tagged-0.8.6/tagged-0.8.6.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tagged-0.8.6.tar.gz"],"sha256":"ad16def0884cf6f05ae1ae8e90192cf9d8d9673fa264b249499bd9e4fac791dd","cabal-sha256":"1f7ca84e6c88cbb923641c60041c9f56c34f1a889759cc073cdf10542b441ff9"},"version":"0.8.6"},
+    "tasty": {"dependencies":["ansi-terminal","async","base","clock","containers","mtl","optparse-applicative","stm","tagged","unbounded-delays","unix","wcwidth"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-1.2.3/tasty-1.2.3.tar.gz"},"name":"tasty","pinned":{"url":["https://hackage.haskell.org/package/tasty-1.2.3/tasty-1.2.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-1.2.3.tar.gz"],"sha256":"8ca107abc12a476cfbc84f516f30a614c81be315903f910bc681137eb702f662","cabal-sha256":"bba67074e5326d57e8f53fc1dabcb6841daa4dc51b053506eb7f40a6f49a0497"},"version":"1.2.3"},
+    "tasty-golden": {"dependencies":["async","base","bytestring","containers","deepseq","directory","filepath","mtl","optparse-applicative","process","tagged","tasty","temporary","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-golden-2.3.3.2/tasty-golden-2.3.3.2.tar.gz"},"name":"tasty-golden","pinned":{"url":["https://hackage.haskell.org/package/tasty-golden-2.3.3.2/tasty-golden-2.3.3.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-golden-2.3.3.2.tar.gz"],"sha256":"a936183e57da934c593d715ae0f122e36beaa935cea9fa19d21386730972b1a5","cabal-sha256":"2aa053398a20f9890702d910e6aade8971f9f1281817a72e74fc67eebe6cba4e"},"version":"2.3.3.2"},
+    "tasty-hedgehog": {"dependencies":["base","hedgehog","tagged","tasty"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-hedgehog-1.0.0.2/tasty-hedgehog-1.0.0.2.tar.gz"},"name":"tasty-hedgehog","pinned":{"url":["https://hackage.haskell.org/package/tasty-hedgehog-1.0.0.2/tasty-hedgehog-1.0.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-hedgehog-1.0.0.2.tar.gz"],"sha256":"65538f7371f5ccf52c232a4723d931dd0278ea49bf478c2abe50c3bc4c1d5bef","cabal-sha256":"f491beff9461e849f5008e5a65b2c9d7f97365e170c7ae03ea170c90b6d6877c"},"version":"1.0.0.2"},
+    "tasty-hspec": {"dependencies":["QuickCheck","base","hspec","hspec-core","tasty","tasty-quickcheck","tasty-smallcheck"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-hspec-1.1.5.1/tasty-hspec-1.1.5.1.tar.gz"},"name":"tasty-hspec","pinned":{"url":["https://hackage.haskell.org/package/tasty-hspec-1.1.5.1/tasty-hspec-1.1.5.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-hspec-1.1.5.1.tar.gz"],"sha256":"fe889ec0f7b3991c46a07d9ff9cf09608a73a18f434a7480d2a09c79e56f3345","cabal-sha256":"7f2e21d2f2a235401d661b93f53e374ab0456a7d2fe542871235905c2e804775"},"version":"1.1.5.1"},
+    "tasty-hunit": {"dependencies":["base","call-stack","tasty"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-hunit-0.10.0.2/tasty-hunit-0.10.0.2.tar.gz"},"name":"tasty-hunit","pinned":{"url":["https://hackage.haskell.org/package/tasty-hunit-0.10.0.2/tasty-hunit-0.10.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-hunit-0.10.0.2.tar.gz"],"sha256":"4823c85efe15f36e1d71867aaa6cdcdff3ef39f97492321e9bb8a30c742f6ef7","cabal-sha256":"8e8bd5807cec650f5aebc5ada07b57620c863e69145e65249651c1b48d97bd70"},"version":"0.10.0.2"},
+    "tasty-quickcheck": {"dependencies":["QuickCheck","base","optparse-applicative","random","tagged","tasty"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-quickcheck-0.10.1.1/tasty-quickcheck-0.10.1.1.tar.gz"},"name":"tasty-quickcheck","pinned":{"url":["https://hackage.haskell.org/package/tasty-quickcheck-0.10.1.1/tasty-quickcheck-0.10.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-quickcheck-0.10.1.1.tar.gz"],"sha256":"f8326014c975ad31cac9e3da55f4bc86d0b26139557987d58c1f9554a8f31f25","cabal-sha256":"b0a751bbe706447fd11cac21a7bbcf919631813aafaba3ce460a421348f6935c"},"version":"0.10.1.1"},
+    "tasty-smallcheck": {"dependencies":["async","base","smallcheck","tagged","tasty"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tasty-smallcheck-0.8.1/tasty-smallcheck-0.8.1.tar.gz"},"name":"tasty-smallcheck","pinned":{"url":["https://hackage.haskell.org/package/tasty-smallcheck-0.8.1/tasty-smallcheck-0.8.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tasty-smallcheck-0.8.1.tar.gz"],"sha256":"314ba7acdb7793730e7677f553a72dd6a4a8f9a45ff3e931cd7d384affb3c6d8","cabal-sha256":"37728da9451a857c7410353267c995abea92f8f395fcabd9fe7bf732cc2e3e2e"},"version":"0.8.1"},
+    "template-haskell": {"dependencies":[],"location":{"type":"core"},"name":"template-haskell","version":"2.16.0.0"},
+    "temporary": {"dependencies":["base","directory","exceptions","filepath","random","transformers","unix"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/temporary-1.3/temporary-1.3.tar.gz"},"name":"temporary","pinned":{"url":["https://hackage.haskell.org/package/temporary-1.3/temporary-1.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/temporary-1.3.tar.gz"],"sha256":"8c442993694b5ffca823ce864af95bd2841fb5264ee511c61cf48cc71d879890","cabal-sha256":"3a66c136f700dbf42f3c5000ca93e80b26dead51e54322c83272b236c1ec8ef1"},"version":"1.3"},
+    "terminal-size": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/terminal-size-0.3.2.1/terminal-size-0.3.2.1.tar.gz"},"name":"terminal-size","pinned":{"url":["https://hackage.haskell.org/package/terminal-size-0.3.2.1/terminal-size-0.3.2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/terminal-size-0.3.2.1.tar.gz"],"sha256":"b5c23e964756bc13914649a67d63233f59ad0a813abe7cadeb2fc9d586dc9658","cabal-sha256":"7b2d8e0475a46961d07ddfb91dee618de70eff55d9ba0402ebeac1f9dcf9b18b"},"version":"0.3.2.1"},
+    "terminfo": {"dependencies":[],"location":{"type":"core"},"name":"terminfo","version":"0.4.1.4"},
+    "text": {"dependencies":[],"location":{"type":"core"},"name":"text","version":"1.2.3.2"},
+    "tf-random": {"dependencies":["base","primitive","random","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tf-random-0.5/tf-random-0.5.tar.gz"},"name":"tf-random","pinned":{"url":["https://hackage.haskell.org/package/tf-random-0.5/tf-random-0.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tf-random-0.5.tar.gz"],"sha256":"2e30cec027b313c9e1794d326635d8fc5f79b6bf6e7580ab4b00186dadc88510","cabal-sha256":"14012837d0f0e18fdbbe3d56e67da8622ee5e20b180abce952dd50bd9f36b326"},"version":"0.5"},
+    "th-abstraction": {"dependencies":["base","containers","ghc-prim","template-haskell"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/th-abstraction-0.3.2.0/th-abstraction-0.3.2.0.tar.gz"},"name":"th-abstraction","pinned":{"url":["https://hackage.haskell.org/package/th-abstraction-0.3.2.0/th-abstraction-0.3.2.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/th-abstraction-0.3.2.0.tar.gz"],"sha256":"36fef33ad0f34b9b8fb5552fe6187579a00d5f90d938e9bc24d382a9919feb79","cabal-sha256":"9b5b4e6e2bbff9b075ad7751ee98e2107090bd17b51d5442695b8990e4db6521"},"version":"0.3.2.0"},
+    "these": {"dependencies":["assoc","base","binary","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz"},"name":"these","pinned":{"url":["https://hackage.haskell.org/package/these-1.1.1.1/these-1.1.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/these-1.1.1.1.tar.gz"],"sha256":"d798c9f56e17def441e8f51e54cc11afdb3e76c6a9d1e9ee154e9a78da0bf508","cabal-sha256":"3b63a3942f1da4ff97786221e3c654b969b54d570fef2cf4db97da4ea26a36cc"},"version":"1.1.1.1"},
+    "time": {"dependencies":[],"location":{"type":"core"},"name":"time","version":"1.9.3"},
+    "time-compat": {"dependencies":["base","base-orphans","deepseq","time"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/time-compat-1.9.3/time-compat-1.9.3.tar.gz"},"name":"time-compat","pinned":{"url":["https://hackage.haskell.org/package/time-compat-1.9.3/time-compat-1.9.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/time-compat-1.9.3.tar.gz"],"sha256":"bb6a44e667945ddca8ded93e041ee91986a4a19f59e149a5dd21fdb1bfa3db88","cabal-sha256":"a1a0a8b088be6a7be50c7c0bf156ce876151b1cbe14261736965e361c8073b2a"},"version":"1.9.3"},
+    "transformers": {"dependencies":[],"location":{"type":"core"},"name":"transformers","version":"0.5.6.2"},
+    "transformers-base": {"dependencies":["base","base-orphans","stm","transformers","transformers-compat"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/transformers-base-0.4.5.2/transformers-base-0.4.5.2.tar.gz"},"name":"transformers-base","pinned":{"url":["https://hackage.haskell.org/package/transformers-base-0.4.5.2/transformers-base-0.4.5.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/transformers-base-0.4.5.2.tar.gz"],"sha256":"d0c80c63fdce6a077dd8eda4f1ff289b85578703a3f1272e141d400fe23245e8","cabal-sha256":"e4d8155470905ba2942033a1537fc4cf91927d1c9b34693fd57ddf3bc02334af"},"version":"0.4.5.2"},
+    "transformers-compat": {"dependencies":["base","ghc-prim","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/transformers-compat-0.6.5/transformers-compat-0.6.5.tar.gz"},"name":"transformers-compat","pinned":{"url":["https://hackage.haskell.org/package/transformers-compat-0.6.5/transformers-compat-0.6.5.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/transformers-compat-0.6.5.tar.gz"],"sha256":"da67cf11515da751b32a8ce6e96549f7268f7c435769ad19dc9766b69774620b","cabal-sha256":"50b00c57bf3fc379ec2477bfc261a2aebc983084488478adb29854f193af4696"},"version":"0.6.5"},
+    "tree-sitter": {"dependencies":["base","bytestring","containers","directory","filepath","split","template-haskell","unordered-containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/tree-sitter-0.9.0.2/tree-sitter-0.9.0.2.tar.gz"},"name":"tree-sitter","pinned":{"url":["https://hackage.haskell.org/package/tree-sitter-0.9.0.2/tree-sitter-0.9.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/tree-sitter-0.9.0.2.tar.gz"],"sha256":"ae9edfd5415e8f243b14010491d149add962cf47d0fab7a36844faf34f0587cb","cabal-sha256":"a8e9821575a1bf90455cc164619f5a59f6cc01d66a870944ece84a755b6450d9"},"version":"0.9.0.2"},
+    "tree-sitter-go": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-go","version":"0.5.0.2"},
+    "tree-sitter-java": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-java","version":"0.7.0.2"},
+    "tree-sitter-json": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-json","version":"0.7.0.2"},
+    "tree-sitter-php": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-php","version":"0.5.0.1"},
+    "tree-sitter-python": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-python","version":"0.9.0.3"},
+    "tree-sitter-ql": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-ql","version":"0.1.0.4"},
+    "tree-sitter-ruby": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-ruby","version":"0.5.0.3"},
+    "tree-sitter-rust": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-rust","version":"0.1.0.1"},
+    "tree-sitter-tsx": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-tsx","version":"0.5.0.2"},
+    "tree-sitter-typescript": {"dependencies":["base","tree-sitter"],"location":{"type":"vendored"},"name":"tree-sitter-typescript","version":"0.5.0.2"},
+    "trifecta": {"dependencies":["Cabal","ansi-terminal","array","base","blaze-builder","blaze-html","blaze-markup","bytestring","cabal-doctest","charset","comonad","containers","deepseq","fingertree","ghc-prim","hashable","lens","mtl","parsers","prettyprinter","prettyprinter-ansi-terminal","profunctors","reducers","semigroups","transformers","unordered-containers","utf8-string"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/trifecta-2.1/trifecta-2.1.tar.gz"},"name":"trifecta","pinned":{"url":["https://hackage.haskell.org/package/trifecta-2.1/trifecta-2.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/trifecta-2.1.tar.gz"],"sha256":"7a25c6b07b6ca4c6465b9f888444183cd1eab54d2890272010150df7a911233b","cabal-sha256":"2a087ff4b1a6ea9e506a578a4161743b7bf1025e1ef4934a6d5d14f778e7609d"},"version":"2.1"},
+    "type-equality": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/type-equality-1/type-equality-1.tar.gz"},"name":"type-equality","pinned":{"url":["https://hackage.haskell.org/package/type-equality-1/type-equality-1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/type-equality-1.tar.gz"],"sha256":"4728b502a211454ef682a10d7a3e817c22d06ba509df114bb267ef9d43a08ce8","cabal-sha256":"d36324583fbafc5698c3f898ccf7cf041cbf42435fc2559c28e8f77682739a8e"},"version":"1"},
+    "unbounded-delays": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unbounded-delays-0.1.1.0/unbounded-delays-0.1.1.0.tar.gz"},"name":"unbounded-delays","pinned":{"url":["https://hackage.haskell.org/package/unbounded-delays-0.1.1.0/unbounded-delays-0.1.1.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unbounded-delays-0.1.1.0.tar.gz"],"sha256":"8aa7f7d10a8d0073518804db76c3ef4c313359994ef175122341b0bce07329c7","cabal-sha256":"8e57c6ffb72ed605b85c69d3b3a7ebbbbb70bfb5e9b9816309f1f733240838f2"},"version":"0.1.1.0"},
+    "unix": {"dependencies":[],"location":{"type":"core"},"name":"unix","version":"2.7.2.2"},
+    "unliftio-core": {"dependencies":["base","transformers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unliftio-core-0.2.0.1/unliftio-core-0.2.0.1.tar.gz"},"name":"unliftio-core","pinned":{"url":["https://hackage.haskell.org/package/unliftio-core-0.2.0.1/unliftio-core-0.2.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unliftio-core-0.2.0.1.tar.gz"],"sha256":"919f0d1297ea2f5373118553c1df2a9405d8b9e31a8307e829da67d4953c299a","cabal-sha256":"9b3e44ea9aacacbfc35b3b54015af450091916ac3618a41868ebf6546977659a"},"version":"0.2.0.1"},
+    "unordered-containers": {"dependencies":["base","deepseq","hashable"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/unordered-containers-0.2.12.0/unordered-containers-0.2.12.0.tar.gz"},"name":"unordered-containers","pinned":{"url":["https://hackage.haskell.org/package/unordered-containers-0.2.12.0/unordered-containers-0.2.12.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/unordered-containers-0.2.12.0.tar.gz"],"sha256":"481dab4ea59f10feaa7d65ecb8ae5d136d130bdbacf2356d414b3926d638bd20","cabal-sha256":"164a47850c4536c8b7cc12f74578588cf3b6c331f04e671306d2dcb806284bb1"},"version":"0.2.12.0"},
+    "utf8-string": {"dependencies":["base","bytestring"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/utf8-string-1.0.1.1/utf8-string-1.0.1.1.tar.gz"},"name":"utf8-string","pinned":{"url":["https://hackage.haskell.org/package/utf8-string-1.0.1.1/utf8-string-1.0.1.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/utf8-string-1.0.1.1.tar.gz"],"sha256":"fb0b9e3acbe0605bcd1c63e51f290a7bbbe6628dfa3294ff453e4235fbaef140","cabal-sha256":"68cc6cf665e7212334a51b63d6936daeaca023b2cfe8637d130acfe95f91700b"},"version":"1.0.1.1"},
+    "utility-ht": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/utility-ht-0.0.15/utility-ht-0.0.15.tar.gz"},"name":"utility-ht","pinned":{"url":["https://hackage.haskell.org/package/utility-ht-0.0.15/utility-ht-0.0.15.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/utility-ht-0.0.15.tar.gz"],"sha256":"845c79cdf0925997ec190a761460b50a9577cd290567b9252e31d075cd6f0f91","cabal-sha256":"940b35a19ce392c4fd86d96fecd0efb3c3b8a598af31fe5aca7e9f3b172e284b"},"version":"0.0.15"},
+    "uuid-types": {"dependencies":["base","binary","bytestring","deepseq","hashable","random","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/uuid-types-1.0.3/uuid-types-1.0.3.tar.gz"},"name":"uuid-types","pinned":{"url":["https://hackage.haskell.org/package/uuid-types-1.0.3/uuid-types-1.0.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/uuid-types-1.0.3.tar.gz"],"sha256":"9276517ab24a9b06f39d6e3c33c6c2b4ace1fc2126dbc1cd9806866a6551b3fd","cabal-sha256":"4e27aa142cb37f391e78f36d13139ba0a907675429a21e8f2cfae9223202dd7e"},"version":"1.0.3"},
+    "vector": {"dependencies":["base","deepseq","ghc-prim","primitive"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/vector-0.12.1.2/vector-0.12.1.2.tar.gz"},"name":"vector","pinned":{"url":["https://hackage.haskell.org/package/vector-0.12.1.2/vector-0.12.1.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/vector-0.12.1.2.tar.gz"],"sha256":"3b6e27683f6f20b37b8a35d0fab9e34b57dad72ac64cb16f428726780d4011bd","cabal-sha256":"9291bc581f36e51d5bda9fce57cb980fbec3dd292996896f285fef39eb80a9a0"},"version":"0.12.1.2"},
+    "vector-algorithms": {"dependencies":["base","bytestring","primitive","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/vector-algorithms-0.8.0.3/vector-algorithms-0.8.0.3.tar.gz"},"name":"vector-algorithms","pinned":{"url":["https://hackage.haskell.org/package/vector-algorithms-0.8.0.3/vector-algorithms-0.8.0.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/vector-algorithms-0.8.0.3.tar.gz"],"sha256":"1ac41f014663fd318b34a76b80e6d8f32f1629ef4996ae7304f31597a0d07387","cabal-sha256":"477ef5ac82fdd28a39536ed0a767faec3425802827abee485be31db5bc6f5e90"},"version":"0.8.0.3"},
+    "vector-builder": {"dependencies":["base","base-prelude","semigroups","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/vector-builder-0.3.8/vector-builder-0.3.8.tar.gz"},"name":"vector-builder","pinned":{"url":["https://hackage.haskell.org/package/vector-builder-0.3.8/vector-builder-0.3.8.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/vector-builder-0.3.8.tar.gz"],"sha256":"a39afd7ac50c42de77660d235017be38ef50f792b6a98212accf687445a18073","cabal-sha256":"184ed15a76025943ccaf556887cf60bca21359e3ccf4d7735def394ab76b76f1"},"version":"0.3.8"},
+    "void": {"dependencies":["base"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/void-0.7.3/void-0.7.3.tar.gz"},"name":"void","pinned":{"url":["https://hackage.haskell.org/package/void-0.7.3/void-0.7.3.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/void-0.7.3.tar.gz"],"sha256":"53af758ddc37dc63981671e503438d02c6f64a2d8744e9bec557a894431f7317","cabal-sha256":"13d30f62fcdf065e595d679d4ac8b4b0c1bb1a1b73db7b5b5a8f857cb5c8a546"},"version":"0.7.3"},
+    "wcwidth": {"dependencies":["base","containers"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/wcwidth-0.0.2/wcwidth-0.0.2.tar.gz"},"name":"wcwidth","pinned":{"url":["https://hackage.haskell.org/package/wcwidth-0.0.2/wcwidth-0.0.2.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/wcwidth-0.0.2.tar.gz"],"sha256":"ffc68736a3bbde3e8157710f29f4a99c0ca593c41194579c54a92c62f6c12ed8","cabal-sha256":"77531eb6683c505c22ab3fa11bbc43d3ce1e7dac21401d4d5a19677d348bb5f3"},"version":"0.0.2"},
+    "wl-pprint-annotated": {"dependencies":["base","containers","deepseq","text"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/wl-pprint-annotated-0.1.0.1/wl-pprint-annotated-0.1.0.1.tar.gz"},"name":"wl-pprint-annotated","pinned":{"url":["https://hackage.haskell.org/package/wl-pprint-annotated-0.1.0.1/wl-pprint-annotated-0.1.0.1.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/wl-pprint-annotated-0.1.0.1.tar.gz"],"sha256":"6b662b244b2e318a2923dc7057d707369a29ea4a0e721b4710eac7239cc727af","cabal-sha256":"0b8fd3649bfe72d155a4379e4c88b7ef00408f6f4973f63333787fd2e1b5ba1e"},"version":"0.1.0.1"},
+    "yaml": {"dependencies":["aeson","attoparsec","base","bytestring","conduit","containers","directory","filepath","libyaml","mtl","resourcet","scientific","template-haskell","text","transformers","unordered-containers","vector"],"location":{"type":"hackage","url":"https://hackage.haskell.org/package/yaml-0.11.4.0/yaml-0.11.4.0.tar.gz"},"name":"yaml","pinned":{"url":["https://hackage.haskell.org/package/yaml-0.11.4.0/yaml-0.11.4.0.tar.gz","https://s3.amazonaws.com/hackage.fpcomplete.com/package/yaml-0.11.4.0.tar.gz"],"sha256":"da4ec8469bb5cc43d131ffee90e89a430a65baad4caa611e91cd9b684168c96c","cabal-sha256":"2583bfc6ea297290fa1bae47242627898896e2647aaaf7662d6d7df9a2dac0b2"},"version":"0.11.4.0"}
+  }
+}