diff --git a/Data/ASN1/BER.hs b/Data/ASN1/BER.hs
--- a/Data/ASN1/BER.hs
+++ b/Data/ASN1/BER.hs
@@ -57,9 +57,10 @@
 import qualified Data.ByteString.Lazy as L
 import Data.ByteString (ByteString)
 
-import Data.Enumerator.IO
+import Data.Enumerator.Binary (enumFile)
 import Data.Enumerator (Iteratee(..), Enumeratee, ($$), (>>==))
 import qualified Data.Enumerator as E
+import qualified Data.Enumerator.List as EL
 
 decodeConstruction :: ASN1Header -> ASN1ConstructionType
 decodeConstruction (ASN1Header Universal 0x10 _ _) = Sequence
@@ -72,7 +73,7 @@
 enumReadRawRepr = E.checkDone $ \k -> k (E.Chunks []) >>== loop []
 	where
 		loop l = E.checkDone $ go l
-		go l k = E.head >>= \x -> case x of
+		go l k = EL.head >>= \x -> case x of
 			Nothing -> if l == [] then k (E.Chunks []) >>== return else E.throwError (Raw.ASN1ParsingPartial)
 			Just el -> p l k el
 
@@ -81,7 +82,7 @@
 
 		{- on header with construction, we pop the next element in the enumerator and
 		 - expect a ConstructionBegin. the list context is prepended by the new construction -}
-		p l k el@(Raw.Header hdr@(ASN1Header _ _ True _)) = E.head >>= \z -> case z of
+		p l k el@(Raw.Header hdr@(ASN1Header _ _ True _)) = EL.head >>= \z -> case z of
 			Just el2@Raw.ConstructionBegin ->
 				let ctype = decodeConstruction hdr in
 				k (E.Chunks [(Start ctype, [el,el2])]) >>== loop ((End ctype,[Raw.ConstructionEnd]) : l)
@@ -90,7 +91,7 @@
 
 		{- on header with primtive, we pop the next element in the enumerator and
 		 - expect a Primitive -}
-		p l k el@(Raw.Header hdr@(ASN1Header _ _ False _)) = E.head >>= \z -> case z of
+		p l k el@(Raw.Header hdr@(ASN1Header _ _ False _)) = EL.head >>= \z -> case z of
 			Just el2@(Raw.Primitive prim) ->
 				let (Right pr) = decodePrimitive hdr prim in
 				k (E.Chunks [(pr, [el,el2])]) >>== loop l
@@ -116,7 +117,7 @@
 	E.checkDone $ \k -> k (E.Chunks []) >>== loop
 	where
 		loop = E.checkDone $ go
-		go k = E.head >>= \x -> case x of
+		go k = EL.head >>= \x -> case x of
 			Nothing          -> k (E.Chunks []) >>== return
 			Just n@(Start _) -> consumeTillEnd >>= \y -> k (E.Chunks [(n, y)] ) >>== loop
 			Just p           -> k (E.Chunks [(p, [])] ) >>== loop
@@ -199,29 +200,29 @@
 
 {-| decode a list of raw ASN1Events into a stream of ASN1 types -}
 decodeASN1Events :: [Raw.ASN1Event] -> Either ASN1Err [ASN1]
-decodeASN1Events evs = wrapASN1Err $ runIdentity (iterateEvents evs E.consume)
+decodeASN1Events evs = wrapASN1Err $ runIdentity (iterateEvents evs EL.consume)
 
 {-| decode a list of raw ASN1Events into a stream of ASN1Repr types -}
 decodeASN1EventsRepr :: [Raw.ASN1Event] -> Either ASN1Err [ASN1Repr]
-decodeASN1EventsRepr evs = wrapASN1Err $ runIdentity (iterateEventsRepr evs E.consume)
+decodeASN1EventsRepr evs = wrapASN1Err $ runIdentity (iterateEventsRepr evs EL.consume)
 
 {-| decode a lazy bytestring as an ASN1 stream -}
 decodeASN1Stream :: L.ByteString -> Either ASN1Err [ASN1]
-decodeASN1Stream l = wrapASN1Err $ runIdentity (iterateByteString l E.consume)
+decodeASN1Stream l = wrapASN1Err $ runIdentity (iterateByteString l EL.consume)
 
 {-| decode a lazy bytestring as an ASN1repr stream -}
 decodeASN1StreamRepr :: L.ByteString -> Either ASN1Err [ASN1Repr]
-decodeASN1StreamRepr l = wrapASN1Err $ runIdentity (iterateByteStringRepr l E.consume)
+decodeASN1StreamRepr l = wrapASN1Err $ runIdentity (iterateByteStringRepr l EL.consume)
 
 {-| encode an ASN1 Stream as raw ASN1 Events -}
 encodeASN1Events :: [ASN1] -> Either ASN1Err [Raw.ASN1Event]
 encodeASN1Events o = wrapASN1Err $ runIdentity run
-	where run = E.run (E.enumList 8 o $$ E.joinI $ enumWriteRaw $$ E.consume)
+	where run = E.run (E.enumList 8 o $$ E.joinI $ enumWriteRaw $$ EL.consume)
 
 {-| encode an ASN1 Stream as lazy bytestring -}
 encodeASN1Stream :: [ASN1] -> Either ASN1Err L.ByteString
 encodeASN1Stream l = either Left (Right . L.fromChunks) $ wrapASN1Err $ runIdentity run
-	where run = E.run (E.enumList 1 l $$ E.joinI $ enumWriteBytes $$ E.consume)
+	where run = E.run (E.enumList 1 l $$ E.joinI $ enumWriteBytes $$ EL.consume)
 
 {-# DEPRECATED decodeASN1s "use stream types with decodeASN1Stream" #-}
 decodeASN1s :: L.ByteString -> Either ASN1Err [ASN1t]
diff --git a/Data/ASN1/DER.hs b/Data/ASN1/DER.hs
--- a/Data/ASN1/DER.hs
+++ b/Data/ASN1/DER.hs
@@ -61,8 +61,9 @@
 import Control.Exception
 
 import Data.Enumerator (Iteratee, Enumeratee, ($$), (>>==))
-import Data.Enumerator.IO
+import Data.Enumerator.Binary (enumFile)
 import qualified Data.Enumerator as E
+import qualified Data.Enumerator.List as EL
 
 {- | Check if the length is the minimum possible and it's not indefinite -}
 checkLength :: ASN1Length -> Maybe ASN1Err
@@ -79,7 +80,7 @@
 checkRawDER = E.checkDone $ \k -> k (E.Chunks []) >>== loop
 	where
 		loop = E.checkDone go
-		go k = E.head >>= \x -> case x of
+		go k = EL.head >>= \x -> case x of
 			Nothing -> k (E.Chunks []) >>== return
 			Just l  -> case tyCheck l of
 				Nothing  -> k (E.Chunks [l]) >>== loop
@@ -141,29 +142,29 @@
 
 {-| decode a list of raw ASN1Events into a stream of ASN1 types -}
 decodeASN1Events :: [Raw.ASN1Event] -> Either ASN1Err [ASN1]
-decodeASN1Events evs = wrapASN1Err $ runIdentity (iterateEvents evs E.consume)
+decodeASN1Events evs = wrapASN1Err $ runIdentity (iterateEvents evs EL.consume)
 
 {-| decode a list of raw ASN1Events into a stream of ASN1Repr types -}
 decodeASN1EventsRepr :: [Raw.ASN1Event] -> Either ASN1Err [ASN1Repr]
-decodeASN1EventsRepr evs = wrapASN1Err $ runIdentity (iterateEventsRepr evs E.consume)
+decodeASN1EventsRepr evs = wrapASN1Err $ runIdentity (iterateEventsRepr evs EL.consume)
 
 {-| decode a lazy bytestring as an ASN1 stream -}
 decodeASN1Stream :: L.ByteString -> Either ASN1Err [ASN1]
-decodeASN1Stream l = wrapASN1Err $ runIdentity (iterateByteString l E.consume)
+decodeASN1Stream l = wrapASN1Err $ runIdentity (iterateByteString l EL.consume)
 
 {-| decode a lazy bytestring as an ASN1repr stream -}
 decodeASN1StreamRepr :: L.ByteString -> Either ASN1Err [ASN1Repr]
-decodeASN1StreamRepr l = wrapASN1Err $ runIdentity (iterateByteStringRepr l E.consume)
+decodeASN1StreamRepr l = wrapASN1Err $ runIdentity (iterateByteStringRepr l EL.consume)
 
 {-| encode an ASN1 Stream as raw ASN1 Events -}
 encodeASN1Events :: [ASN1] -> Either ASN1Err [Raw.ASN1Event]
 encodeASN1Events o = wrapASN1Err $ runIdentity run
-	where run = E.run (E.enumList 8 o $$ E.joinI $ enumWriteRaw $$ E.consume)
+	where run = E.run (E.enumList 8 o $$ E.joinI $ enumWriteRaw $$ EL.consume)
 
 {-| encode an ASN1 Stream as lazy bytestring -}
 encodeASN1Stream :: [ASN1] -> Either ASN1Err L.ByteString
 encodeASN1Stream l = either Left (Right . L.fromChunks) $ wrapASN1Err $ runIdentity run
-	where run = E.run (E.enumList 1 l $$ E.joinI $ enumWriteBytes $$ E.consume)
+	where run = E.run (E.enumList 1 l $$ E.joinI $ enumWriteBytes $$ EL.consume)
 
 {-# DEPRECATED decodeASN1s "use stream types with decodeASN1Stream" #-}
 decodeASN1s :: L.ByteString -> Either ASN1Err [ASN1t]
diff --git a/Data/ASN1/Prim.hs b/Data/ASN1/Prim.hs
--- a/Data/ASN1/Prim.hs
+++ b/Data/ASN1/Prim.hs
@@ -125,20 +125,20 @@
 encodePrimitiveData (OID oid)           = putOID oid
 encodePrimitiveData (Real _)            = B.empty -- not implemented
 encodePrimitiveData Enumerated          = B.empty -- not implemented
-encodePrimitiveData (UTF8String b)      = putString $ encodeUtf8 b
+encodePrimitiveData (UTF8String b)      = putString $ encodeUtf8 $ T.pack b
 encodePrimitiveData (NumericString b)   = putString b
-encodePrimitiveData (PrintableString b) = putString $ encodeUtf8 b
-encodePrimitiveData (T61String b)       = putString $ encodeUtf8 b
+encodePrimitiveData (PrintableString b) = putString $ encodeUtf8 $ T.pack b
+encodePrimitiveData (T61String b)       = putString $ encodeUtf8 $ T.pack b
 encodePrimitiveData (VideoTexString b)  = putString b
-encodePrimitiveData (IA5String b)       = putString $ encodeUtf8 b
+encodePrimitiveData (IA5String b)       = putString $ encodeUtf8 $ T.pack b
 encodePrimitiveData (UTCTime t)         = putUTCTime t
 encodePrimitiveData (GeneralizedTime t) = putGeneralizedTime t
 encodePrimitiveData (GraphicString b)   = putString b
 encodePrimitiveData (VisibleString b)   = putString b
 encodePrimitiveData (GeneralString b)   = putString b
-encodePrimitiveData (UniversalString b) = putString $ encodeUtf32BE b
+encodePrimitiveData (UniversalString b) = putString $ encodeUtf32BE $ T.pack b
 encodePrimitiveData (CharacterString b) = putString b
-encodePrimitiveData (BMPString b)       = putString $ encodeUCS2BE b
+encodePrimitiveData (BMPString b)       = putString $ encodeUCS2BE $ T.pack b
 encodePrimitiveData (Other _ _ b)       = b
 encodePrimitiveData o                   = error ("not a primitive " ++ show o)
 
@@ -269,19 +269,19 @@
 getNumericString = either Left (Right . NumericString) . getString (\_ -> Nothing)
 
 getPrintableString :: ByteString -> Either ASN1Err ASN1
-getPrintableString = either Left (Right . PrintableString . decodeASCII) . getString (\_ -> Nothing)
+getPrintableString = either Left (Right . PrintableString . T.unpack . decodeASCII) . getString (\_ -> Nothing)
 
 getUTF8String :: ByteString -> Either ASN1Err ASN1
-getUTF8String = either Left (Right . UTF8String . decodeUtf8) . getString (\_ -> Nothing)
+getUTF8String = either Left (Right . UTF8String . T.unpack . decodeUtf8) . getString (\_ -> Nothing)
 
 getT61String :: ByteString -> Either ASN1Err ASN1
-getT61String = either Left (Right . T61String . decodeASCII) . getString (\_ -> Nothing)
+getT61String = either Left (Right . T61String . T.unpack . decodeASCII) . getString (\_ -> Nothing)
 
 getVideoTexString :: ByteString -> Either ASN1Err ASN1
 getVideoTexString = either Left (Right . VideoTexString) . getString (\_ -> Nothing)
 
 getIA5String :: ByteString -> Either ASN1Err ASN1
-getIA5String = either Left (Right . IA5String . decodeASCII) . getString (\_ -> Nothing)
+getIA5String = either Left (Right . IA5String . T.unpack . decodeASCII) . getString (\_ -> Nothing)
 
 getGraphicString :: ByteString -> Either ASN1Err ASN1
 getGraphicString = either Left (Right . GraphicString) . getString (\_ -> Nothing)
@@ -293,13 +293,13 @@
 getGeneralString = either Left (Right . GeneralString) . getString (\_ -> Nothing)
 
 getUniversalString :: ByteString -> Either ASN1Err ASN1
-getUniversalString = either Left (Right . UniversalString . decodeUtf32BE) . getString (\_ -> Nothing)
+getUniversalString = either Left (Right . UniversalString . T.unpack . decodeUtf32BE) . getString (\_ -> Nothing)
 
 getCharacterString :: ByteString -> Either ASN1Err ASN1
 getCharacterString = either Left (Right . CharacterString) . getString (\_ -> Nothing)
 
 getBMPString :: ByteString -> Either ASN1Err ASN1
-getBMPString = either Left (Right . BMPString . decodeUCS2BE) . getString (\_ -> Nothing)
+getBMPString = either Left (Right . BMPString . T.unpack . decodeUCS2BE) . getString (\_ -> Nothing)
 
 getNull :: ByteString -> Either ASN1Err ASN1
 getNull s = if B.length s == 0 then Right Null else Left $ ASN1Misc "Null: data length not within bound"
diff --git a/Data/ASN1/Raw.hs b/Data/ASN1/Raw.hs
--- a/Data/ASN1/Raw.hs
+++ b/Data/ASN1/Raw.hs
@@ -31,7 +31,8 @@
 
 import Data.Enumerator hiding (head, length, map)
 import qualified Data.Enumerator as E
-import Data.Enumerator.IO
+import qualified Data.Enumerator.List as EL
+import Data.Enumerator.Binary (enumFile)
 import Data.Attoparsec.Enumerator
 import Data.Attoparsec
 import qualified Data.Attoparsec as A
@@ -262,7 +263,7 @@
 	where
 		putEoc    = putHeader $ ASN1Header Universal 0 False (LenShort 0)
 		loop eocs = checkDone $ go eocs
-		go eocs k = E.head >>= \x -> case x of
+		go eocs k = EL.head >>= \x -> case x of
 			Nothing                ->
 				if eocs == [] then k (Chunks []) >>== return else E.throwError ASN1WritingUnexpectedInputEOF
 			Just (Header hdr@(ASN1Header _ _ True len)) ->
@@ -276,6 +277,6 @@
 				False : tl -> k (Chunks []) >>== loop tl
 
 toBytes :: [ASN1Event] -> L.ByteString
-toBytes evs = case runIdentity (run (enumList 8 evs $$ joinI (enumWriteBytes $$ E.consume))) of
+toBytes evs = case runIdentity (run (enumList 8 evs $$ joinI (enumWriteBytes $$ EL.consume))) of
 	Left err -> error $ show err
 	Right l  -> L.fromChunks l
diff --git a/Data/ASN1/Stream.hs b/Data/ASN1/Stream.hs
--- a/Data/ASN1/Stream.hs
+++ b/Data/ASN1/Stream.hs
@@ -7,7 +7,6 @@
 	) where
 
 import Data.ASN1.Raw
-import Data.Text.Lazy (Text)
 import Data.ByteString (ByteString)
 import qualified Data.ByteString.Lazy as L
 
@@ -26,20 +25,20 @@
 	| OID [Integer]
 	| Real Double
 	| Enumerated
-	| UTF8String Text
+	| UTF8String String
 	| NumericString L.ByteString
-	| PrintableString Text
-	| T61String Text
+	| PrintableString String
+	| T61String String
 	| VideoTexString L.ByteString
-	| IA5String Text
+	| IA5String String
 	| UTCTime (Int, Int, Int, Int, Int, Int, Bool)
 	| GeneralizedTime (Int, Int, Int, Int, Int, Int, Bool)
 	| GraphicString L.ByteString
 	| VisibleString L.ByteString
 	| GeneralString L.ByteString
-	| UniversalString Text
+	| UniversalString String
 	| CharacterString L.ByteString
-	| BMPString Text
+	| BMPString String
 	| Other ASN1Class ASN1Tag ByteString
 	| Start ASN1ConstructionType
 	| End ASN1ConstructionType
diff --git a/Data/ASN1/Types.hs b/Data/ASN1/Types.hs
--- a/Data/ASN1/Types.hs
+++ b/Data/ASN1/Types.hs
@@ -7,7 +7,6 @@
 import qualified Data.ASN1.Stream as S
 import qualified Data.ByteString.Lazy as L
 import Data.ByteString (ByteString)
-import Data.Text.Lazy (Text)
 import Data.ASN1.Raw (ASN1Class, ASN1Tag)
 
 data ASN1t =
@@ -19,20 +18,20 @@
 	| OID [Integer]
 	| Real Double
 	| Enumerated
-	| UTF8String Text
+	| UTF8String String
 	| NumericString L.ByteString
-	| PrintableString Text
-	| T61String Text
+	| PrintableString String
+	| T61String String
 	| VideoTexString L.ByteString
-	| IA5String Text
+	| IA5String String
 	| UTCTime (Int, Int, Int, Int, Int, Int, Bool)
 	| GeneralizedTime (Int, Int, Int, Int, Int, Int, Bool)
 	| GraphicString L.ByteString
 	| VisibleString L.ByteString
 	| GeneralString L.ByteString
-	| UniversalString Text
+	| UniversalString String
 	| CharacterString L.ByteString
-	| BMPString Text
+	| BMPString String
 	| Other ASN1Class ASN1Tag ByteString
 	| Sequence [ASN1t]
 	| Set [ASN1t]
diff --git a/Tests.hs b/Tests.hs
--- a/Tests.hs
+++ b/Tests.hs
@@ -14,6 +14,7 @@
 import qualified Data.ByteString.Lazy as L
 import qualified Data.Text.Lazy as T
 import qualified Data.Enumerator as E
+import qualified Data.Enumerator.List as EL
 import Data.Enumerator (($$))
 
 import Control.Monad
@@ -113,11 +114,11 @@
 arbitraryPrintString = do
 	let printableString = (['a'..'z'] ++ ['A'..'Z'] ++ ['0'..'9'] ++ " ()+,-./:=?")
 	x <- replicateM 21 (elements printableString)
-	return $ T.pack x
+	return $ x
 
 arbitraryIA5String = do
 	x <- replicateM 21 (elements $ map toEnum [0..127])
-	return $ T.pack x
+	return $ x
 
 instance Arbitrary ASN1 where
 	arbitrary = oneof
@@ -192,7 +193,7 @@
 
 prop_event_marshalling_id :: ASN1Events -> Bool
 prop_event_marshalling_id (ASN1Events e) =
-	let r = runIdentity $ E.run (E.enumList 1 e $$ E.joinI $ enumWriteReadBytes $$ E.consume) in
+	let r = runIdentity $ E.run (E.enumList 1 e $$ E.joinI $ enumWriteReadBytes $$ EL.consume) in
 	case r of
 		Left _  -> False
 		Right z -> e == z
@@ -201,7 +202,7 @@
 
 prop_asn1_event_marshalling_id :: ASN1 -> Bool
 prop_asn1_event_marshalling_id x =
-	let r = runIdentity $ E.run (E.enumList 1 [x] $$ E.joinI $ enumWriteReadRaw $$ E.consume) in
+	let r = runIdentity $ E.run (E.enumList 1 [x] $$ E.joinI $ enumWriteReadRaw $$ EL.consume) in
 	case r of
 		Left _  -> False
 		Right z -> [x] == z
diff --git a/asn1-data.cabal b/asn1-data.cabal
--- a/asn1-data.cabal
+++ b/asn1-data.cabal
@@ -1,5 +1,5 @@
 Name:                asn1-data
-Version:             0.4.6
+Version:             0.5.0
 Description:
     ASN1 data reader and writer in raw form with supports for high level forms of ASN1 (BER, CER and DER).
     .
@@ -26,7 +26,7 @@
   Build-Depends:     base >= 3 && < 5,
                      bytestring,
                      text >= 0.11,
-                     enumerator >= 0.4 && < 0.5,
+                     enumerator >= 0.4.5 && < 0.5,
                      attoparsec >= 0.8 && < 0.9,
                      attoparsec-enumerator >= 0.2 && < 0.3,
                      mtl