diff --git a/src/Language/Lexer/Tlex/Data/EnumMap.hs b/src/Language/Lexer/Tlex/Data/EnumMap.hs
deleted file mode 100644
--- a/src/Language/Lexer/Tlex/Data/EnumMap.hs
+++ /dev/null
@@ -1,103 +0,0 @@
-module Language.Lexer.Tlex.Data.EnumMap (
-    EnumMap,
-    empty,
-    insert,
-    assocs,
-    keys,
-    toAscList,
-    toDescList,
-    lookup,
-    member,
-    insertOrUpdate,
-    fromList,
-    foldlWithKey',
-    update,
-    delete,
-    singleton,
-    unionWith,
-    intersectionWith,
-    mapWithKey,
-    mergeWithKey,
-) where
-
-import           Prelude            hiding (lookup)
-
-import qualified Data.Coerce        as Coerce
-import qualified Data.IntMap.Strict as IntMap
-
-
-newtype EnumMap k a = EnumMap
-    { unEnumMap :: IntMap.IntMap a
-    }
-    deriving (Eq, Show, Functor)
-
-empty :: Enum k => EnumMap k a
-empty = EnumMap IntMap.empty
-
-singleton :: Enum k => k -> a -> EnumMap k a
-singleton k x = EnumMap do IntMap.singleton (fromEnum k) x
-
-insert :: Enum k => k -> a -> EnumMap k a -> EnumMap k a
-insert k x (EnumMap m) = EnumMap do IntMap.insert (fromEnum k) x m
-
-assocs :: Enum k => EnumMap k a -> [(k, a)]
-assocs (EnumMap m) = [ (toEnum i, x) | (i, x) <- IntMap.assocs m ]
-
-keys :: Enum k => EnumMap k a -> [k]
-keys (EnumMap m) = [ toEnum k | k <- IntMap.keys m ]
-
-toAscList :: Enum k => EnumMap k a -> [(k, a)]
-toAscList (EnumMap m) = [ (toEnum i, x) | (i, x) <- IntMap.toAscList m ]
-
-toDescList :: Enum k => EnumMap k a -> [(k, a)]
-toDescList (EnumMap m) = [ (toEnum i, x) | (i, x) <- IntMap.toDescList m ]
-
-lookup :: Enum k => k -> EnumMap k a -> Maybe a
-lookup k (EnumMap m) = IntMap.lookup (fromEnum k) m
-
-member :: Enum k => k -> EnumMap k a -> Bool
-member k (EnumMap m) = IntMap.member (fromEnum k) m
-
-insertOrUpdate :: Enum k => k -> a -> (a -> a) -> EnumMap k a -> EnumMap k a
-insertOrUpdate k ~dx ~uf (EnumMap m) =
-    let ik = fromEnum k
-    in EnumMap case IntMap.lookup ik m of
-        Nothing -> IntMap.insert ik dx m
-        Just x  -> IntMap.insert ik (uf x) m
-
-fromList :: Enum k => [(k, a)] -> EnumMap k a
-fromList xs = EnumMap do IntMap.fromList [ (fromEnum i, x) | (i, x) <- xs ]
-
-delete :: Enum k => k -> EnumMap k a -> EnumMap k a
-delete k (EnumMap m) = EnumMap do IntMap.delete (fromEnum k) m
-
-foldlWithKey' :: Enum k => (b -> k -> a -> b) -> b -> EnumMap k a -> b
-foldlWithKey' f acc0 (EnumMap m) = IntMap.foldlWithKey' (\acc i x -> f acc (toEnum i) x) acc0 m
-
-update :: Enum k => (a -> Maybe a) -> k -> EnumMap k a -> EnumMap k a
-update f k (EnumMap m) = EnumMap do IntMap.update f (fromEnum k) m
-
-unionWith :: Enum k => (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
-unionWith f (EnumMap m1) (EnumMap m2) = EnumMap do IntMap.unionWith f m1 m2
-
-intersectionWith :: Enum k => (a -> a -> a) -> EnumMap k a -> EnumMap k a -> EnumMap k a
-intersectionWith f (EnumMap m1) (EnumMap m2) = EnumMap do IntMap.intersectionWith f m1 m2
-
-mapWithKey :: Enum k => (k -> a -> b) -> EnumMap k a -> EnumMap k b
-mapWithKey f (EnumMap m) = EnumMap do
-    IntMap.mapWithKey
-        do \i x -> f (toEnum i) x
-        do m
-
-mergeWithKey :: Enum k
-    => (k -> a -> b -> Maybe c)
-    -> (EnumMap k a -> EnumMap k c)
-    -> (EnumMap k b -> EnumMap k c)
-    -> EnumMap k a -> EnumMap k b -> EnumMap k c
-mergeWithKey f g1 g2 (EnumMap m1) (EnumMap m2) = EnumMap do
-    IntMap.mergeWithKey
-        do \i x y -> f (toEnum i) x y
-        do \m -> Coerce.coerce g1 m
-        do \m -> Coerce.coerce g2 m
-        do m1
-        do m2
diff --git a/src/Language/Lexer/Tlex/Data/EnumSet.hs b/src/Language/Lexer/Tlex/Data/EnumSet.hs
deleted file mode 100644
--- a/src/Language/Lexer/Tlex/Data/EnumSet.hs
+++ /dev/null
@@ -1,73 +0,0 @@
-module Language.Lexer.Tlex.Data.EnumSet (
-    EnumSet,
-    empty,
-    singleton,
-    insert,
-    member,
-    union,
-    intersection,
-    difference,
-    partition,
-    fromList,
-    toList,
-    toIntSet,
-) where
-
-import           Language.Lexer.Tlex.Prelude hiding (empty, toList)
-
-import qualified Data.Hashable               as Hashable
-import qualified Data.IntSet                 as IntSet
-
-
-newtype EnumSet a = EnumSet IntSet.IntSet
-    deriving (Eq, Show)
-
-instance Hashable.Hashable (EnumSet a) where
-    hashWithSalt s (EnumSet x) = Hashable.hashWithSalt s do IntSet.toAscList x
-
-instance Enum a => Semigroup (EnumSet a) where
-    (<>) = union
-
-instance Enum a => Monoid (EnumSet a) where
-    mempty = empty
-
-empty :: Enum a => EnumSet a
-empty = EnumSet IntSet.empty
-
-singleton :: Enum a => a -> EnumSet a
-singleton x = EnumSet do IntSet.singleton do fromEnum x
-
-insert :: Enum a => a -> EnumSet a -> EnumSet a
-insert x (EnumSet s) = EnumSet
-    do IntSet.insert
-        do fromEnum x
-        do s
-
-member :: Enum a => a -> EnumSet a -> Bool
-member x (EnumSet s) = IntSet.member
-    do fromEnum x
-    do s
-
-union :: Enum a => EnumSet a -> EnumSet a -> EnumSet a
-union (EnumSet s1) (EnumSet s2) = EnumSet do IntSet.union s1 s2
-
-intersection :: Enum a => EnumSet a -> EnumSet a -> EnumSet a
-intersection (EnumSet s1) (EnumSet s2) = EnumSet do IntSet.intersection s1 s2
-
-difference :: Enum a => EnumSet a -> EnumSet a -> EnumSet a
-difference (EnumSet s1) (EnumSet s2) = EnumSet do IntSet.difference s1 s2
-
-partition :: Enum a => (a -> Bool) -> EnumSet a -> (EnumSet a, EnumSet a)
-partition p (EnumSet s) = coerce
-    do IntSet.partition
-        do \i -> p do toEnum i
-        s
-
-fromList :: Enum a => [a] -> EnumSet a
-fromList xs = EnumSet do IntSet.fromList [ fromEnum x | x <- xs ]
-
-toList :: Enum a => EnumSet a -> [a]
-toList (EnumSet xs) = [ toEnum x | x <- IntSet.toList xs ]
-
-toIntSet :: Enum a => EnumSet a -> IntSet.IntSet
-toIntSet (EnumSet m) = m
diff --git a/src/Language/Lexer/Tlex/Data/SymEnumSet.hs b/src/Language/Lexer/Tlex/Data/SymEnumSet.hs
--- a/src/Language/Lexer/Tlex/Data/SymEnumSet.hs
+++ b/src/Language/Lexer/Tlex/Data/SymEnumSet.hs
@@ -14,7 +14,7 @@
 
 import           Prelude
 
-import qualified Language.Lexer.Tlex.Data.EnumSet as EnumSet
+import qualified Data.EnumSet as EnumSet
 
 
 data SymEnumSet a = SymEnumSet
diff --git a/src/Language/Lexer/Tlex/Machine/DFA.hs b/src/Language/Lexer/Tlex/Machine/DFA.hs
--- a/src/Language/Lexer/Tlex/Machine/DFA.hs
+++ b/src/Language/Lexer/Tlex/Machine/DFA.hs
@@ -12,9 +12,9 @@
 
 import           Language.Lexer.Tlex.Prelude
 
+import qualified Data.EnumMap.Strict                 as EnumMap
 import qualified Data.IntMap                         as IntMap
 import qualified Data.List                           as List
-import qualified Language.Lexer.Tlex.Data.EnumMap    as EnumMap
 import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern
 import qualified Language.Lexer.Tlex.Machine.State   as MState
 
diff --git a/src/Language/Lexer/Tlex/Machine/Pattern.hs b/src/Language/Lexer/Tlex/Machine/Pattern.hs
--- a/src/Language/Lexer/Tlex/Machine/Pattern.hs
+++ b/src/Language/Lexer/Tlex/Machine/Pattern.hs
@@ -13,8 +13,8 @@
 
 import           Language.Lexer.Tlex.Prelude
 
+import qualified Data.EnumSet                        as EnumSet
 import qualified Data.Hashable                       as Hashable
-import qualified Language.Lexer.Tlex.Data.EnumSet    as EnumSet
 import qualified Language.Lexer.Tlex.Data.SymEnumSet as SymEnumSet
 
 
diff --git a/src/Language/Lexer/Tlex/Pipeline/MinDfa.hs b/src/Language/Lexer/Tlex/Pipeline/MinDfa.hs
--- a/src/Language/Lexer/Tlex/Pipeline/MinDfa.hs
+++ b/src/Language/Lexer/Tlex/Pipeline/MinDfa.hs
@@ -4,10 +4,10 @@
 
 import           Language.Lexer.Tlex.Prelude
 
+import qualified Data.EnumMap.Strict                 as EnumMap
 import qualified Data.HashMap.Strict                 as HashMap
 import qualified Data.HashSet                        as HashSet
 import qualified Data.IntMap.Strict                  as IntMap
-import qualified Language.Lexer.Tlex.Data.EnumMap    as EnumMap
 import qualified Language.Lexer.Tlex.Machine.DFA     as DFA
 import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern
 import qualified Language.Lexer.Tlex.Machine.State   as MState
diff --git a/src/Language/Lexer/Tlex/Pipeline/Nfa2Dfa.hs b/src/Language/Lexer/Tlex/Pipeline/Nfa2Dfa.hs
--- a/src/Language/Lexer/Tlex/Pipeline/Nfa2Dfa.hs
+++ b/src/Language/Lexer/Tlex/Pipeline/Nfa2Dfa.hs
@@ -4,10 +4,10 @@
 
 import           Language.Lexer.Tlex.Prelude
 
+import qualified Data.EnumMap.Strict                 as EnumMap
 import qualified Data.HashMap.Strict                 as HashMap
 import qualified Data.IntMap.Strict                  as IntMap
 import qualified Data.IntSet                         as IntSet
-import qualified Language.Lexer.Tlex.Data.EnumMap    as EnumMap
 import qualified Language.Lexer.Tlex.Machine.DFA     as DFA
 import qualified Language.Lexer.Tlex.Machine.NFA     as NFA
 import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern
@@ -132,9 +132,11 @@
                 True ->
                     let ~newTrans = insertNfaSn nfaSn otherTrans0
                         trans1 = IntSet.foldl'
-                            do \trans c -> EnumMap.insertOrUpdate c
-                                do newTrans
-                                do \ss -> insertNfaSn nfaSn ss
+                            do \trans c -> EnumMap.alter
+                                do \case
+                                    Nothing -> Just newTrans
+                                    Just ss -> Just do insertNfaSn nfaSn ss
+                                do c
                                 do trans
                             do trans0
                             do cs
@@ -143,9 +145,11 @@
                     let (diffTrans1, trans1) = IntSet.foldl'
                                                 do \(diffTrans, trans) c ->
                                                     ( EnumMap.delete c diffTrans
-                                                    , EnumMap.insertOrUpdate c
-                                                        MState.emptySet
-                                                        id
+                                                    , EnumMap.alter
+                                                        do \case
+                                                            Nothing -> Just MState.emptySet
+                                                            Just ss -> Just ss
+                                                        c
                                                         trans
                                                     )
                                                 do (trans0, trans0)
diff --git a/src/Language/Lexer/Tlex/Pipeline/Pattern2Nfa.hs b/src/Language/Lexer/Tlex/Pipeline/Pattern2Nfa.hs
--- a/src/Language/Lexer/Tlex/Pipeline/Pattern2Nfa.hs
+++ b/src/Language/Lexer/Tlex/Pipeline/Pattern2Nfa.hs
@@ -4,7 +4,7 @@
 
 import           Language.Lexer.Tlex.Prelude
 
-import qualified Language.Lexer.Tlex.Data.EnumSet    as EnumSet
+import qualified Data.EnumSet                        as EnumSet
 import qualified Language.Lexer.Tlex.Data.SymEnumSet as SymEnumSet
 import qualified Language.Lexer.Tlex.Machine.NFA     as NFA
 import qualified Language.Lexer.Tlex.Machine.Pattern as Pattern
@@ -23,7 +23,7 @@
                 let (isStraight, es) = SymEnumSet.toEnumSet s
                 NFA.NFAStateTrans
                     { NFA.nstTransIsStraight = isStraight
-                    , NFA.nstTransRange = EnumSet.toIntSet es
+                    , NFA.nstTransRange = EnumSet.unEnumSet es
                     , NFA.nstTransNextState = e
                     }
         p1 Pattern.:^: p2 -> do
diff --git a/tlex-core.cabal b/tlex-core.cabal
--- a/tlex-core.cabal
+++ b/tlex-core.cabal
@@ -2,7 +2,7 @@
 build-type:          Custom
 
 name:                tlex-core
-version:             0.2.1.0
+version:             0.3.0.0
 license:             Apache-2.0 OR MPL-2.0
 license-file:        LICENSE
 copyright:           (c) 2021 Mizunashi Mana
@@ -89,14 +89,15 @@
             -dcore-lint
 
     build-depends:
-        base                 >= 4.12.0 && < 4.15,
+        base                 >= 4.12.0  && < 4.15,
 
         -- project depends
-        array                >= 0.5.3 && < 0.6,
-        containers           >= 0.6.0 && < 0.7,
-        hashable             >= 1.3.0 && < 1.4,
-        transformers         >= 0.5.6 && < 0.6,
-        unordered-containers >= 0.2.13 && < 0.3,
+        array                >= 0.5.3   && < 0.6,
+        containers           >= 0.6.0   && < 0.7,
+        hashable             >= 1.3.0   && < 1.4,
+        transformers         >= 0.5.6   && < 0.6,
+        unordered-containers >= 0.2.13  && < 0.3,
+        enummapset-th        >= 0.6.0   && < 0.7,
 
     autogen-modules:
         Paths_tlex_core
@@ -123,8 +124,6 @@
         Language.Lexer.Tlex.Pipeline.Pattern2Nfa
         Language.Lexer.Tlex.Pipeline.Nfa2Dfa
         Language.Lexer.Tlex.Pipeline.MinDfa
-        Language.Lexer.Tlex.Data.EnumSet
-        Language.Lexer.Tlex.Data.EnumMap
         Language.Lexer.Tlex.Data.SymEnumSet
         Language.Lexer.Tlex.Data.Bag