    {-
        Copyright 2013-2022 Mario Blazevic

        License: BSD3 (see BSD3-LICENSE.txt file)
    -}

    -- | This module defines the 'ByteStringUTF8' newtype wrapper around 'ByteString', together with its 'TextualMonoid'
    -- instance. The 'FactorialMonoid' instance of a wrapped 'ByteStringUTF8' value differs from the original 'ByteString':
    -- the prime 'factors' of the original value are its bytes, and for the wrapped value the prime 'factors' are its valid
    -- UTF8 byte sequences. The following example session demonstrates the relationship:
    --
    -- >> let utf8@(ByteStringUTF8 bs) = fromString "E=mc\xb2"
    -- >> bs
    -- >"E=mc\194\178"
    -- >> factors bs
    -- >["E","=","m","c","\194","\178"]
    -- >> utf8
    -- >"E=mc²"
    -- >> factors utf8
    -- >["E","=","m","c","²"]
    --
    -- The 'TextualMonoid' instance follows the same logic, but it also decodes all valid UTF8 sequences into
    -- characters. Any invalid UTF8 byte sequence from the original 'ByteString' is preserved as a single prime factor:
    --
    -- >> let utf8'@(ByteStringUTF8 bs') = ByteStringUTF8 (Data.ByteString.map pred bs)
    -- >> bs'
    -- >"D<lb\193\177"
    -- >> factors bs'
    -- >["D","<","l","b","\193","\177"]
    -- >> utf8'
    -- >"D<lb\[193,177]"
    -- >> factors utf8'
    -- >["D","<","l","b","\[193,177]"]

    {-# LANGUAGE Haskell2010, DeriveDataTypeable #-}

    module Data.Monoid.Instances.ByteString.UTF8 (
       ByteStringUTF8(..), decode
       )
    where

    import Control.Exception (assert)
    import Data.Bits ((.&.), (.|.), shiftL, shiftR)
    import Data.Char (chr, ord, isDigit, isPrint)
    import Data.Data (Data, Typeable)
    import qualified Data.Foldable as Foldable
    import qualified Data.List as List
    import Data.Maybe (fromMaybe, isJust, isNothing)
    import Data.String (IsString(fromString))
    import Data.Word (Word8)
    import Data.ByteString (ByteString)
    import qualified Data.ByteString as ByteString
    import qualified Data.ByteString.Char8 as ByteString.Char8
    import Data.ByteString.Internal (w2c)
    import Data.ByteString.Unsafe (unsafeDrop, unsafeHead, unsafeTail, unsafeTake, unsafeIndex)
    import Data.Text (pack, unpack)
    import Data.Text.Encoding (decodeUtf8', encodeUtf8)

    import Data.Semigroup (Semigroup(..))
    import Data.Monoid (Monoid(..))
    import Data.Semigroup.Cancellative (LeftReductive(..), LeftCancellative)
    import Data.Semigroup.Factorial (Factorial(..))
    import Data.Monoid.GCD (LeftGCDMonoid(..))
    import Data.Monoid.Null (MonoidNull(..), PositiveMonoid)
    import Data.Monoid.Factorial (FactorialMonoid(..))
    import Data.Monoid.Textual (TextualMonoid(..))
    import qualified Data.Monoid.Factorial as Factorial (FactorialMonoid(..))
    import qualified Data.Monoid.Textual as Textual (TextualMonoid(..))

    import Prelude hiding (any, drop, dropWhile, foldl, foldl1, foldr, foldr1, scanl, scanr, scanl1, scanr1,
                           map, concatMap, break, span)

    newtype ByteStringUTF8 = ByteStringUTF8 ByteString deriving (Typeable ByteStringUTF8
    Typeable ByteStringUTF8 =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ByteStringUTF8 -> c ByteStringUTF8)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c ByteStringUTF8)
    -> (ByteStringUTF8 -> Constr)
    -> (ByteStringUTF8 -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c ByteStringUTF8))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c ByteStringUTF8))
    -> ((forall b. Data b => b -> b)
        -> ByteStringUTF8 -> ByteStringUTF8)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> ByteStringUTF8 -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ByteStringUTF8 -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> ByteStringUTF8 -> m ByteStringUTF8)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ByteStringUTF8 -> m ByteStringUTF8)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> ByteStringUTF8 -> m ByteStringUTF8)
    -> Data ByteStringUTF8
    ByteStringUTF8 -> Constr
    ByteStringUTF8 -> DataType
    (forall b. Data b => b -> b) -> ByteStringUTF8 -> ByteStringUTF8
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> ByteStringUTF8 -> u
    forall u. (forall d. Data d => d -> u) -> ByteStringUTF8 -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ByteStringUTF8
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ByteStringUTF8 -> c ByteStringUTF8
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ByteStringUTF8)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ByteStringUTF8)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ByteStringUTF8 -> c ByteStringUTF8
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ByteStringUTF8 -> c ByteStringUTF8
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ByteStringUTF8
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ByteStringUTF8
    $ctoConstr :: ByteStringUTF8 -> Constr
    toConstr :: ByteStringUTF8 -> Constr
    $cdataTypeOf :: ByteStringUTF8 -> DataType
    dataTypeOf :: ByteStringUTF8 -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ByteStringUTF8)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ByteStringUTF8)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ByteStringUTF8)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ByteStringUTF8)
    $cgmapT :: (forall b. Data b => b -> b) -> ByteStringUTF8 -> ByteStringUTF8
    gmapT :: (forall b. Data b => b -> b) -> ByteStringUTF8 -> ByteStringUTF8
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteStringUTF8 -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> ByteStringUTF8 -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ByteStringUTF8 -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ByteStringUTF8 -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> ByteStringUTF8 -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ByteStringUTF8 -> m ByteStringUTF8
    Data, ByteStringUTF8 -> ByteStringUTF8 -> Bool
    (ByteStringUTF8 -> ByteStringUTF8 -> Bool)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> Bool) -> Eq ByteStringUTF8
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    == :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    $c/= :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    /= :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    Eq, Eq ByteStringUTF8
    Eq ByteStringUTF8 =>
    (ByteStringUTF8 -> ByteStringUTF8 -> Ordering)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> Bool)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> Bool)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> Bool)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> Bool)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8)
    -> (ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8)
    -> Ord ByteStringUTF8
    ByteStringUTF8 -> ByteStringUTF8 -> Bool
    ByteStringUTF8 -> ByteStringUTF8 -> Ordering
    ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: ByteStringUTF8 -> ByteStringUTF8 -> Ordering
    compare :: ByteStringUTF8 -> ByteStringUTF8 -> Ordering
    $c< :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    < :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    $c<= :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    <= :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    $c> :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    > :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    $c>= :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    >= :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    $cmax :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    max :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    $cmin :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    min :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    Ord, Typeable)

    -- | Takes a raw 'ByteString' chunk and returns a pair of 'ByteStringUTF8' decoding the prefix of the chunk and the
    -- remaining suffix that is either null or contains the incomplete last character of the chunk.
    decode :: ByteString -> (ByteStringUTF8, ByteString)
    decode :: ByteString -> (ByteStringUTF8, ByteString)
    decode ByteString
    bs
       | ByteString -> Bool
    ByteString.null ByteString
    bs Bool -> Bool -> Bool
    || Word8
    l Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs, ByteString
    forall a. Monoid a => a
    mempty)
       | Word8
    l Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xC0 = (ByteString -> ByteStringUTF8
    ByteStringUTF8 (HasCallStack => ByteString -> ByteString
    ByteString -> ByteString
    ByteString.init ByteString
    bs), Word8 -> ByteString
    ByteString.singleton Word8
    l)
       | ByteString -> Bool
    ByteString.null ByteString
    prefix = (ByteStringUTF8
    forall a. Monoid a => a
    mempty, ByteString
    bs)
       | Bool
    otherwise =
          case Word8 -> ByteString -> Maybe (Char, ByteStringUTF8)
    toChar (HasCallStack => ByteString -> Word8
    ByteString -> Word8
    ByteString.last ByteString
    prefix) ByteString
    suffix
          of Maybe (Char, ByteStringUTF8)
    Nothing -> (ByteString -> ByteStringUTF8
    ByteStringUTF8 (HasCallStack => ByteString -> ByteString
    ByteString -> ByteString
    ByteString.init ByteString
    prefix), Int -> ByteString -> ByteString
    forall m. FactorialMonoid m => Int -> m -> m
    drop (ByteString -> Int
    ByteString.length ByteString
    prefix Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) ByteString
    bs)
             Just{} -> (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs, ByteString
    forall a. Monoid a => a
    mempty)
       where (ByteString
    prefix, ByteString
    suffix) = (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
    ByteString.breakEnd Word8 -> Bool
    byteStartsCharacter ByteString
    bs
             l :: Word8
    l = HasCallStack => ByteString -> Word8
    ByteString -> Word8
    ByteString.last ByteString
    bs

    -- | O(n)
    instance Semigroup ByteStringUTF8 where
       ByteStringUTF8 ByteString
    a <> :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    <> ByteStringUTF8 ByteString
    b = ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString
    a ByteString -> ByteString -> ByteString
    forall a. Semigroup a => a -> a -> a
    <> ByteString
    b)
       {-# INLINE (<>) #-}

    -- | O(n)
    instance Monoid ByteStringUTF8 where
       mempty :: ByteStringUTF8
    mempty = ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    ByteString.empty
       {-# INLINE mempty #-}
       mappend :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    mappend = ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    forall a. Semigroup a => a -> a -> a
    (<>)
       {-# INLINE mappend #-}

    -- | O(1)
    instance MonoidNull ByteStringUTF8 where
       null :: ByteStringUTF8 -> Bool
    null (ByteStringUTF8 ByteString
    b) = ByteString -> Bool
    ByteString.null ByteString
    b
       {-# INLINE null #-}

    -- | O(n)
    instance LeftReductive ByteStringUTF8 where
       stripPrefix :: ByteStringUTF8 -> ByteStringUTF8 -> Maybe ByteStringUTF8
    stripPrefix (ByteStringUTF8 ByteString
    a) (ByteStringUTF8 ByteString
    b) = (ByteString -> ByteStringUTF8)
    -> Maybe ByteString -> Maybe ByteStringUTF8
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteString -> Maybe ByteString
    forall m. LeftReductive m => m -> m -> Maybe m
    stripPrefix ByteString
    a ByteString
    b)
       {-# INLINE stripPrefix #-}
       ByteStringUTF8 ByteString
    a isPrefixOf :: ByteStringUTF8 -> ByteStringUTF8 -> Bool
    `isPrefixOf` ByteStringUTF8 ByteString
    b = ByteString
    a ByteString -> ByteString -> Bool
    forall m. LeftReductive m => m -> m -> Bool
    `isPrefixOf` ByteString
    b
       {-# INLINE isPrefixOf #-}

    instance LeftCancellative ByteStringUTF8

    -- | O(prefixLength)
    instance LeftGCDMonoid ByteStringUTF8 where
       commonPrefix :: ByteStringUTF8 -> ByteStringUTF8 -> ByteStringUTF8
    commonPrefix (ByteStringUTF8 ByteString
    a) (ByteStringUTF8 ByteString
    b) = ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteString -> ByteString
    forall m. LeftGCDMonoid m => m -> m -> m
    commonPrefix ByteString
    a ByteString
    b)
       {-# INLINE commonPrefix #-}
       stripCommonPrefix :: ByteStringUTF8
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8, ByteStringUTF8)
    stripCommonPrefix (ByteStringUTF8 ByteString
    a) (ByteStringUTF8 ByteString
    b) = (ByteString, ByteString, ByteString)
    -> (ByteStringUTF8, ByteStringUTF8, ByteStringUTF8)
    wrapTriple (ByteString -> ByteString -> (ByteString, ByteString, ByteString)
    forall m. LeftGCDMonoid m => m -> m -> (m, m, m)
    stripCommonPrefix ByteString
    a ByteString
    b)
       {-# INLINE stripCommonPrefix #-}

    instance Show ByteStringUTF8 where
       showsPrec :: Int -> ByteStringUTF8 -> ShowS
    showsPrec Int
    _ ByteStringUTF8
    bs String
    s0 = Char
    '"' Char -> ShowS
    forall a. a -> [a] -> [a]
    : (ByteStringUTF8 -> ShowS)
    -> (Char -> ShowS) -> String -> ByteStringUTF8 -> String
    forall t a.
    TextualMonoid t =>
    (t -> a -> a) -> (Char -> a -> a) -> a -> t -> a
    forall a.
    (ByteStringUTF8 -> a -> a)
    -> (Char -> a -> a) -> a -> ByteStringUTF8 -> a
    Textual.foldr ByteStringUTF8 -> ShowS
    showsBytes Char -> ShowS
    showsChar (Char
    '"' Char -> ShowS
    forall a. a -> [a] -> [a]
    : String
    s0) ByteStringUTF8
    bs
          where showsBytes :: ByteStringUTF8 -> ShowS
    showsBytes (ByteStringUTF8 ByteString
    b) String
    s = Char
    '\\' Char -> ShowS
    forall a. a -> [a] -> [a]
    : [Word8] -> ShowS
    forall a. Show a => a -> ShowS
    shows (ByteString -> [Word8]
    ByteString.unpack ByteString
    b) String
    s
                showsChar :: Char -> ShowS
    showsChar Char
    c String
    s
                  | Char -> Bool
    isPrint Char
    c = Char
    c Char -> ShowS
    forall a. a -> [a] -> [a]
    : String
    s
                  | Char
    h:String
    _ <- String
    s, Char -> Bool
    isDigit Char
    h = String
    "\\" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show (Char -> Int
    ord Char
    c) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    "\\&" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    s
                  | Bool
    otherwise = String
    "\\" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show (Char -> Int
    ord Char
    c) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    s

    instance IsString ByteStringUTF8 where
       fromString :: String -> ByteStringUTF8
    fromString = ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8)
    -> (String -> ByteString) -> String -> ByteStringUTF8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> ByteString) -> String -> ByteString
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    Foldable.foldMap Char -> ByteString
    fromChar
       {-# INLINE fromString #-}

    instance PositiveMonoid ByteStringUTF8

    instance Factorial ByteStringUTF8 where
       primePrefix :: ByteStringUTF8 -> ByteStringUTF8
    primePrefix utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs)
          | ByteString -> Bool
    ByteString.null ByteString
    bs = ByteStringUTF8
    utf8
          | ByteString -> Word8
    unsafeHead ByteString
    bs Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = ByteString -> ByteStringUTF8
    ByteStringUTF8 (Int -> ByteString -> ByteString
    ByteString.take Int
    1 ByteString
    bs)
          | Bool
    otherwise = case (Word8 -> Bool) -> ByteString -> Maybe Int
    ByteString.findIndex Word8 -> Bool
    byteStartsCharacter (ByteString -> ByteString
    unsafeTail ByteString
    bs)
                        of Just Int
    i -> ByteString -> ByteStringUTF8
    ByteStringUTF8 (Int -> ByteString -> ByteString
    ByteString.take (Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i) ByteString
    bs)
                           Maybe Int
    Nothing -> ByteStringUTF8
    utf8
       {-# INLINABLE primePrefix #-}
       factors :: ByteStringUTF8 -> [ByteStringUTF8]
    factors (ByteStringUTF8 ByteString
    bs) = (ByteString -> ByteStringUTF8) -> [ByteString] -> [ByteStringUTF8]
    forall a b. (a -> b) -> [a] -> [b]
    List.map ByteString -> ByteStringUTF8
    ByteStringUTF8 ([ByteString] -> [ByteStringUTF8])
    -> [ByteString] -> [ByteStringUTF8]
    forall a b. (a -> b) -> a -> b
    $ (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString]
    ByteString.groupBy Word8 -> Word8 -> Bool
    forall {a} {a}. (Ord a, Ord a, Num a, Num a) => a -> a -> Bool
    continued ByteString
    bs
          where continued :: a -> a -> Bool
    continued a
    a a
    b = a
    a a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    >= a
    0x80 Bool -> Bool -> Bool
    && a
    b a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    >= a
    0x80 Bool -> Bool -> Bool
    && a
    b a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0xC0
       {-# INLINABLE factors #-}
       length :: ByteStringUTF8 -> Int
    length (ByteStringUTF8 ByteString
    bs) = (Int, Bool) -> Int
    forall a b. (a, b) -> a
    fst (((Int, Bool) -> Word8 -> (Int, Bool))
    -> (Int, Bool) -> ByteString -> (Int, Bool)
    forall a. (a -> Word8 -> a) -> a -> ByteString -> a
    ByteString.foldl' (Int, Bool) -> Word8 -> (Int, Bool)
    forall {a} {a}.
    (Ord a, Num a, Enum a) =>
    (a, Bool) -> a -> (a, Bool)
    count (Int
    0, Bool
    False) ByteString
    bs)
          where count :: (a, Bool) -> a -> (a, Bool)
    count (a
    n, Bool
    high) a
    byte | a
    byte a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0x80 = (a -> a
    forall a. Enum a => a -> a
    succ a
    n, Bool
    False)
                                     | a
    byte a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0xC0 = (if Bool
    high then a
    n else a -> a
    forall a. Enum a => a -> a
    succ a
    n, Bool
    True)
                                     | Bool
    otherwise = (a -> a
    forall a. Enum a => a -> a
    succ a
    n, Bool
    True)
       {-# INLINABLE length #-}
       foldl :: forall a. (a -> ByteStringUTF8 -> a) -> a -> ByteStringUTF8 -> a
    foldl a -> ByteStringUTF8 -> a
    f a
    a0 (ByteStringUTF8 ByteString
    bs) = (a -> ByteString -> a) -> a -> [ByteString] -> a
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    List.foldl a -> ByteString -> a
    f' a
    a0 (ByteString -> [ByteString]
    groupASCII ByteString
    bs)
          where f' :: a -> ByteString -> a
    f' a
    a ByteString
    b | ByteString -> Word8
    unsafeHead ByteString
    b Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (a -> Word8 -> a) -> a -> ByteString -> a
    forall a. (a -> Word8 -> a) -> a -> ByteString -> a
    ByteString.foldl a -> Word8 -> a
    f'' a
    a ByteString
    b
                       | Bool
    otherwise = a -> ByteStringUTF8 -> a
    f a
    a (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    b)
                f'' :: a -> Word8 -> a
    f'' a
    a Word8
    w = a -> ByteStringUTF8 -> a
    f a
    a (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Word8 -> ByteString
    ByteString.singleton Word8
    w)
       {-# INLINABLE foldl #-}
       foldl' :: forall a. (a -> ByteStringUTF8 -> a) -> a -> ByteStringUTF8 -> a
    foldl' a -> ByteStringUTF8 -> a
    f a
    a0 (ByteStringUTF8 ByteString
    bs) = (a -> ByteString -> a) -> a -> [ByteString] -> a
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    List.foldl' a -> ByteString -> a
    f' a
    a0 (ByteString -> [ByteString]
    groupASCII ByteString
    bs)
          where f' :: a -> ByteString -> a
    f' a
    a ByteString
    b | ByteString -> Word8
    unsafeHead ByteString
    b Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (a -> Word8 -> a) -> a -> ByteString -> a
    forall a. (a -> Word8 -> a) -> a -> ByteString -> a
    ByteString.foldl' a -> Word8 -> a
    f'' a
    a ByteString
    b
                       | Bool
    otherwise = a -> ByteStringUTF8 -> a
    f a
    a (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    b)
                f'' :: a -> Word8 -> a
    f'' a
    a Word8
    w = a -> ByteStringUTF8 -> a
    f a
    a (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Word8 -> ByteString
    ByteString.singleton Word8
    w)
       {-# INLINABLE foldl' #-}
       foldr :: forall a. (ByteStringUTF8 -> a -> a) -> a -> ByteStringUTF8 -> a
    foldr ByteStringUTF8 -> a -> a
    f a
    a0 (ByteStringUTF8 ByteString
    bs) = (ByteString -> a -> a) -> a -> [ByteString] -> a
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    List.foldr ByteString -> a -> a
    f' a
    a0 (ByteString -> [ByteString]
    groupASCII ByteString
    bs)
          where f' :: ByteString -> a -> a
    f' ByteString
    b a
    a | ByteString -> Word8
    unsafeHead ByteString
    b Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (Word8 -> a -> a) -> a -> ByteString -> a
    forall a. (Word8 -> a -> a) -> a -> ByteString -> a
    ByteString.foldr Word8 -> a -> a
    f'' a
    a ByteString
    b
                       | Bool
    otherwise = ByteStringUTF8 -> a -> a
    f (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    b) a
    a
                f'' :: Word8 -> a -> a
    f'' Word8
    w a
    a = ByteStringUTF8 -> a -> a
    f (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Word8 -> ByteString
    ByteString.singleton Word8
    w) a
    a
       {-# INLINABLE foldr #-}
       reverse :: ByteStringUTF8 -> ByteStringUTF8
    reverse (ByteStringUTF8 ByteString
    bs) =
          ByteString -> ByteStringUTF8
    ByteStringUTF8 ([ByteString] -> ByteString
    ByteString.concat ([ByteString] -> ByteString) -> [ByteString] -> ByteString
    forall a b. (a -> b) -> a -> b
    $ [ByteString] -> [ByteString]
    forall a. [a] -> [a]
    List.reverse ([ByteString] -> [ByteString]) -> [ByteString] -> [ByteString]
    forall a b. (a -> b) -> a -> b
    $ (ByteString -> ByteString) -> [ByteString] -> [ByteString]
    forall a b. (a -> b) -> [a] -> [b]
    List.map ByteString -> ByteString
    reverseASCII ([ByteString] -> [ByteString]) -> [ByteString] -> [ByteString]
    forall a b. (a -> b) -> a -> b
    $ ByteString -> [ByteString]
    groupASCII ByteString
    bs)
          where reverseASCII :: ByteString -> ByteString
    reverseASCII ByteString
    b | ByteString -> Word8
    unsafeHead ByteString
    b Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = ByteString -> ByteString
    ByteString.reverse ByteString
    b
                               | Bool
    otherwise = ByteString
    b
       {-# INLINABLE reverse #-}

    instance FactorialMonoid ByteStringUTF8 where
       splitPrimePrefix :: ByteStringUTF8 -> Maybe (ByteStringUTF8, ByteStringUTF8)
    splitPrimePrefix utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs)
          | ByteString -> Bool
    ByteString.null ByteString
    bs = Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. Maybe a
    Nothing
          | ByteString -> Word8
    unsafeHead ByteString
    bs Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (ByteStringUTF8, ByteStringUTF8)
    -> Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. a -> Maybe a
    Just ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8))
    -> (ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt Int
    1 ByteString
    bs)
          | Bool
    otherwise = case (Word8 -> Bool) -> ByteString -> Maybe Int
    ByteString.findIndex Word8 -> Bool
    byteStartsCharacter (ByteString -> ByteString
    unsafeTail ByteString
    bs)
                        of Just Int
    i -> (ByteStringUTF8, ByteStringUTF8)
    -> Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. a -> Maybe a
    Just ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8))
    -> (ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt (Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i) ByteString
    bs)
                           Maybe Int
    Nothing -> (ByteStringUTF8, ByteStringUTF8)
    -> Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. a -> Maybe a
    Just (ByteStringUTF8
    utf8, ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ ByteString
    ByteString.empty)
       {-# INLINABLE splitPrimePrefix #-}
       splitPrimeSuffix :: ByteStringUTF8 -> Maybe (ByteStringUTF8, ByteStringUTF8)
    splitPrimeSuffix (ByteStringUTF8 ByteString
    bs)
          | ByteString -> Bool
    ByteString.null ByteString
    bs = Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. Maybe a
    Nothing
          | ByteString -> Bool
    ByteString.null ByteString
    prefix = (ByteStringUTF8, ByteStringUTF8)
    -> Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. a -> Maybe a
    Just ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair (ByteString, ByteString)
    splitBS)
          | Bool -> Bool
    not (ByteString -> Bool
    ByteString.null ByteString
    suffix) Bool -> Bool -> Bool
    && HasCallStack => ByteString -> Word8
    ByteString -> Word8
    ByteString.last ByteString
    prefix Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (ByteStringUTF8, ByteStringUTF8)
    -> Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. a -> Maybe a
    Just ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair (ByteString, ByteString)
    splitBS)
          | Bool
    otherwise = (ByteStringUTF8, ByteStringUTF8)
    -> Maybe (ByteStringUTF8, ByteStringUTF8)
    forall a. a -> Maybe a
    Just ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair ((ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8))
    -> (ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt (Int -> Int
    forall a. Enum a => a -> a
    pred (Int -> Int) -> Int -> Int
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    ByteString.length ByteString
    prefix) ByteString
    bs)
          where splitBS :: (ByteString, ByteString)
    splitBS@(ByteString
    prefix, ByteString
    suffix) = (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
    ByteString.breakEnd Word8 -> Bool
    byteStartsCharacter ByteString
    bs
       {-# INLINABLE splitPrimeSuffix #-}
       splitAt :: Int -> ByteStringUTF8 -> (ByteStringUTF8, ByteStringUTF8)
    splitAt Int
    n (ByteStringUTF8 ByteString
    bs) = (ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair (Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt (Int -> ByteString -> Int
    charStartIndex Int
    n ByteString
    bs) ByteString
    bs)
       {-# INLINE splitAt #-}
       take :: Int -> ByteStringUTF8 -> ByteStringUTF8
    take Int
    n (ByteStringUTF8 ByteString
    bs) = ByteString -> ByteStringUTF8
    ByteStringUTF8 (Int -> ByteString -> ByteString
    ByteString.take (Int -> ByteString -> Int
    charStartIndex Int
    n ByteString
    bs) ByteString
    bs)
       {-# INLINE take #-}
       drop :: Int -> ByteStringUTF8 -> ByteStringUTF8
    drop Int
    n (ByteStringUTF8 ByteString
    bs) = ByteString -> ByteStringUTF8
    ByteStringUTF8 (Int -> ByteString -> ByteString
    ByteString.drop (Int -> ByteString -> Int
    charStartIndex Int
    n ByteString
    bs) ByteString
    bs)
       {-# INLINE drop #-}
       dropWhile :: (ByteStringUTF8 -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    dropWhile ByteStringUTF8 -> Bool
    p (ByteStringUTF8 ByteString
    bs0) = ByteString -> ByteStringUTF8
    dropASCII ByteString
    bs0
          where dropASCII :: ByteString -> ByteStringUTF8
    dropASCII ByteString
    bs =
                   let suffix :: ByteString
    suffix = (Word8 -> Bool) -> ByteString -> ByteString
    ByteString.dropWhile (\Word8
    w-> Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 Bool -> Bool -> Bool
    && ByteStringUTF8 -> Bool
    p (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Word8 -> ByteString
    ByteString.singleton Word8
    w)) ByteString
    bs
                   in if ByteString -> Bool
    ByteString.null ByteString
    suffix Bool -> Bool -> Bool
    || ByteString -> Word8
    unsafeHead ByteString
    suffix Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80
                      then ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    suffix
                      else ByteString -> ByteStringUTF8
    dropMultiByte ByteString
    suffix
                dropMultiByte :: ByteString -> ByteStringUTF8
    dropMultiByte ByteString
    bs =
                   let utf8 :: ByteStringUTF8
    utf8 = ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs
                   in case (Word8 -> Bool) -> ByteString -> Maybe Int
    ByteString.findIndex Word8 -> Bool
    byteStartsCharacter (ByteString -> ByteString
    unsafeTail ByteString
    bs)
                      of Maybe Int
    Nothing -> if ByteStringUTF8 -> Bool
    p ByteStringUTF8
    utf8 then ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    ByteString.empty else ByteStringUTF8
    utf8
                         Just Int
    i -> let (ByteString
    hd, ByteString
    tl) = Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt (Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i) ByteString
    bs
                                   in if ByteStringUTF8 -> Bool
    p (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    hd)
                                      then ByteString -> ByteStringUTF8
    dropASCII ByteString
    tl
                                      else ByteStringUTF8
    utf8
       {-# INLINE dropWhile #-}
       takeWhile :: (ByteStringUTF8 -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    takeWhile ByteStringUTF8 -> Bool
    p utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs) =
          ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    ByteString.take (ByteString -> Int
    ByteString.length ByteString
    bs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    s) ByteString
    bs
          where (ByteStringUTF8 ByteString
    s) = (ByteStringUTF8 -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    forall m. FactorialMonoid m => (m -> Bool) -> m -> m
    Factorial.dropWhile ByteStringUTF8 -> Bool
    p ByteStringUTF8
    utf8
       {-# INLINE takeWhile #-}
       span :: (ByteStringUTF8 -> Bool)
    -> ByteStringUTF8 -> (ByteStringUTF8, ByteStringUTF8)
    span ByteStringUTF8 -> Bool
    p utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs) =
          (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    ByteString.take (ByteString -> Int
    ByteString.length ByteString
    bs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    s) ByteString
    bs, ByteStringUTF8
    suffix)
          where suffix :: ByteStringUTF8
    suffix@(ByteStringUTF8 ByteString
    s) = (ByteStringUTF8 -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    forall m. FactorialMonoid m => (m -> Bool) -> m -> m
    Factorial.dropWhile ByteStringUTF8 -> Bool
    p ByteStringUTF8
    utf8
       {-# INLINE span #-}
       break :: (ByteStringUTF8 -> Bool)
    -> ByteStringUTF8 -> (ByteStringUTF8, ByteStringUTF8)
    break ByteStringUTF8 -> Bool
    p = (ByteStringUTF8 -> Bool)
    -> ByteStringUTF8 -> (ByteStringUTF8, ByteStringUTF8)
    forall m. FactorialMonoid m => (m -> Bool) -> m -> (m, m)
    Factorial.span (Bool -> Bool
    not (Bool -> Bool)
    -> (ByteStringUTF8 -> Bool) -> ByteStringUTF8 -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteStringUTF8 -> Bool
    p)
       {-# INLINE break #-}
       spanMaybe :: forall s.
    s
    -> (s -> ByteStringUTF8 -> Maybe s)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8, s)
    spanMaybe s
    s0 s -> ByteStringUTF8 -> Maybe s
    f (ByteStringUTF8 ByteString
    bs0) = (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    ByteString.take (ByteString -> Int
    ByteString.length ByteString
    bs0 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    dropped) ByteString
    bs0,
                                              ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    dropped,
                                              s
    s')
          where (ByteString
    dropped, s
    s') = s -> ByteString -> (ByteString, s)
    dropASCII s
    s0 ByteString
    bs0
                dropASCII :: s -> ByteString -> (ByteString, s)
    dropASCII s
    s ByteString
    bs =
                   let suffix :: ByteString
    suffix = Int -> ByteString -> ByteString
    ByteString.drop Int
    index ByteString
    bs
                       (Int
    index, s
    s1) = (Word8 -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s))
    -> ((Int, s) -> (Int, s)) -> ByteString -> (Int, s) -> (Int, s)
    forall a. (Word8 -> a -> a) -> a -> ByteString -> a
    ByteString.foldr Word8 -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    f8 (Int, s) -> (Int, s)
    forall a. a -> a
    id ByteString
    bs (Int
    0, s
    s)
                       f8 :: Word8 -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    f8 Word8
    w (Int, s) -> (Int, s)
    cont (Int
    i, s
    s2)
                         | Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80, Just s
    s3 <- s -> ByteStringUTF8 -> Maybe s
    f s
    s2 (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Word8 -> ByteString
    ByteString.singleton Word8
    w) =
                             let i' :: Int
    i' = Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i :: Int in Int -> (Int, s) -> (Int, s)
    forall a b. a -> b -> b
    seq Int
    i' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    forall a b. (a -> b) -> a -> b
    $ (Int, s) -> (Int, s)
    cont (Int
    i', s
    s3)
                         | Bool
    otherwise = (Int
    i, s
    s2)
                   in if ByteString -> Bool
    ByteString.null ByteString
    suffix Bool -> Bool -> Bool
    || ByteString -> Word8
    unsafeHead ByteString
    suffix Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80
                      then (ByteString
    suffix, s
    s1)
                      else s -> ByteString -> (ByteString, s)
    dropMultiByte s
    s1 ByteString
    suffix
                dropMultiByte :: s -> ByteString -> (ByteString, s)
    dropMultiByte s
    s ByteString
    bs =
                   case (Word8 -> Bool) -> ByteString -> Maybe Int
    ByteString.findIndex Word8 -> Bool
    byteStartsCharacter (ByteString -> ByteString
    unsafeTail ByteString
    bs)
                   of Maybe Int
    Nothing -> case s -> ByteStringUTF8 -> Maybe s
    f s
    s (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs)
                                 of Just s
    s1 -> (ByteString
    ByteString.empty, s
    s1)
                                    Maybe s
    Nothing -> (ByteString
    bs, s
    s)
                      Just Int
    i -> let (ByteString
    hd, ByteString
    tl) = Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt (Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i) ByteString
    bs
                                in case s -> ByteStringUTF8 -> Maybe s
    f s
    s (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    hd)
                                   of Just s
    s1 -> s -> ByteString -> (ByteString, s)
    dropASCII s
    s1 ByteString
    tl
                                      Maybe s
    Nothing -> (ByteString
    bs, s
    s)
       {-# INLINE spanMaybe #-}
       spanMaybe' :: forall s.
    s
    -> (s -> ByteStringUTF8 -> Maybe s)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8, s)
    spanMaybe' s
    s0 s -> ByteStringUTF8 -> Maybe s
    f (ByteStringUTF8 ByteString
    bs0) = (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $
                                               Int -> ByteString -> ByteString
    ByteString.take (ByteString -> Int
    ByteString.length ByteString
    bs0 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    dropped) ByteString
    bs0,
                                               ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    dropped,
                                               s
    s')
          where (ByteString
    dropped, s
    s') = s -> ByteString -> (ByteString, s)
    dropASCII s
    s0 ByteString
    bs0
                dropASCII :: s -> ByteString -> (ByteString, s)
    dropASCII s
    s ByteString
    bs =
                   let suffix :: ByteString
    suffix = Int -> ByteString -> ByteString
    ByteString.drop Int
    index ByteString
    bs
                       (Int
    index, s
    s1) = (Word8 -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s))
    -> ((Int, s) -> (Int, s)) -> ByteString -> (Int, s) -> (Int, s)
    forall a. (Word8 -> a -> a) -> a -> ByteString -> a
    ByteString.foldr Word8 -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    f8 (Int, s) -> (Int, s)
    forall a. a -> a
    id ByteString
    bs (Int
    0, s
    s)
                       f8 :: Word8 -> ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    f8 Word8
    w (Int, s) -> (Int, s)
    cont (Int
    i, s
    s2)
                         | Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80, Just s
    s3 <- s -> ByteStringUTF8 -> Maybe s
    f s
    s2 (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Word8 -> ByteString
    ByteString.singleton Word8
    w) =
                             let i' :: Int
    i' = Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i :: Int in Int -> (Int, s) -> (Int, s)
    forall a b. a -> b -> b
    seq Int
    i' ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    forall a b. (a -> b) -> a -> b
    $ s -> (Int, s) -> (Int, s)
    forall a b. a -> b -> b
    seq s
    s3 ((Int, s) -> (Int, s)) -> (Int, s) -> (Int, s)
    forall a b. (a -> b) -> a -> b
    $ (Int, s) -> (Int, s)
    cont (Int
    i', s
    s3)
                         | Bool
    otherwise = (Int
    i, s
    s)
                   in if ByteString -> Bool
    ByteString.null ByteString
    suffix Bool -> Bool -> Bool
    || ByteString -> Word8
    unsafeHead ByteString
    suffix Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80
                      then (ByteString
    suffix, s
    s1)
                      else s -> ByteString -> (ByteString, s)
    dropMultiByte s
    s1 ByteString
    suffix
                dropMultiByte :: s -> ByteString -> (ByteString, s)
    dropMultiByte s
    s ByteString
    bs =
                   case (Word8 -> Bool) -> ByteString -> Maybe Int
    ByteString.findIndex Word8 -> Bool
    byteStartsCharacter (ByteString -> ByteString
    unsafeTail ByteString
    bs)
                   of Maybe Int
    Nothing -> case s -> ByteStringUTF8 -> Maybe s
    f s
    s (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs)
                                 of Just s
    s1 -> s -> (ByteString, s) -> (ByteString, s)
    forall a b. a -> b -> b
    seq s
    s1 (ByteString
    ByteString.empty, s
    s1)
                                    Maybe s
    Nothing -> (ByteString
    bs, s
    s)
                      Just Int
    i -> let (ByteString
    hd, ByteString
    tl) = Int -> ByteString -> (ByteString, ByteString)
    ByteString.splitAt (Int -> Int
    forall a. Enum a => a -> a
    succ Int
    i) ByteString
    bs
                                in case s -> ByteStringUTF8 -> Maybe s
    f s
    s (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    hd)
                                   of Just s
    s1 -> s -> (ByteString, s) -> (ByteString, s)
    forall a b. a -> b -> b
    seq s
    s1 (s -> ByteString -> (ByteString, s)
    dropASCII s
    s1 ByteString
    tl)
                                      Maybe s
    Nothing -> (ByteString
    bs, s
    s)
       {-# INLINE spanMaybe' #-}

    instance TextualMonoid ByteStringUTF8 where
       singleton :: Char -> ByteStringUTF8
    singleton = ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8)
    -> (Char -> ByteString) -> Char -> ByteStringUTF8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> ByteString
    fromChar
       {-# INLINE singleton #-}
       splitCharacterPrefix :: ByteStringUTF8 -> Maybe (Char, ByteStringUTF8)
    splitCharacterPrefix (ByteStringUTF8 ByteString
    bs) = ByteString -> Maybe (Word8, ByteString)
    ByteString.uncons ByteString
    bs Maybe (Word8, ByteString)
    -> ((Word8, ByteString) -> Maybe (Char, ByteStringUTF8))
    -> Maybe (Char, ByteStringUTF8)
    forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Word8 -> ByteString -> Maybe (Char, ByteStringUTF8))
    -> (Word8, ByteString) -> Maybe (Char, ByteStringUTF8)
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Word8 -> ByteString -> Maybe (Char, ByteStringUTF8)
    toChar
       {-# INLINE splitCharacterPrefix #-}
       foldl :: forall a.
    (a -> ByteStringUTF8 -> a)
    -> (a -> Char -> a) -> a -> ByteStringUTF8 -> a
    foldl a -> ByteStringUTF8 -> a
    ft a -> Char -> a
    fc a
    a0 (ByteStringUTF8 ByteString
    bs) = case ((a, [Word8]) -> Char -> (a, [Word8]))
    -> (a, [Word8]) -> ByteString -> (a, [Word8])
    forall a. (a -> Char -> a) -> a -> ByteString -> a
    ByteString.Char8.foldl (a, [Word8]) -> Char -> (a, [Word8])
    f (a
    a0, []) ByteString
    bs
                                            of (a
    a, []) -> a
    a
                                               (a
    a, [Word8]
    acc) -> a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc
          where f :: (a, [Word8]) -> Char -> (a, [Word8])
    f (a
    a, []) Char
    c | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = (a -> Char -> a
    fc a
    a Char
    c, [])
                            | Bool
    otherwise = (a
    a, [Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    ord Char
    c])
                f (a
    a, [Word8]
    acc) Char
    c | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = (a -> Char -> a
    fc (a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc) Char
    c, [])
                             | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\xC0' = (a
    a, Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Char -> Int
    ord Char
    c) Word8 -> [Word8] -> [Word8]
    forall a. a -> [a] -> [a]
    : [Word8]
    acc)
                             | Bool
    otherwise = (a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc, [Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    ord Char
    c])
                multiByte :: a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc = (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    forall a. (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    reverseBytesToChar (a -> ByteStringUTF8 -> a
    ft a
    a (ByteStringUTF8 -> a)
    -> (ByteString -> ByteStringUTF8) -> ByteString -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteStringUTF8
    ByteStringUTF8) (a -> Char -> a
    fc a
    a) [Word8]
    acc
       {-# INLINE foldl #-}
       foldl' :: forall a.
    (a -> ByteStringUTF8 -> a)
    -> (a -> Char -> a) -> a -> ByteStringUTF8 -> a
    foldl' a -> ByteStringUTF8 -> a
    ft a -> Char -> a
    fc a
    a0 (ByteStringUTF8 ByteString
    bs) = case ((a, [Word8]) -> Char -> (a, [Word8]))
    -> (a, [Word8]) -> ByteString -> (a, [Word8])
    forall a. (a -> Char -> a) -> a -> ByteString -> a
    ByteString.Char8.foldl' (a, [Word8]) -> Char -> (a, [Word8])
    f (a
    a0, []) ByteString
    bs
                                             of (a
    a, []) -> a
    a
                                                (a
    a, [Word8]
    acc) -> a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc
          where f :: (a, [Word8]) -> Char -> (a, [Word8])
    f (a
    a, []) Char
    c | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = (a -> Char -> a
    fc a
    a Char
    c, [])
                            | Bool
    otherwise = a -> (a, [Word8]) -> (a, [Word8])
    forall a b. a -> b -> b
    seq a
    a (a
    a, [Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    ord Char
    c])
                f (a
    a, [Word8]
    acc) Char
    c | a -> Char -> Char
    forall a b. a -> b -> b
    seq a
    a Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = let a' :: a
    a' = a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc in a -> (a, [Word8]) -> (a, [Word8])
    forall a b. a -> b -> b
    seq a
    a' (a -> Char -> a
    fc a
    a' Char
    c, [])
                             | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\xC0' = (a
    a, Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Char -> Int
    ord Char
    c) Word8 -> [Word8] -> [Word8]
    forall a. a -> [a] -> [a]
    : [Word8]
    acc)
                             | Bool
    otherwise = let a' :: a
    a' = a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc in a -> (a, [Word8]) -> (a, [Word8])
    forall a b. a -> b -> b
    seq a
    a' (a
    a', [Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    ord Char
    c])
                multiByte :: a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc = (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    forall a. (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    reverseBytesToChar (a -> ByteStringUTF8 -> a
    ft a
    a (ByteStringUTF8 -> a)
    -> (ByteString -> ByteStringUTF8) -> ByteString -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteStringUTF8
    ByteStringUTF8) (a -> Char -> a
    fc a
    a) [Word8]
    acc
       {-# INLINE foldl' #-}
       foldr :: forall a.
    (ByteStringUTF8 -> a -> a)
    -> (Char -> a -> a) -> a -> ByteStringUTF8 -> a
    foldr ByteStringUTF8 -> a -> a
    ft Char -> a -> a
    fc a
    a0 (ByteStringUTF8 ByteString
    bs) = case (Char -> (a, [Word8]) -> (a, [Word8]))
    -> (a, [Word8]) -> ByteString -> (a, [Word8])
    forall a. (Char -> a -> a) -> a -> ByteString -> a
    ByteString.Char8.foldr Char -> (a, [Word8]) -> (a, [Word8])
    f (a
    a0, []) ByteString
    bs
                                            of (a
    a, []) -> a
    a
                                               (a
    a, [Word8]
    acc) -> a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc
          where f :: Char -> (a, [Word8]) -> (a, [Word8])
    f Char
    c (a
    a, []) | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = (Char -> a -> a
    fc Char
    c a
    a, [])
                            | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\xC0' = (a
    a, [Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    ord Char
    c])
                            | Bool
    otherwise = (ByteStringUTF8 -> a -> a
    ft (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Char -> ByteString
    ByteString.Char8.singleton Char
    c) a
    a, [])
                f Char
    c (a
    a, [Word8]
    acc) | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = (Char -> a -> a
    fc Char
    c (ByteStringUTF8 -> a -> a
    ft (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ [Word8] -> ByteString
    ByteString.pack [Word8]
    acc) a
    a), [])
                             | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\xC0' = (a
    a, Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Char -> Int
    ord Char
    c) Word8 -> [Word8] -> [Word8]
    forall a. a -> [a] -> [a]
    : [Word8]
    acc)
                             | Bool
    otherwise = (a -> [Word8] -> a
    multiByte a
    a (Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Char -> Int
    ord Char
    c) Word8 -> [Word8] -> [Word8]
    forall a. a -> [a] -> [a]
    : [Word8]
    acc), [])
                multiByte :: a -> [Word8] -> a
    multiByte a
    a [Word8]
    acc = (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    forall a. (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    bytesToChar ((ByteStringUTF8 -> a -> a
    `ft` a
    a) (ByteStringUTF8 -> a)
    -> (ByteString -> ByteStringUTF8) -> ByteString -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteStringUTF8
    ByteStringUTF8) (Char -> a -> a
    `fc` a
    a) [Word8]
    acc
       {-# INLINE foldr #-}
       dropWhile :: (ByteStringUTF8 -> Bool)
    -> (Char -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    dropWhile ByteStringUTF8 -> Bool
    pb Char -> Bool
    pc (ByteStringUTF8 ByteString
    bs) = ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ ByteString -> ByteString
    dropASCII ByteString
    bs
          where dropASCII :: ByteString -> ByteString
    dropASCII ByteString
    rest = case (Char -> Bool) -> ByteString -> Maybe Int
    ByteString.Char8.findIndex (\Char
    c-> Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    > Char
    '\x7f' Bool -> Bool -> Bool
    || Bool -> Bool
    not (Char -> Bool
    pc Char
    c)) ByteString
    rest
                                 of Maybe Int
    Nothing -> ByteString
    ByteString.empty
                                    Just Int
    j -> let rest' :: ByteString
    rest' = Int -> ByteString -> ByteString
    unsafeDrop Int
    j ByteString
    rest
                                              in if ByteString -> Word8
    unsafeHead ByteString
    rest' Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Word8
    0x7f
                                                 then ByteString -> ByteString
    dropMultiByte ByteString
    rest'
                                                 else ByteString
    rest'
                dropMultiByte :: ByteString -> ByteString
    dropMultiByte ByteString
    rest = case ByteStringUTF8 -> Maybe (Char, ByteStringUTF8)
    forall t. TextualMonoid t => t -> Maybe (Char, t)
    splitCharacterPrefix (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    rest)
                                     of Just (Char
    c, ByteStringUTF8 ByteString
    rest') | Char -> Bool
    pc Char
    c -> ByteString -> ByteString
    dropASCII ByteString
    rest'
                                        Maybe (Char, ByteStringUTF8)
    Nothing -> let j :: Int
    j = Int -> Int
    forall a. Enum a => a -> a
    succ (ByteString -> Int
    headIndex (ByteString -> Int) -> ByteString -> Int
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    forall m. FactorialMonoid m => Int -> m -> m
    drop Int
    1 ByteString
    rest)
                                                   in if ByteStringUTF8 -> Bool
    pb (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    ByteString.take Int
    j ByteString
    rest)
                                                      then ByteString -> ByteString
    dropASCII (Int -> ByteString -> ByteString
    unsafeDrop Int
    j ByteString
    rest)
                                                      else ByteString
    rest
                                        Maybe (Char, ByteStringUTF8)
    _ -> ByteString
    rest
       {-# INLINE dropWhile #-}
       takeWhile :: (ByteStringUTF8 -> Bool)
    -> (Char -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    takeWhile ByteStringUTF8 -> Bool
    pb Char -> Bool
    pc utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs) =
          ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeTake (ByteString -> Int
    ByteString.length ByteString
    bs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    suffix) ByteString
    bs
          where ByteStringUTF8 ByteString
    suffix = (ByteStringUTF8 -> Bool)
    -> (Char -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    forall t.
    TextualMonoid t =>
    (t -> Bool) -> (Char -> Bool) -> t -> t
    Textual.dropWhile ByteStringUTF8 -> Bool
    pb Char -> Bool
    pc ByteStringUTF8
    utf8
       {-# INLINE takeWhile #-}
       span :: (ByteStringUTF8 -> Bool)
    -> (Char -> Bool)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8)
    span ByteStringUTF8 -> Bool
    pb Char -> Bool
    pc utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs) = (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeTake (ByteString -> Int
    ByteString.length ByteString
    bs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    suffix') ByteString
    bs, ByteStringUTF8
    suffix)
          where suffix :: ByteStringUTF8
    suffix@(ByteStringUTF8 ByteString
    suffix') = (ByteStringUTF8 -> Bool)
    -> (Char -> Bool) -> ByteStringUTF8 -> ByteStringUTF8
    forall t.
    TextualMonoid t =>
    (t -> Bool) -> (Char -> Bool) -> t -> t
    Textual.dropWhile ByteStringUTF8 -> Bool
    pb Char -> Bool
    pc ByteStringUTF8
    utf8
       {-# INLINE span #-}
       break :: (ByteStringUTF8 -> Bool)
    -> (Char -> Bool)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8)
    break ByteStringUTF8 -> Bool
    pb Char -> Bool
    pc = (ByteStringUTF8 -> Bool)
    -> (Char -> Bool)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8)
    forall t.
    TextualMonoid t =>
    (t -> Bool) -> (Char -> Bool) -> t -> (t, t)
    Textual.span (Bool -> Bool
    not (Bool -> Bool)
    -> (ByteStringUTF8 -> Bool) -> ByteStringUTF8 -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteStringUTF8 -> Bool
    pb) (Bool -> Bool
    not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Bool
    pc)
       {-# INLINE break #-}
       spanMaybe :: forall s.
    s
    -> (s -> ByteStringUTF8 -> Maybe s)
    -> (s -> Char -> Maybe s)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8, s)
    spanMaybe s
    s0 s -> ByteStringUTF8 -> Maybe s
    ft s -> Char -> Maybe s
    fc (ByteStringUTF8 ByteString
    bs)  =
          let inner :: Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner Int
    i s
    s
                | Int
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    len =
                    let w :: Word8
    w = ByteString -> Int -> Word8
    unsafeIndex ByteString
    bs Int
    i
                    in if Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80
                       then case s -> Char -> Maybe s
    fc s
    s (Word8 -> Char
    w2c Word8
    w)
                            of Just s
    s' -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) s
    s'
                               Maybe s
    Nothing -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
                       else case ByteStringUTF8 -> Maybe (Char, ByteStringUTF8)
    forall t. TextualMonoid t => t -> Maybe (Char, t)
    splitCharacterPrefix (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeDrop Int
    i ByteString
    bs)
                            of Just (Char
    c, ByteStringUTF8 ByteString
    rest) | Just s
    s' <- s -> Char -> Maybe s
    fc s
    s Char
    c -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner (Int
    len Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    rest) s
    s'
                               Maybe (Char, ByteStringUTF8)
    Nothing -> let j :: Int
    j = Int -> Int
    forall a. Enum a => a -> a
    succ (ByteString -> Int
    headIndex (ByteString -> Int) -> ByteString -> Int
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    forall m. FactorialMonoid m => Int -> m -> m
    drop (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) ByteString
    bs)
                                          in case s -> ByteStringUTF8 -> Maybe s
    ft s
    s (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    ByteString.take Int
    j (ByteString -> ByteString) -> ByteString -> ByteString
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeDrop Int
    i ByteString
    bs)
                                             of Just s
    s' -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    j) s
    s'
                                                Maybe s
    Nothing -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
                               Maybe (Char, ByteStringUTF8)
    _ -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
                | Bool
    otherwise = Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
              done :: Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i c
    s = Int
    i Int
    -> (ByteStringUTF8, ByteStringUTF8, c)
    -> (ByteStringUTF8, ByteStringUTF8, c)
    forall a b. a -> b -> b
    `seq` c
    s c
    -> (ByteStringUTF8, ByteStringUTF8, c)
    -> (ByteStringUTF8, ByteStringUTF8, c)
    forall a b. a -> b -> b
    `seq` (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeTake Int
    i ByteString
    bs, ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeDrop Int
    i ByteString
    bs, c
    s)
              len :: Int
    len = ByteString -> Int
    ByteString.length ByteString
    bs
          in Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner Int
    0 s
    s0
       {-# INLINE spanMaybe #-}
       spanMaybe' :: forall s.
    s
    -> (s -> ByteStringUTF8 -> Maybe s)
    -> (s -> Char -> Maybe s)
    -> ByteStringUTF8
    -> (ByteStringUTF8, ByteStringUTF8, s)
    spanMaybe' s
    s0 s -> ByteStringUTF8 -> Maybe s
    ft s -> Char -> Maybe s
    fc (ByteStringUTF8 ByteString
    bs)  =
          let inner :: Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner Int
    i s
    s
                | Int
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    len =
                    s
    s s
    -> (ByteStringUTF8, ByteStringUTF8, s)
    -> (ByteStringUTF8, ByteStringUTF8, s)
    forall a b. a -> b -> b
    `seq`
                    let w :: Word8
    w = ByteString -> Int -> Word8
    unsafeIndex ByteString
    bs Int
    i
                    in if Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80
                       then case s -> Char -> Maybe s
    fc s
    s (Word8 -> Char
    w2c Word8
    w)
                            of Just s
    s' -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) s
    s'
                               Maybe s
    Nothing -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
                       else case ByteStringUTF8 -> Maybe (Char, ByteStringUTF8)
    forall t. TextualMonoid t => t -> Maybe (Char, t)
    splitCharacterPrefix (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeDrop Int
    i ByteString
    bs)
                            of Just (Char
    c, ByteStringUTF8 ByteString
    rest) | Just s
    s' <- s -> Char -> Maybe s
    fc s
    s Char
    c -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner (Int
    len Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - ByteString -> Int
    ByteString.length ByteString
    rest) s
    s'
                               Maybe (Char, ByteStringUTF8)
    Nothing -> let j :: Int
    j = Int -> Int
    forall a. Enum a => a -> a
    succ (ByteString -> Int
    headIndex (ByteString -> Int) -> ByteString -> Int
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    forall m. FactorialMonoid m => Int -> m -> m
    drop (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) ByteString
    bs)
                                          in case s -> ByteStringUTF8 -> Maybe s
    ft s
    s (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    ByteString.take Int
    j (ByteString -> ByteString) -> ByteString -> ByteString
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeDrop Int
    i ByteString
    bs)
                                             of Just s
    s' -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    j) s
    s'
                                                Maybe s
    Nothing -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
                               Maybe (Char, ByteStringUTF8)
    _ -> Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
                | Bool
    otherwise = Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    forall {c}. Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i s
    s
              done :: Int -> c -> (ByteStringUTF8, ByteStringUTF8, c)
    done Int
    i c
    s = Int
    i Int
    -> (ByteStringUTF8, ByteStringUTF8, c)
    -> (ByteStringUTF8, ByteStringUTF8, c)
    forall a b. a -> b -> b
    `seq` c
    s c
    -> (ByteStringUTF8, ByteStringUTF8, c)
    -> (ByteStringUTF8, ByteStringUTF8, c)
    forall a b. a -> b -> b
    `seq` (ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeTake Int
    i ByteString
    bs, ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8) -> ByteString -> ByteStringUTF8
    forall a b. (a -> b) -> a -> b
    $ Int -> ByteString -> ByteString
    unsafeDrop Int
    i ByteString
    bs, c
    s)
              len :: Int
    len = ByteString -> Int
    ByteString.length ByteString
    bs
          in Int -> s -> (ByteStringUTF8, ByteStringUTF8, s)
    inner Int
    0 s
    s0
       {-# INLINE spanMaybe' #-}
       find :: (Char -> Bool) -> ByteStringUTF8 -> Maybe Char
    find Char -> Bool
    p (ByteStringUTF8 ByteString
    bs0) = ByteString -> Maybe Char
    loop ByteString
    bs0
          where loop :: ByteString -> Maybe Char
    loop ByteString
    bs = case (Char -> Bool) -> ByteString -> Maybe Int
    ByteString.Char8.findIndex (\Char
    c-> Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Char
    '\x80' Bool -> Bool -> Bool
    || Char -> Bool
    p Char
    c) ByteString
    bs
                          of Maybe Int
    Nothing -> Maybe Char
    forall a. Maybe a
    Nothing
                             Just Int
    i -> let x :: Word8
    x = ByteString -> Int -> Word8
    unsafeIndex ByteString
    bs Int
    i
                                           bs' :: ByteString
    bs' = Int -> ByteString -> ByteString
    unsafeDrop (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) ByteString
    bs
                                       in if Word8
    x Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80
                                          then Char -> Maybe Char
    forall a. a -> Maybe a
    Just (Word8 -> Char
    w2c Word8
    x)
                                          else case Word8 -> ByteString -> Maybe (Char, ByteStringUTF8)
    toChar Word8
    x ByteString
    bs'
                                               of Just (Char
    c, ByteStringUTF8 ByteString
    rest) | Char -> Bool
    p Char
    c -> Char -> Maybe Char
    forall a. a -> Maybe a
    Just Char
    c
                                                                                | Bool
    otherwise -> ByteString -> Maybe Char
    loop ByteString
    rest
                                                  Maybe (Char, ByteStringUTF8)
    Nothing -> ByteString -> Maybe Char
    loop ((Word8 -> Bool) -> ByteString -> ByteString
    ByteString.dropWhile (Bool -> Bool
    not (Bool -> Bool) -> (Word8 -> Bool) -> Word8 -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Bool
    byteStartsCharacter) ByteString
    bs')
       {-# INLINE find #-}
       any :: (Char -> Bool) -> ByteStringUTF8 -> Bool
    any Char -> Bool
    p ByteStringUTF8
    utf8 = Maybe Char -> Bool
    forall a. Maybe a -> Bool
    isJust ((Char -> Bool) -> ByteStringUTF8 -> Maybe Char
    forall t. TextualMonoid t => (Char -> Bool) -> t -> Maybe Char
    find Char -> Bool
    p ByteStringUTF8
    utf8)
       {-# INLINE any #-}
       all :: (Char -> Bool) -> ByteStringUTF8 -> Bool
    all Char -> Bool
    p ByteStringUTF8
    utf8 = Maybe Char -> Bool
    forall a. Maybe a -> Bool
    isNothing ((Char -> Bool) -> ByteStringUTF8 -> Maybe Char
    forall t. TextualMonoid t => (Char -> Bool) -> t -> Maybe Char
    find (Bool -> Bool
    not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Bool
    p) ByteStringUTF8
    utf8)
       {-# INLINE all #-}
       elem :: Char -> ByteStringUTF8 -> Bool
    elem Char
    c utf8 :: ByteStringUTF8
    utf8@(ByteStringUTF8 ByteString
    bs)
         | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80' = Char -> ByteString -> Bool
    ByteString.Char8.elem Char
    c ByteString
    bs
         | Bool
    otherwise = (Char -> Bool) -> ByteStringUTF8 -> Bool
    forall t. TextualMonoid t => (Char -> Bool) -> t -> Bool
    any (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    c) ByteStringUTF8
    utf8
       {-# INLINE elem #-}
       fromText :: Text -> ByteStringUTF8
    fromText = ByteString -> ByteStringUTF8
    ByteStringUTF8 (ByteString -> ByteStringUTF8)
    -> (Text -> ByteString) -> Text -> ByteStringUTF8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> ByteString
    encodeUtf8
       toText :: (ByteStringUTF8 -> Text) -> ByteStringUTF8 -> Text
    toText ByteStringUTF8 -> Text
    f t :: ByteStringUTF8
    t@(ByteStringUTF8 ByteString
    bs) = (UnicodeException -> Text)
    -> (Text -> Text) -> Either UnicodeException Text -> Text
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either (Text -> UnicodeException -> Text
    forall a b. a -> b -> a
    const (Text -> UnicodeException -> Text)
    -> Text -> UnicodeException -> Text
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ (ByteStringUTF8 -> String) -> ByteStringUTF8 -> String
    forall t. TextualMonoid t => (t -> String) -> t -> String
    toString (Text -> String
    unpack (Text -> String)
    -> (ByteStringUTF8 -> Text) -> ByteStringUTF8 -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteStringUTF8 -> Text
    f) ByteStringUTF8
    t) Text -> Text
    forall a. a -> a
    id (ByteString -> Either UnicodeException Text
    decodeUtf8' ByteString
    bs)

    reverseBytesToChar :: (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    reverseBytesToChar :: forall a. (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    reverseBytesToChar ByteString -> a
    ft Char -> a
    fc [Word8
    w] = if Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 then Char -> a
    fc (Word8 -> Char
    w2c Word8
    w) else ByteString -> a
    ft (Word8 -> ByteString
    ByteString.singleton Word8
    w)
    reverseBytesToChar ByteString -> a
    ft Char -> a
    fc [Word8
    b0, Word8
    b1] =
      Bool -> a -> a
    forall a. HasCallStack => Bool -> a -> a
    assert (Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b0 Bool -> Bool -> Bool
    && Word8
    b0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $
      if Word8
    0xC2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1 Bool -> Bool -> Bool
    && Word8
    b1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xE0
      then Char -> a
    fc (Int -> Char
    chr (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b1 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x1F) Int
    6 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b0 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F))
      else ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8
    b1, Word8
    b0])
    reverseBytesToChar ByteString -> a
    ft Char -> a
    fc [Word8
    b0, Word8
    b1, Word8
    b2] =
      Bool -> a -> a
    forall a. HasCallStack => Bool -> a -> a
    assert (Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b0 Bool -> Bool -> Bool
    && Word8
    b0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0 Bool -> Bool -> Bool
    && Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1 Bool -> Bool -> Bool
    && Word8
    b1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $
      if (Word8
    0xE0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    b2 Bool -> Bool -> Bool
    || Word8
    0xE0 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    b2 Bool -> Bool -> Bool
    && Word8
    0xA0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1) Bool -> Bool -> Bool
    && Word8
    b2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF0
      then Char -> a
    fc (Int -> Char
    chr (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b2 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0xF) Int
    12
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b1 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int
    6
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b0 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F))
      else ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8
    b2, Word8
    b1, Word8
    b0])
    reverseBytesToChar ByteString -> a
    ft Char -> a
    fc [Word8
    b0, Word8
    b1, Word8
    b2, Word8
    b3] =
      Bool -> a -> a
    forall a. HasCallStack => Bool -> a -> a
    assert (Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b0 Bool -> Bool -> Bool
    && Word8
    b0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0 Bool -> Bool -> Bool
    && Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1 Bool -> Bool -> Bool
    && Word8
    b1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0 Bool -> Bool -> Bool
    && Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b2 Bool -> Bool -> Bool
    && Word8
    b2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $
      if (Word8
    0xF0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    b3 Bool -> Bool -> Bool
    || Word8
    0xF0 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    b3 Bool -> Bool -> Bool
    && Word8
    0x90 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b2) Bool -> Bool -> Bool
    && Word8
    b3 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF5 Bool -> Bool -> Bool
    && (Word8
    b3 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF4 Bool -> Bool -> Bool
    || Word8
    b2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x90)
      then Char -> a
    fc (Int -> Char
    chr (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b3 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x7) Int
    18
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b2 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int
    12
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b1 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int
    6
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b0 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F))
      else ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8
    b3, Word8
    b2, Word8
    b1, Word8
    b0])
    reverseBytesToChar ByteString -> a
    ft Char -> a
    _fc [Word8]
    bytes = ByteString -> a
    ft (ByteString -> ByteString
    ByteString.reverse (ByteString -> ByteString) -> ByteString -> ByteString
    forall a b. (a -> b) -> a -> b
    $ [Word8] -> ByteString
    ByteString.pack [Word8]
    bytes)

    bytesToChar :: (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    bytesToChar :: forall a. (ByteString -> a) -> (Char -> a) -> [Word8] -> a
    bytesToChar ByteString -> a
    ft Char -> a
    fc [Word8
    w] = if Word8
    w Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 then Char -> a
    fc (Word8 -> Char
    w2c Word8
    w) else ByteString -> a
    ft (Word8 -> ByteString
    ByteString.singleton Word8
    w)
    bytesToChar ByteString -> a
    ft Char -> a
    fc bytes :: [Word8]
    bytes@[Word8
    b1, Word8
    b0] =
      Bool -> a -> a
    forall a. HasCallStack => Bool -> a -> a
    assert (Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b0 Bool -> Bool -> Bool
    && Word8
    b0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $
      if Word8
    0xC2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1 Bool -> Bool -> Bool
    && Word8
    b1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xE0
      then Char -> a
    fc (Int -> Char
    chr (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b1 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x1F) Int
    6 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b0 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F))
      else ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8]
    bytes)
    bytesToChar ByteString -> a
    ft Char -> a
    fc bytes :: [Word8]
    bytes@[Word8
    b2, Word8
    b1, Word8
    b0] =
      Bool -> a -> a
    forall a. HasCallStack => Bool -> a -> a
    assert (Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b0 Bool -> Bool -> Bool
    && Word8
    b0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0 Bool -> Bool -> Bool
    && Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1 Bool -> Bool -> Bool
    && Word8
    b1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $
      if (Word8
    0xE0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    b2 Bool -> Bool -> Bool
    || Word8
    0xE0 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    b2 Bool -> Bool -> Bool
    && Word8
    0xA0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1) Bool -> Bool -> Bool
    && Word8
    b2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF0
      then Char -> a
    fc (Int -> Char
    chr (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b2 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0xF) Int
    12
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b1 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int
    6
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b0 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F))
      else ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8]
    bytes)
    bytesToChar ByteString -> a
    ft Char -> a
    fc bytes :: [Word8]
    bytes@[Word8
    b3, Word8
    b2, Word8
    b1, Word8
    b0] =
      Bool -> a -> a
    forall a. HasCallStack => Bool -> a -> a
    assert (Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b0 Bool -> Bool -> Bool
    && Word8
    b0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0 Bool -> Bool -> Bool
    && Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b1 Bool -> Bool -> Bool
    && Word8
    b1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0 Bool -> Bool -> Bool
    && Word8
    0x80 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b2 Bool -> Bool -> Bool
    && Word8
    b2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC0) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $
      if (Word8
    0xF0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    b3 Bool -> Bool -> Bool
    || Word8
    0xF0 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    b3 Bool -> Bool -> Bool
    && Word8
    0x90 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    b2) Bool -> Bool -> Bool
    && Word8
    b3 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF5 Bool -> Bool -> Bool
    && (Word8
    b3 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF4 Bool -> Bool -> Bool
    || Word8
    b2 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x90)
      then Char -> a
    fc (Int -> Char
    chr (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b3 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x7) Int
    18
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b2 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int
    12
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b1 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int
    6
                    Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    b0 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F))
      else ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8]
    bytes)
    bytesToChar ByteString -> a
    ft Char -> a
    _fc [Word8]
    bytes = ByteString -> a
    ft ([Word8] -> ByteString
    ByteString.pack [Word8]
    bytes)

    wrapPair :: (ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair :: (ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8)
    wrapPair (ByteString
    bs1, ByteString
    bs2) = (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs1, ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs2)
    {-# INLINE wrapPair #-}

    wrapTriple :: (ByteString, ByteString, ByteString) -> (ByteStringUTF8, ByteStringUTF8, ByteStringUTF8)
    wrapTriple :: (ByteString, ByteString, ByteString)
    -> (ByteStringUTF8, ByteStringUTF8, ByteStringUTF8)
    wrapTriple (ByteString
    bs1, ByteString
    bs2, ByteString
    bs3) = (ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs1, ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs2, ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    bs3)
    {-# INLINE wrapTriple #-}

    fromChar :: Char -> ByteString
    fromChar :: Char -> ByteString
    fromChar Char
    c | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x80'    = Char -> ByteString
    ByteString.Char8.singleton Char
    c
               | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x800'   = [Word8] -> ByteString
    ByteString.pack [Word8
    0xC0 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftR Int
    n Int
    6),
                                                  Word8
    0x80 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F)]
               | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\x10000' = [Word8] -> ByteString
    ByteString.pack [Word8
    0xE0 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftR Int
    n Int
    12),
                                                  Word8
    0x80 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftR Int
    n Int
    6 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F),
                                                  Word8
    0x80 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F)]
               | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    0x200000  = [Word8] -> ByteString
    ByteString.pack [Word8
    0xF0 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftR Int
    n Int
    18),
                                                  Word8
    0x80 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftR Int
    n Int
    12 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F),
                                                  Word8
    0x80 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    shiftR Int
    n Int
    6 Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F),
                                                  Word8
    0x80 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    + Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F)]
               | Bool
    otherwise  = String -> ByteString
    forall a. HasCallStack => String -> a
    error (String
    "Data.Char.ord '" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ (Char
    c Char -> ShowS
    forall a. a -> [a] -> [a]
    : String
    "' >=0x200000"))
       where n :: Int
    n = Char -> Int
    ord Char
    c

    toChar :: Word8 -> ByteString -> Maybe (Char, ByteStringUTF8)
    toChar :: Word8 -> ByteString -> Maybe (Char, ByteStringUTF8)
    toChar Word8
    hd ByteString
    tl | Word8
    hd Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 = (Char, ByteStringUTF8) -> Maybe (Char, ByteStringUTF8)
    forall a. a -> Maybe a
    Just (Word8 -> Char
    w2c Word8
    hd, ByteString -> ByteStringUTF8
    ByteStringUTF8 ByteString
    tl)
                 | Word8
    hd Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xC2 = Maybe (Char, ByteStringUTF8)
    forall a. Maybe a
    Nothing
                 | Word8
    hd Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xE0 = do (b0, t0) <- ByteString -> Maybe (Word8, ByteString)
    ByteString.uncons ByteString
    tl
                                  if headIndex tl == 1
                                     then return (chr (shiftL (fromIntegral hd .&. 0x1F) 6
                                                       .|. fromIntegral b0 .&. 0x3F),
                                                  ByteStringUTF8 t0)
                                     else Nothing
                 | Word8
    hd Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF0 = do (b1, t1) <- ByteString -> Maybe (Word8, ByteString)
    ByteString.uncons ByteString
    tl
                                  (b0, t0) <- ByteString.uncons t1
                                  if (hd > 0xE0 || b1 >= 0xA0) && headIndex tl == 2
                                     then return (chr (shiftL (fromIntegral hd .&. 0xF) 12
                                                       .|. shiftL (fromIntegral b1 .&. 0x3F) 6
                                                       .|. fromIntegral b0 .&. 0x3F),
                                                  ByteStringUTF8 t0)
                                     else Nothing
                 | Word8
    hd Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0xF5 = do (b2, t2) <- ByteString -> Maybe (Word8, ByteString)
    ByteString.uncons ByteString
    tl
                                  (b1, t1) <- ByteString.uncons t2
                                  (b0, t0) <- ByteString.uncons t1
                                  if (hd > 0xF0 || b2 >= 0x90) && (hd < 0xF4 || b2 < 0x90) && headIndex tl == 3
                                     then return (chr (shiftL (fromIntegral hd .&. 0x7) 18
                                                       .|. shiftL (fromIntegral b2 .&. 0x3F) 12
                                                       .|. shiftL (fromIntegral b1 .&. 0x3F) 6
                                                       .|. fromIntegral b0 .&. 0x3F),
                                                  ByteStringUTF8 t0)
                                     else Nothing
                 | Bool
    otherwise = Maybe (Char, ByteStringUTF8)
    forall a. Maybe a
    Nothing

    groupASCII :: ByteString -> [ByteString]
    groupASCII :: ByteString -> [ByteString]
    groupASCII = (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString]
    ByteString.groupBy Word8 -> Word8 -> Bool
    forall {a} {a}. (Ord a, Ord a, Num a, Num a) => a -> a -> Bool
    continued
       where continued :: a -> a -> Bool
    continued a
    a a
    b = (a
    a a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0x80) Bool -> Bool -> Bool
    forall a. Eq a => a -> a -> Bool
    == (a
    b a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0x80) Bool -> Bool -> Bool
    && a
    b a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0xC0
    {-# INLINE groupASCII #-}

    headIndex :: ByteString -> Int
    headIndex :: ByteString -> Int
    headIndex ByteString
    bs = Int -> Maybe Int -> Int
    forall a. a -> Maybe a -> a
    fromMaybe (ByteString -> Int
    ByteString.length ByteString
    bs) (Maybe Int -> Int) -> Maybe Int -> Int
    forall a b. (a -> b) -> a -> b
    $ (Word8 -> Bool) -> ByteString -> Maybe Int
    ByteString.findIndex Word8 -> Bool
    byteStartsCharacter ByteString
    bs
    {-# INLINE headIndex #-}

    byteStartsCharacter :: Word8 -> Bool
    byteStartsCharacter :: Word8 -> Bool
    byteStartsCharacter Word8
    b = Word8
    b Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 Bool -> Bool -> Bool
    || Word8
    b Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xC0
    {-# INLINE byteStartsCharacter #-}

    charStartIndex :: Int -> ByteString -> Int
    charStartIndex :: Int -> ByteString -> Int
    charStartIndex Int
    n ByteString
    _ | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0 = Int
    0
    charStartIndex Int
    n0 ByteString
    bs = (Word8 -> ((Int, Bool, Int) -> Int) -> (Int, Bool, Int) -> Int)
    -> ((Int, Bool, Int) -> Int)
    -> ByteString
    -> (Int, Bool, Int)
    -> Int
    forall a. (Word8 -> a -> a) -> a -> ByteString -> a
    ByteString.foldr Word8 -> ((Int, Bool, Int) -> Int) -> (Int, Bool, Int) -> Int
    forall {a} {a} {c}.
    (Ord a, Num a, Num a, Enum a, Enum c, Eq a) =>
    a -> ((a, Bool, c) -> c) -> (a, Bool, c) -> c
    count (Int -> (Int, Bool, Int) -> Int
    forall a b. a -> b -> a
    const (Int -> (Int, Bool, Int) -> Int) -> Int -> (Int, Bool, Int) -> Int
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    ByteString.length ByteString
    bs) ByteString
    bs (Int
    n0, Bool
    False, Int
    0)
          where count :: a -> ((a, Bool, c) -> c) -> (a, Bool, c) -> c
    count a
    byte (a, Bool, c) -> c
    _    (a
    0, Bool
    high, c
    i) | a
    byte a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0x80 Bool -> Bool -> Bool
    || a
    byte a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    >= a
    0xC0 Bool -> Bool -> Bool
    || Bool -> Bool
    not Bool
    high = c
    i
                count a
    byte (a, Bool, c) -> c
    cont (a
    n, Bool
    high, c
    i) | a
    byte a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0x80 = (a, Bool, c) -> c
    cont (a -> a
    forall a. Enum a => a -> a
    pred a
    n, Bool
    False, c -> c
    forall a. Enum a => a -> a
    succ c
    i)
                                             | a
    byte a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0xC0 = (a, Bool, c) -> c
    cont (if Bool
    high then a
    n else a -> a
    forall a. Enum a => a -> a
    pred a
    n, Bool
    True, c -> c
    forall a. Enum a => a -> a
    succ c
    i)
                                             | Bool
    otherwise = (a, Bool, c) -> c
    cont (a -> a
    forall a. Enum a => a -> a
    pred a
    n, Bool
    True, c -> c
    forall a. Enum a => a -> a
    succ c
    i)
    {-# INLINE charStartIndex #-}