diff --git a/binary-parser.cabal b/binary-parser.cabal
--- a/binary-parser.cabal
+++ b/binary-parser.cabal
@@ -1,72 +1,87 @@
-name:
-  binary-parser
-version:
-  0.5.7.2
+cabal-version: 3.0
+name:          binary-parser
+version:       0.5.7.3
 synopsis:
-  A highly-efficient but limited parser API specialised for bytestrings
-category:
-  Parser, Binary
-homepage:
-  https://github.com/nikita-volkov/binary-parser
-bug-reports:
-  https://github.com/nikita-volkov/binary-parser/issues
-author:
-  Nikita Volkov <nikita.y.volkov@mail.ru>
-maintainer:
-  Nikita Volkov <nikita.y.volkov@mail.ru>
-copyright:
-  (c) 2015, Nikita Volkov
-license:
-  MIT
-license-file:
-  LICENSE
-build-type:
-  Simple
-cabal-version:
-  >=1.10
+  An efficient but limited parser API specialised to bytestrings
 
+category:      Parser, Binary
+homepage:      https://github.com/nikita-volkov/binary-parser
+bug-reports:   https://github.com/nikita-volkov/binary-parser/issues
+author:        Nikita Volkov <nikita.y.volkov@mail.ru>
+maintainer:    Nikita Volkov <nikita.y.volkov@mail.ru>
+copyright:     (c) 2015, Nikita Volkov
+license:       MIT
+license-file:  LICENSE
+
 source-repository head
-  type:
-    git
-  location:
-    git://github.com/nikita-volkov/binary-parser.git
+  type:     git
+  location: git://github.com/nikita-volkov/binary-parser.git
 
-library
-  hs-source-dirs:
-    library
+common base-settings
+  default-language:   Haskell2010
   default-extensions:
-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, DerivingVia, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, RoleAnnotations, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
-  default-language:
-    Haskell2010
-  other-modules:
-    BinaryParser.Prelude
-  exposed-modules:
-    BinaryParser
+    NoImplicitPrelude
+    NoMonomorphismRestriction
+    Arrows
+    BangPatterns
+    ConstraintKinds
+    DataKinds
+    DefaultSignatures
+    DeriveDataTypeable
+    DeriveFoldable
+    DeriveFunctor
+    DeriveGeneric
+    DeriveTraversable
+    DerivingVia
+    EmptyDataDecls
+    FlexibleContexts
+    FlexibleInstances
+    FunctionalDependencies
+    GADTs
+    GeneralizedNewtypeDeriving
+    LambdaCase
+    LiberalTypeSynonyms
+    MagicHash
+    MultiParamTypeClasses
+    MultiWayIf
+    OverloadedStrings
+    ParallelListComp
+    PatternGuards
+    QuasiQuotes
+    RankNTypes
+    RecordWildCards
+    RoleAnnotations
+    ScopedTypeVariables
+    StandaloneDeriving
+    TemplateHaskell
+    TupleSections
+    TypeFamilies
+    TypeOperators
+    UnboxedTuples
+
   build-depends:
-    -- data:
-    bytestring >= 0.10 && < 0.12,
-    text >= 1 && < 3,
-    -- general:
-    mtl == 2.*,
-    transformers >= 0.4 && < 0.7,
-    base >= 4.12 && < 5
+    , base          >=4.12 && <5
+    , bytestring    >=0.10 && <0.12
+    , mtl           >=2    && <3
+    , text          >=1    && <3
+    , transformers  >=0.4  && <0.7
 
+library
+  import:          base-settings
+  hs-source-dirs:  library
+  other-modules:   BinaryParser.Prelude
+  exposed-modules: BinaryParser
+
 test-suite tests
-  type:
-    exitcode-stdio-1.0
-  hs-source-dirs:
-    tests
-  main-is:
-    Main.hs
-  default-extensions:
-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, DerivingVia, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, RoleAnnotations, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
-  default-language:
-    Haskell2010
+  import:         base-settings
+  type:           exitcode-stdio-1.0
+  hs-source-dirs: tests
+  main-is:        Main.hs
   build-depends:
-    binary-parser,
-    QuickCheck >=2.10 && <3,
-    quickcheck-instances >=0.3.22 && <0.4,
-    rerebase <2,
-    tasty >=1.2.3 && <2,
-    tasty-hunit >=0.10 && <0.11,
-    tasty-quickcheck >=0.10 && <0.11
+    , base-prelude          >=1.6    && <2
+    , binary-parser
+    , QuickCheck            >=2.10   && <3
+    , quickcheck-instances  ^>=0.3.22
+    , tasty                 >=1.2.3  && <2
+    , tasty-hunit           ^>=0.10
+    , tasty-quickcheck      ^>=0.10
diff --git a/library/BinaryParser.hs b/library/BinaryParser.hs
--- a/library/BinaryParser.hs
+++ b/library/BinaryParser.hs
@@ -1,51 +1,52 @@
 {-# LANGUAGE CPP #-}
+
 module BinaryParser
-(
-  BinaryParser,
-  run,
-  failure,
-  byte,
-  matchingByte,
-  bytesOfSize,
-  bytesWhile,
-  unitOfSize,
-  unitOfBytes,
-  unitWhile,
-  remainders,
-  fold,
-  endOfInput,
-  sized,
-  -- * Extras
-  storableOfSize,
-  beWord16,
-  leWord16,
-  beWord32,
-  leWord32,
-  beWord64,
-  leWord64,
-  asciiIntegral,
-)
+  ( BinaryParser,
+    run,
+    failure,
+    byte,
+    matchingByte,
+    bytesOfSize,
+    bytesWhile,
+    unitOfSize,
+    unitOfBytes,
+    unitWhile,
+    remainders,
+    fold,
+    endOfInput,
+    sized,
+
+    -- * Extras
+    storableOfSize,
+    beWord16,
+    leWord16,
+    beWord32,
+    leWord32,
+    beWord64,
+    leWord64,
+    asciiIntegral,
+  )
 where
 
 import BinaryParser.Prelude hiding (fold)
+import qualified BinaryParser.Prelude as B
 import qualified Data.ByteString as ByteString
-import qualified Data.ByteString.Unsafe as ByteString
 import qualified Data.ByteString.Internal as A
-import qualified BinaryParser.Prelude as B
-
+import qualified Data.ByteString.Unsafe as ByteString
 
 -- |
 -- A highly-efficient parser specialised for strict 'ByteString's.
--- 
+--
 -- Supports the roll-back and alternative branching
 -- on the basis of the 'Alternative' interface.
--- 
+--
 -- Does not generate fancy error-messages,
 -- which contributes to its efficiency.
-newtype BinaryParser a =
-  BinaryParser ( ByteString -> Either Text ( a , ByteString ) )
-  deriving ( Functor , Applicative , Alternative , Monad , MonadPlus , MonadError Text )
-    via ( StateT ByteString ( Except Text ) )
+newtype BinaryParser a
+  = BinaryParser (ByteString -> Either Text (a, ByteString))
+  deriving
+    (Functor, Applicative, Alternative, Monad, MonadPlus, MonadError Text)
+    via (StateT ByteString (Except Text))
 
 type role BinaryParser representational
 
@@ -189,8 +190,8 @@
   BinaryParser $ \remainders ->
     if ByteString.length remainders >= size
       then
-        parser (ByteString.unsafeTake size remainders) &
-        fmap (\result -> (fst result, ByteString.unsafeDrop size remainders))
+        parser (ByteString.unsafeTake size remainders)
+          & fmap (\result -> (fst result, ByteString.unsafeDrop size remainders))
       else Left "End of input"
 
 -- |
@@ -200,12 +201,13 @@
 storableOfSize size =
   BinaryParser $ \(A.PS payloadFP offset length) ->
     if length >= size
-      then let result =
-                 unsafeDupablePerformIO $ withForeignPtr payloadFP $ \ptr -> peekByteOff (castPtr ptr) offset
-               newRemainder =
-                 A.PS payloadFP (offset + size) (length - size)
-               in Right (result, newRemainder)
-      else Left "End of input" 
+      then
+        let result =
+              unsafeDupablePerformIO $ withForeignPtr payloadFP $ \ptr -> peekByteOff (castPtr ptr) offset
+            newRemainder =
+              A.PS payloadFP (offset + size) (length - size)
+         in Right (result, newRemainder)
+      else Left "End of input"
 
 -- | Big-endian word of 2 bytes.
 {-# INLINE beWord16 #-}
@@ -277,7 +279,7 @@
 -- Integral number encoded in ASCII.
 {-# INLINE asciiIntegral #-}
 asciiIntegral :: Integral a => BinaryParser a
-asciiIntegral = 
+asciiIntegral =
   do
     firstDigit <- matchingByte byteDigit
     fold step firstDigit
diff --git a/library/BinaryParser/Prelude.hs b/library/BinaryParser/Prelude.hs
--- a/library/BinaryParser/Prelude.hs
+++ b/library/BinaryParser/Prelude.hs
@@ -1,27 +1,34 @@
 module BinaryParser.Prelude
-( 
-  module Exports,
-  mapLeft,
-  joinMap,
-)
+  ( module Exports,
+    mapLeft,
+    joinMap,
+  )
 where
 
-
--- base
--------------------------
 import Control.Applicative as Exports
 import Control.Arrow as Exports hiding (first, second)
 import Control.Category as Exports
 import Control.Concurrent as Exports
 import Control.Exception as Exports
-import Control.Monad as Exports hiding (fail, mapM_, sequence_, forM_, msum, mapM, sequence, forM)
-import Control.Monad.IO.Class as Exports
+import Control.Monad as Exports hiding (fail, forM, forM_, mapM, mapM_, msum, sequence, sequence_)
+import Control.Monad.Cont.Class as Exports
+import Control.Monad.Error.Class as Exports hiding (Error (..))
 import Control.Monad.Fail as Exports
 import Control.Monad.Fix as Exports hiding (fix)
+import Control.Monad.IO.Class as Exports
+import Control.Monad.Reader.Class as Exports
 import Control.Monad.ST as Exports
+import Control.Monad.State.Class as Exports
+import Control.Monad.Trans.Class as Exports
+import Control.Monad.Trans.Except as Exports (Except, ExceptT (ExceptT), catchE, except, mapExcept, mapExceptT, runExcept, runExceptT, throwE, withExcept, withExceptT)
+import Control.Monad.Trans.Reader as Exports (Reader, ReaderT (ReaderT), mapReader, mapReaderT, runReader, runReaderT, withReader, withReaderT)
+import Control.Monad.Trans.State.Strict as Exports (State, StateT (StateT), evalState, evalStateT, execState, execStateT, mapState, mapStateT, runState, runStateT, withState, withStateT)
+import Control.Monad.Trans.Writer.Strict as Exports (Writer, WriterT (..), execWriter, execWriterT, mapWriter, mapWriterT, runWriter)
+import Control.Monad.Writer.Class as Exports
 import Data.Bifunctor as Exports
 import Data.Bits as Exports
 import Data.Bool as Exports
+import Data.ByteString as Exports (ByteString)
 import Data.Char as Exports
 import Data.Coerce as Exports
 import Data.Complex as Exports
@@ -33,19 +40,20 @@
 import Data.Function as Exports hiding (id, (.))
 import Data.Functor as Exports
 import Data.Functor.Identity as Exports
-import Data.Int as Exports
 import Data.IORef as Exports
+import Data.Int as Exports
 import Data.Ix as Exports
-import Data.List as Exports hiding (sortOn, isSubsequenceOf, uncons, concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl')
-import Data.List.NonEmpty as Exports (NonEmpty(..))
+import Data.List as Exports hiding (all, and, any, concat, concatMap, elem, find, foldl, foldl', foldl1, foldr, foldr1, isSubsequenceOf, mapAccumL, mapAccumR, maximum, maximumBy, minimum, minimumBy, notElem, or, product, sortOn, sum, uncons)
+import Data.List.NonEmpty as Exports (NonEmpty (..))
 import Data.Maybe as Exports
-import Data.Monoid as Exports hiding (Last(..), First(..), (<>))
+import Data.Monoid as Exports hiding (First (..), Last (..), (<>))
 import Data.Ord as Exports
 import Data.Proxy as Exports
 import Data.Ratio as Exports
-import Data.Semigroup as Exports
 import Data.STRef as Exports
+import Data.Semigroup as Exports
 import Data.String as Exports
+import Data.Text as Exports (Text)
 import Data.Traversable as Exports
 import Data.Tuple as Exports
 import Data.Unique as Exports
@@ -56,13 +64,12 @@
 import Foreign.ForeignPtr as Exports
 import Foreign.Ptr as Exports
 import Foreign.StablePtr as Exports
-import Foreign.Storable as Exports hiding (sizeOf, alignment)
-import GHC.Conc as Exports hiding (orElse, withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead)
-import GHC.Exts as Exports (lazy, inline, sortWith, groupWith, IsList(fromList, Item))
+import Foreign.Storable as Exports hiding (alignment, sizeOf)
+import GHC.Conc as Exports hiding (orElse, threadWaitRead, threadWaitReadSTM, threadWaitWrite, threadWaitWriteSTM, withMVar)
+import GHC.Exts as Exports (IsList (Item, fromList), groupWith, inline, lazy, sortWith)
 import GHC.Generics as Exports (Generic, Generic1)
 import GHC.IO.Exception as Exports
 import Numeric as Exports
-import Prelude as Exports hiding (fail, concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.))
 import System.Environment as Exports
 import System.Exit as Exports
 import System.IO as Exports
@@ -72,38 +79,11 @@
 import System.Mem.StableName as Exports
 import System.Timeout as Exports
 import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P)
-import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec)
-import Text.Printf as Exports (printf, hPrintf)
-import Text.Read as Exports (Read(..), readMaybe, readEither)
+import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readP_to_Prec, readPrec_to_P, readPrec_to_S, readS_to_Prec)
+import Text.Printf as Exports (hPrintf, printf)
+import Text.Read as Exports (Read (..), readEither, readMaybe)
 import Unsafe.Coerce as Exports
-
--- transformers
--------------------------
-import Control.Monad.IO.Class as Exports
-import Control.Monad.Trans.Class as Exports
-import Control.Monad.Trans.Cont as Exports hiding (shift, callCC)
-import Control.Monad.Trans.Except as Exports (ExceptT(ExceptT), Except, except, runExcept, runExceptT, mapExcept, mapExceptT, withExcept, withExceptT, throwE, catchE)
-import Control.Monad.Trans.Maybe as Exports
-import Control.Monad.Trans.Reader as Exports (Reader, runReader, mapReader, withReader, ReaderT(ReaderT), runReaderT, mapReaderT, withReaderT)
-import Control.Monad.Trans.State.Strict as Exports (State, runState, evalState, execState, mapState, withState, StateT(StateT), runStateT, evalStateT, execStateT, mapStateT, withStateT)
-import Control.Monad.Trans.Writer.Strict as Exports (Writer, runWriter, execWriter, mapWriter, WriterT(..), execWriterT, mapWriterT)
-
--- mtl
--------------------------
-import Control.Monad.Cont.Class as Exports
-import Control.Monad.Error.Class as Exports hiding (Error(..))
-import Control.Monad.Reader.Class as Exports
-import Control.Monad.State.Class as Exports
-import Control.Monad.Writer.Class as Exports
-
--- bytestring
--------------------------
-import Data.ByteString as Exports (ByteString)
-
--- text
--------------------------
-import Data.Text as Exports (Text)
-
+import Prelude as Exports hiding (all, and, any, concat, concatMap, elem, fail, foldl, foldl1, foldr, foldr1, id, mapM, mapM_, maximum, minimum, notElem, or, product, sequence, sequence_, sum, (.))
 
 {-# INLINE mapLeft #-}
 mapLeft :: (a -> b) -> Either a x -> Either b x
diff --git a/tests/Main.hs b/tests/Main.hs
--- a/tests/Main.hs
+++ b/tests/Main.hs
@@ -1,42 +1,35 @@
 module Main where
 
-import Prelude
+import BasePrelude
+import qualified BinaryParser as B
+import qualified Data.ByteString as A
+import qualified Data.ByteString.Builder as C
+import qualified Data.ByteString.Lazy as D
 import Test.QuickCheck.Instances
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.QuickCheck
-import qualified Data.ByteString as A
-import qualified Data.ByteString.Builder as C
-import qualified Data.ByteString.Lazy as D
-import qualified BinaryParser as B
 
-
 main =
   defaultMain $
-  testGroup "All tests" $
-  [
-    builderIsomporhismProperty "byte" B.byte C.word8
-    ,
-    builderIsomporhismProperty "beWord16" B.beWord16 C.word16BE
-    ,
-    builderIsomporhismProperty "beWord32" B.beWord32 C.word32BE
-    ,
-    expectedResultTest "byte consumes" ((,) <$> B.byte <*> B.beWord32) (49, 4) "1\NUL\NUL\NUL\EOT"
-    ,
-    expectedResultTest "Applicative composition" ((,) <$> B.beWord16 <*> B.beWord16) (1, 2) "\NUL\SOH\NUL\STX"
-    ,
-    let parser =
-          do
-            a <- B.beWord16
-            b <- B.beWord16
-            return (a, b)
-        in expectedResultTest "Monadic composition" parser (1, 2) "\NUL\SOH\NUL\STX"
-  ]
+    testGroup "All tests" $
+      [ builderIsomporhismProperty "byte" B.byte C.word8,
+        builderIsomporhismProperty "beWord16" B.beWord16 C.word16BE,
+        builderIsomporhismProperty "beWord32" B.beWord32 C.word32BE,
+        expectedResultTest "byte consumes" ((,) <$> B.byte <*> B.beWord32) (49, 4) "1\NUL\NUL\NUL\EOT",
+        expectedResultTest "Applicative composition" ((,) <$> B.beWord16 <*> B.beWord16) (1, 2) "\NUL\SOH\NUL\STX",
+        let parser =
+              do
+                a <- B.beWord16
+                b <- B.beWord16
+                return (a, b)
+         in expectedResultTest "Monadic composition" parser (1, 2) "\NUL\SOH\NUL\STX"
+      ]
 
 builderIsomporhismProperty details parser valueToBuilder =
   testProperty name $ \value ->
-  B.run parser (D.toStrict (C.toLazyByteString (valueToBuilder value))) ===
-  Right value
+    B.run parser (D.toStrict (C.toLazyByteString (valueToBuilder value)))
+      === Right value
   where
     name =
       "builderIsomporhismProperty: " <> details