diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+1.4.0.0 [2024-07-01]
+--------------------
+* Mini.Transformers.ParserT:
+  * Prune parser combinators 'endBy', 'endBy1'
+  * Add parser 'peek'
+  * Add parser combinator 'till'
+  * Clarify 'chainl1', 'chainr1' haddockumentation
+* Add build flags for explicit imports
+* Streamline imports
+
 1.3.0.1 [2024-04-14]
 --------------------
 * Streamline data documentation
diff --git a/Mini/Data/Map.hs b/Mini/Data/Map.hs
--- a/Mini/Data/Map.hs
+++ b/Mini/Data/Map.hs
@@ -51,11 +51,56 @@
 import Data.Bool (
   bool,
  )
-import Prelude hiding (
-  filter,
-  lookup,
-  map,
-  null,
+import Prelude (
+  Applicative,
+  Bool (
+    False,
+    True
+  ),
+  Eq,
+  Foldable,
+  Functor,
+  Int,
+  Maybe (
+    Just,
+    Nothing
+  ),
+  Monoid,
+  Ord,
+  Ordering (
+    EQ,
+    GT,
+    LT
+  ),
+  Semigroup,
+  Show,
+  Traversable,
+  compare,
+  const,
+  error,
+  flip,
+  fmap,
+  foldl,
+  foldr,
+  max,
+  maybe,
+  mempty,
+  not,
+  pure,
+  show,
+  traverse,
+  uncurry,
+  ($),
+  (&&),
+  (+),
+  (-),
+  (.),
+  (<),
+  (<$>),
+  (<*>),
+  (<>),
+  (==),
+  (>),
  )
 
 {-
@@ -88,7 +133,7 @@
 instance Functor (Map k) where
   fmap f = map E (go L) (go B) (go R)
    where
-    go c _ k a _ recl recr = c recl k (f a) recr
+    go c _ k a _ recl = c recl k (f a)
 
 instance Foldable (Map k) where
   foldr = foldrWithKey . const
diff --git a/Mini/Data/Set.hs b/Mini/Data/Set.hs
--- a/Mini/Data/Set.hs
+++ b/Mini/Data/Set.hs
@@ -43,9 +43,42 @@
 import Data.Bool (
   bool,
  )
-import Prelude hiding (
-  filter,
-  null,
+import Prelude (
+  Bool (
+    False,
+    True
+  ),
+  Eq,
+  Foldable,
+  Int,
+  Maybe (
+    Just,
+    Nothing
+  ),
+  Ord,
+  Ordering (
+    EQ,
+    GT,
+    LT
+  ),
+  Show,
+  compare,
+  error,
+  flip,
+  foldl,
+  foldr,
+  max,
+  show,
+  uncurry,
+  ($),
+  (&&),
+  (+),
+  (-),
+  (.),
+  (<),
+  (<>),
+  (==),
+  (>),
  )
 
 {-
diff --git a/Mini/Optics/Lens.hs b/Mini/Optics/Lens.hs
--- a/Mini/Optics/Lens.hs
+++ b/Mini/Optics/Lens.hs
@@ -16,15 +16,22 @@
 
 import Control.Applicative (
   Const (
-    Const,
-    getConst
+    Const
   ),
+  getConst,
  )
 import Data.Functor.Identity (
   Identity (
-    Identity,
-    runIdentity
+    Identity
   ),
+  runIdentity,
+ )
+import Prelude (
+  Functor,
+  const,
+  ($),
+  (.),
+  (<$>),
  )
 
 {-
diff --git a/Mini/Transformers/Class.hs b/Mini/Transformers/Class.hs
--- a/Mini/Transformers/Class.hs
+++ b/Mini/Transformers/Class.hs
@@ -6,6 +6,10 @@
   ),
 ) where
 
+import Prelude (
+  Monad,
+ )
+
 {-
  - Class
  -}
diff --git a/Mini/Transformers/EitherT.hs b/Mini/Transformers/EitherT.hs
--- a/Mini/Transformers/EitherT.hs
+++ b/Mini/Transformers/EitherT.hs
@@ -14,10 +14,9 @@
 ) where
 
 import Control.Applicative (
-  Alternative (
-    empty,
-    (<|>)
-  ),
+  Alternative,
+  empty,
+  (<|>),
  )
 import Control.Monad (
   ap,
@@ -25,9 +24,28 @@
   (>=>),
  )
 import Mini.Transformers.Class (
-  MonadTrans (
-    lift
+  MonadTrans,
+  lift,
+ )
+import Prelude (
+  Applicative,
+  Either (
+    Left,
+    Right
   ),
+  Functor,
+  Monad,
+  Monoid,
+  either,
+  fmap,
+  mappend,
+  mempty,
+  pure,
+  ($),
+  (.),
+  (<$>),
+  (<*>),
+  (>>=),
  )
 
 {-
diff --git a/Mini/Transformers/MaybeT.hs b/Mini/Transformers/MaybeT.hs
--- a/Mini/Transformers/MaybeT.hs
+++ b/Mini/Transformers/MaybeT.hs
@@ -14,10 +14,9 @@
 ) where
 
 import Control.Applicative (
-  Alternative (
-    empty,
-    (<|>)
-  ),
+  Alternative,
+  empty,
+  (<|>),
  )
 import Control.Monad (
   ap,
@@ -25,9 +24,25 @@
   (>=>),
  )
 import Mini.Transformers.Class (
-  MonadTrans (
-    lift
+  MonadTrans,
+  lift,
+ )
+import Prelude (
+  Applicative,
+  Functor,
+  Maybe (
+    Just,
+    Nothing
   ),
+  Monad,
+  fmap,
+  maybe,
+  pure,
+  ($),
+  (.),
+  (<$>),
+  (<*>),
+  (>>=),
  )
 
 {-
diff --git a/Mini/Transformers/ParserT.hs b/Mini/Transformers/ParserT.hs
--- a/Mini/Transformers/ParserT.hs
+++ b/Mini/Transformers/ParserT.hs
@@ -23,12 +23,12 @@
   oneOf,
   noneOf,
   eof,
+  peek,
 
   -- * Combinators
   sepBy,
   sepBy1,
-  endBy,
-  endBy1,
+  till,
   chainl1,
   chainr1,
   between,
@@ -38,11 +38,10 @@
 ) where
 
 import Control.Applicative (
-  Alternative (
-    empty,
-    many,
-    (<|>)
-  ),
+  Alternative,
+  empty,
+  many,
+  (<|>),
  )
 import Control.Monad (
   ap,
@@ -53,9 +52,50 @@
   bool,
  )
 import Mini.Transformers.Class (
-  MonadTrans (
-    lift
+  MonadTrans,
+  lift,
+ )
+import Prelude (
+  Applicative,
+  Bool (
+    True
   ),
+  Either (
+    Left,
+    Right
+  ),
+  Eq,
+  Foldable,
+  Functor,
+  Monad,
+  MonadFail,
+  Monoid,
+  Semigroup,
+  Show,
+  String,
+  Traversable,
+  const,
+  either,
+  elem,
+  fail,
+  flip,
+  fmap,
+  fst,
+  mempty,
+  notElem,
+  pure,
+  show,
+  traverse,
+  ($),
+  (*>),
+  (.),
+  (<$),
+  (<$>),
+  (<*),
+  (<*>),
+  (<>),
+  (==),
+  (>>=),
  )
 
 {-
@@ -152,6 +192,10 @@
 eof :: (Monad m, Show s) => ParserT s m ()
 eof = reject item
 
+-- | Parse the next symbol without consuming it
+peek :: (Monad m, Show s) => ParserT s m s
+peek = accept item
+
 {-
  - Combinators
  -}
@@ -164,34 +208,30 @@
 sepBy1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
 sepBy1 p sep = (:) <$> p <*> many (sep *> p)
 
--- | Parse zero or more @p@ separated and ended by @q@ via @p \`endBy\` q@
-endBy :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
-endBy p = option [] . endBy1 p
-
--- | Parse one or more @p@ separated and ended by @q@ via @p \`endBy1\` q@
-endBy1 :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
-endBy1 p sep = sepBy1 p sep <* sep
+-- | Parse zero or more @p@ until @q@ succeeds via @p \`till\` q@
+till :: (Monad m, Eq s) => ParserT s m a -> ParserT s m b -> ParserT s m [a]
+till p end = ([] <$ end) <|> ((:) <$> p <*> till p end)
 
--- | Parse one or more @p@ left-chained with @op@ via @chainl1 p op@
+-- | Parse one or more @p@ left-associatively chained by @f@ via @chainl1 p f@
 chainl1
   :: (Monad m, Eq s)
   => ParserT s m a
   -> ParserT s m (a -> a -> a)
   -> ParserT s m a
-chainl1 p op = p >>= go
+chainl1 p f = p >>= go
  where
-  go a = option a $ op <*> pure a <*> p >>= go
+  go a = option a $ f <*> pure a <*> p >>= go
 
--- | Parse one or more @p@ right-chained with @op@ via @chainr1 p op@
+-- | Parse one or more @p@ right-associatively chained by @f@ via @chainr1 p f@
 chainr1
   :: (Monad m, Eq s)
   => ParserT s m a
   -> ParserT s m (a -> a -> a)
   -> ParserT s m a
-chainr1 p op = go
+chainr1 p f = go
  where
   go = p >>= rest
-  rest a = option a $ op <*> pure a <*> go >>= rest
+  rest a = option a $ f <*> pure a <*> go >>= rest
 
 -- | Parse @p@ enclosed by @a@ and @b@ via @between a b p@
 between
diff --git a/Mini/Transformers/ReaderT.hs b/Mini/Transformers/ReaderT.hs
--- a/Mini/Transformers/ReaderT.hs
+++ b/Mini/Transformers/ReaderT.hs
@@ -14,19 +14,29 @@
 ) where
 
 import Control.Applicative (
-  Alternative (
-    empty,
-    (<|>)
-  ),
+  Alternative,
+  empty,
+  (<|>),
  )
 import Control.Monad (
   ap,
   liftM,
  )
 import Mini.Transformers.Class (
-  MonadTrans (
-    lift
-  ),
+  MonadTrans,
+  lift,
+ )
+import Prelude (
+  Applicative,
+  Functor,
+  Monad,
+  const,
+  fmap,
+  pure,
+  ($),
+  (.),
+  (<*>),
+  (>>=),
  )
 
 {-
diff --git a/Mini/Transformers/StateT.hs b/Mini/Transformers/StateT.hs
--- a/Mini/Transformers/StateT.hs
+++ b/Mini/Transformers/StateT.hs
@@ -17,10 +17,9 @@
 ) where
 
 import Control.Applicative (
-  Alternative (
-    empty,
-    (<|>)
-  ),
+  Alternative,
+  empty,
+  (<|>),
  )
 import Control.Monad (
   ap,
@@ -28,9 +27,21 @@
   (>=>),
  )
 import Mini.Transformers.Class (
-  MonadTrans (
-    lift
-  ),
+  MonadTrans,
+  lift,
+ )
+import Prelude (
+  Applicative,
+  Functor,
+  Monad,
+  const,
+  fmap,
+  pure,
+  ($),
+  (.),
+  (<$>),
+  (<*>),
+  (>>=),
  )
 
 {-
diff --git a/Mini/Transformers/WriterT.hs b/Mini/Transformers/WriterT.hs
--- a/Mini/Transformers/WriterT.hs
+++ b/Mini/Transformers/WriterT.hs
@@ -15,19 +15,31 @@
 ) where
 
 import Control.Applicative (
-  Alternative (
-    empty,
-    (<|>)
-  ),
+  Alternative,
+  empty,
+  (<|>),
  )
 import Control.Monad (
   ap,
   liftM,
  )
 import Mini.Transformers.Class (
-  MonadTrans (
-    lift
-  ),
+  MonadTrans,
+  lift,
+ )
+import Prelude (
+  Applicative,
+  Functor,
+  Monad,
+  Monoid,
+  fmap,
+  mempty,
+  pure,
+  ($),
+  (.),
+  (<*>),
+  (<>),
+  (>>=),
  )
 
 {-
diff --git a/mini.cabal b/mini.cabal
--- a/mini.cabal
+++ b/mini.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               mini
-version:            1.3.0.1
+version:            1.4.0.0
 license:            MIT
 license-file:       LICENSE
 copyright:          (c) 2023-2024 Victor Wallsten
@@ -38,6 +38,8 @@
     base == 4.*
   default-language:
     Haskell2010
+  default-extensions:
+    NoImplicitPrelude
   ghc-options:
     -Wall
     -Wcompat
@@ -46,5 +48,6 @@
     -Wincomplete-uni-patterns
     -Wmissing-export-lists
     -Wmissing-home-modules
+    -Wmissing-import-lists
     -Wpartial-fields
     -Wredundant-constraints