diff --git a/ascii-case.cabal b/ascii-case.cabal
--- a/ascii-case.cabal
+++ b/ascii-case.cabal
@@ -1,11 +1,13 @@
-cabal-version: 2.0
+cabal-version: 3.0
 
 name: ascii-case
-version: 1.0.0.10
+version: 1.0.0.11
 synopsis: ASCII letter case
 category: Data, Text
 
-description: This package defines a @Case@ type that describes the two varieties of ASCII letter: capital and small.
+description:
+    This package defines a @Case@ type that describes the
+    two varieties of ASCII letter: capital and small.
 
 license: Apache-2.0
 license-file: license.txt
@@ -13,42 +15,52 @@
 author: Chris Martin
 maintainer: Chris Martin, Julie Moronuki
 
-homepage:    https://github.com/typeclasses/ascii
+homepage: https://github.com/typeclasses/ascii
 bug-Reports: https://github.com/typeclasses/ascii/issues
 
 build-type: Simple
 
-extra-source-files: changelog.txt
-
 source-repository head
-    type:     git
+    type: git
     location: git://github.com/typeclasses/ascii.git
 
-library
+common base
     default-language: Haskell2010
-    default-extensions: NoImplicitPrelude
-    default-extensions: StandaloneDeriving
-    default-extensions: DerivingStrategies
-    default-extensions: DeriveAnyClass
-    default-extensions: DeriveDataTypeable
-    default-extensions: DeriveGeneric
     ghc-options: -Wall
+
+    default-extensions:
+        NoImplicitPrelude
+
+    build-depends:
+        ascii-char ^>= 1.0
+      , base >= 4.13 && < 4.17
+
+library
+    import: base
     hs-source-dirs: library
 
-    build-depends: ascii-char ^>= 1.0
+    default-extensions:
+        StandaloneDeriving
+        DerivingStrategies
+        DeriveAnyClass
+        DeriveDataTypeable
+        DeriveGeneric
 
-    build-depends: base       >= 4.11 && < 4.17
-    build-depends: hashable   >= 1.2  && < 1.5
+    build-depends:
+        hashable >= 1.3 && < 1.5
 
-    exposed-modules: ASCII.Case
+    exposed-modules:
+        ASCII.Case
 
-test-suite test
+test-suite test-ascii-case
+    import: base
     type: exitcode-stdio-1.0
-    default-language: Haskell2010
-    default-extensions: NoImplicitPrelude
-    default-extensions: OverloadedStrings
-    default-extensions: QuasiQuotes
-    ghc-options: -Wall
     hs-source-dirs: test
-    main-is: test.hs
-    build-depends: ascii-case, ascii-char, base
+    main-is: Main.hs
+
+    default-extensions:
+        OverloadedStrings
+        QuasiQuotes
+
+    build-depends:
+        ascii-case
diff --git a/changelog.txt b/changelog.txt
deleted file mode 100644
--- a/changelog.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-1.0.0.0  - 2020-05-05 - Initial release
-1.0.0.2  - 2020-05-18 - Support GHC 8.10
-1.0.0.4  - 2021-02-10 - Support GHC 9.0
-1.0.0.6  - 2021-09-26 - Add a test suite
-1.0.0.8  - 2021-11-13 - Support hashable 1.4
-1.0.0.10 - 2022-01-09 - Support GHC 9.2
diff --git a/library/ASCII/Case.hs b/library/ASCII/Case.hs
--- a/library/ASCII/Case.hs
+++ b/library/ASCII/Case.hs
@@ -6,20 +6,20 @@
 
 module ASCII.Case ( Case (..), letterCase, isCase, toCase ) where
 
-import ASCII.Char    ( Char (..) )
-import Data.Bool     ( Bool, otherwise )
-import Data.Data     ( Data )
-import Data.Eq       ( Eq )
-import Data.Function ( (.) )
-import Data.Hashable ( Hashable )
-import Data.Ord      ( Ord, (<=), (>=) )
-import GHC.Generics  ( Generic )
-import Prelude       ( Enum, Bounded, Int, (+), (-) )
-import Text.Show     ( Show )
-import Data.Maybe    ( Maybe (..) )
+import ASCII.Char (Char (..))
+import Data.Bool (Bool, otherwise)
+import Data.Data (Data)
+import Data.Eq (Eq)
+import Data.Function ((.))
+import Data.Hashable (Hashable)
+import Data.Maybe (Maybe (..))
+import Data.Ord (Ord, (<=), (>=))
+import GHC.Generics (Generic)
+import Prelude (Bounded, Enum, Int, (+), (-))
+import Text.Show (Show)
 
 import qualified ASCII.Char as Char
-import qualified Data.Bool  as Bool
+import qualified Data.Bool as Bool
 
 data Case =
     UpperCase -- ^ The letters from 'CapitalLetterA' to 'CapitalLetterZ'.
diff --git a/test/Main.hs b/test/Main.hs
new file mode 100644
--- /dev/null
+++ b/test/Main.hs
@@ -0,0 +1,54 @@
+module Main (main) where
+
+import ASCII.Case
+
+import ASCII.Char (Char (..))
+
+import Control.Applicative (Applicative (..))
+import Control.Monad (Monad (..))
+import Data.Bool (Bool (..))
+import Data.Eq (Eq ((==)))
+import Data.Function (($), (.))
+import Data.Functor (Functor (..))
+import Data.List (intercalate, map, null)
+import Data.Maybe (Maybe (..))
+import Data.Semigroup ((<>))
+import Numeric.Natural (Natural)
+import System.Exit (die)
+import System.IO (IO, putStrLn)
+import Text.Show (show)
+
+main :: IO ()
+main = dieIfFailures $ do
+    test 1 $ map letterCase [CapitalLetterR, SmallLetterR, DollarSign] == [Just UpperCase, Just LowerCase,Nothing]
+    test 2 $ map (isCase UpperCase) [CapitalLetterR, SmallLetterR, DollarSign] == [True, False, False]
+    test 3 $ toCase UpperCase SmallLetterX == CapitalLetterX
+    test 4 $ toCase LowerCase CapitalLetterF == SmallLetterF
+    test 5 $ toCase UpperCase CapitalLetterA == CapitalLetterA
+    test 6 $ toCase UpperCase ExclamationMark == ExclamationMark
+
+dieIfFailures :: Failures a -> IO a
+dieIfFailures (Failures fs x) =
+    if null fs
+        then do putStrLn "💯"; return x
+        else die $ intercalate " " (map (("🔥" <> ) . show) fs)
+
+type TestNumber = Natural
+
+test :: TestNumber -> Bool -> Failures ()
+test n t = Failures (if t then [] else [n]) ()
+
+data Failures a = Failures [TestNumber] a
+
+instance Functor Failures
+  where
+    fmap f (Failures a x) = Failures a (f x)
+
+instance Applicative Failures
+  where
+    pure x = Failures [] x
+    Failures a f <*> Failures b x = Failures (a <> b) (f x)
+
+instance Monad Failures
+  where
+    Failures a x >>= f = let Failures b y = f x in Failures (a <> b) y
diff --git a/test/test.hs b/test/test.hs
deleted file mode 100644
--- a/test/test.hs
+++ /dev/null
@@ -1,54 +0,0 @@
-module Main where
-
-import ASCII.Case
-
-import ASCII.Char (Char (..))
-
-import Control.Applicative (Applicative (..))
-import Control.Monad (Monad (..))
-import Data.Bool (Bool (..))
-import Data.Eq (Eq ((==)))
-import Data.Function ((.), ($))
-import Data.Functor (Functor (..))
-import Data.List (intercalate, map, null)
-import Data.Maybe (Maybe (..))
-import Data.Semigroup ((<>))
-import Numeric.Natural (Natural)
-import System.Exit (die)
-import System.IO (IO, putStrLn)
-import Text.Show (show)
-
-main :: IO ()
-main = dieIfFailures $ do
-    test 1 $ map letterCase [CapitalLetterR, SmallLetterR, DollarSign] == [Just UpperCase, Just LowerCase,Nothing]
-    test 2 $ map (isCase UpperCase) [CapitalLetterR, SmallLetterR, DollarSign] == [True, False, False]
-    test 3 $ toCase UpperCase SmallLetterX == CapitalLetterX
-    test 4 $ toCase LowerCase CapitalLetterF == SmallLetterF
-    test 5 $ toCase UpperCase CapitalLetterA == CapitalLetterA
-    test 6 $ toCase UpperCase ExclamationMark == ExclamationMark
-
-dieIfFailures :: Failures a -> IO a
-dieIfFailures (Failures fs x) =
-    if null fs
-        then do putStrLn "💯"; return x
-        else die $ intercalate " " (map (("🔥" <> ) . show) fs)
-
-type TestNumber = Natural
-
-test :: TestNumber -> Bool -> Failures ()
-test n t = Failures (if t then [] else [n]) ()
-
-data Failures a = Failures [TestNumber] a
-
-instance Functor Failures
-  where
-    fmap f (Failures a x) = Failures a (f x)
-
-instance Applicative Failures
-  where
-    pure x = Failures [] x
-    Failures a f <*> Failures b x = Failures (a <> b) (f x)
-
-instance Monad Failures
-  where
-    Failures a x >>= f = let Failures b y = f x in Failures (a <> b) y