{-# LANGUAGE BangPatterns      #-}
{-# LANGUAGE OverloadedStrings #-}

module HaskellWorks.Data.Xml.Blank
  ( blankXml
  ) where

import Data.ByteString                      (ByteString)
import Data.Word
import Data.Word8
import HaskellWorks.Data.Xml.Internal.Words
import Prelude

import qualified Data.ByteString as BS

type ExpectedChar = Word8

data BlankState
  = InXml
  | InTag
  | InAttrList
  | InCloseTag
  | InClose
  | InBang Int
  | InString ExpectedChar
  | InText
  | InMeta
  | InCdataTag
  | InCdata Int
  | InRem Int
  | InIdent
  deriving (BlankState -> BlankState -> Bool
(BlankState -> BlankState -> Bool)
-> (BlankState -> BlankState -> Bool) -> Eq BlankState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlankState -> BlankState -> Bool
$c/= :: BlankState -> BlankState -> Bool
== :: BlankState -> BlankState -> Bool
$c== :: BlankState -> BlankState -> Bool
Eq, Int -> BlankState -> ShowS
[BlankState] -> ShowS
BlankState -> String
(Int -> BlankState -> ShowS)
-> (BlankState -> String)
-> ([BlankState] -> ShowS)
-> Show BlankState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlankState] -> ShowS
$cshowList :: [BlankState] -> ShowS
show :: BlankState -> String
$cshow :: BlankState -> String
showsPrec :: Int -> BlankState -> ShowS
$cshowsPrec :: Int -> BlankState -> ShowS
Show)

data ByteStringP = BSP Word8 ByteString | EmptyBSP deriving Int -> ByteStringP -> ShowS
[ByteStringP] -> ShowS
ByteStringP -> String
(Int -> ByteStringP -> ShowS)
-> (ByteStringP -> String)
-> ([ByteStringP] -> ShowS)
-> Show ByteStringP
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ByteStringP] -> ShowS
$cshowList :: [ByteStringP] -> ShowS
show :: ByteStringP -> String
$cshow :: ByteStringP -> String
showsPrec :: Int -> ByteStringP -> ShowS
$cshowsPrec :: Int -> ByteStringP -> ShowS
Show

blankXml :: BS.ByteString -> BS.ByteString
blankXml :: ByteString -> ByteString
blankXml ByteString
as = (ByteString, Maybe (BlankState, ByteString)) -> ByteString
forall a b. (a, b) -> a
fst (Int
-> ((BlankState, ByteString)
    -> Maybe (Word8, (BlankState, ByteString)))
-> (BlankState, ByteString)
-> (ByteString, Maybe (BlankState, ByteString))
forall a.
Int -> (a -> Maybe (Word8, a)) -> a -> (ByteString, Maybe a)
BS.unfoldrN (ByteString -> Int
BS.length ByteString
as) (BlankState, ByteString) -> Maybe (Word8, (BlankState, ByteString))
go (BlankState
InXml, ByteString
as))
  where go :: (BlankState, ByteString) -> Maybe (Word8, (BlankState, ByteString))
        go :: (BlankState, ByteString) -> Maybe (Word8, (BlankState, ByteString))
go (BlankState
InXml, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8 -> ByteString -> Bool
isMetaStart Word8
c ByteString
cs -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketleft , (BlankState
InMeta       , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> ByteString -> Bool
isEndTag Word8
c ByteString
cs    -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InCloseTag   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isTextStart Word8
c    -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_t           , (BlankState
InText       , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_less       -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_less        , (BlankState
InTag        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c        -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (BlankState
InXml        , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                    -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InXml        , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                           -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InTag, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c       -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_parenleft   , (BlankState
InAttrList   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> ByteString -> Bool
isTagClose Word8
c ByteString
cs -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InClose      , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater   -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c       -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (BlankState
InTag        , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                   -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InTag        , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                          -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InCloseTag, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_greater     , (BlankState
InXml        , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                 -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InCloseTag   , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                        -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InAttrList, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater     -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_parenright  , (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> ByteString -> Bool
isTagClose Word8
c ByteString
cs   -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_parenright  , (BlankState
InClose      , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isNameStartChar Word8
c -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_a           , (BlankState
InIdent      , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isQuote Word8
c         -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_v           , (Word8 -> BlankState
InString Word8
c   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c         -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (BlankState
InAttrList   , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                     -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InAttrList   , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                            -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InClose, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (Word8
_, !ByteString
cs) -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_greater     , (BlankState
InXml        , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing       -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InIdent, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isNameChar Word8
c -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InIdent      , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c    -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InAttrList   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_equal  -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InAttrList   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c    -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (BlankState
InAttrList   , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InAttrList   , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                       -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (InString Word8
q, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
q    -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InAttrList   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (Word8 -> BlankState
InString Word8
q   , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)             -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Word8 -> BlankState
InString Word8
q   , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                    -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InText, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8 -> ByteString -> Bool
isEndTag Word8
c ByteString
cs        -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InCloseTag   , ByteString
cs))
          Just ( Word8
_, !ByteString
cs) | (Word8 -> Bool) -> ByteString -> Bool
headIs (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_less) ByteString
cs -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c            -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (BlankState
InText       , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                        -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InText       , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                               -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InMeta, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_exclam      -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InMeta       , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_hyphen      -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InRem Int
0      , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_bracketleft -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InCdataTag   , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater     -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketright, (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c         -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (Int -> BlankState
InBang Int
1     , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                     -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InBang Int
1     , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                            -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (BlankState
InCdataTag, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_bracketleft -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InCdata Int
0    , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c         -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (BlankState
InCdataTag   , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                     -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (BlankState
InCdataTag   , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                            -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (InCdata Int
n, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
2  -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketright, (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> ByteString -> Bool
isCdataEnd Word8
c ByteString
cs Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InCdata (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1), ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_bracketright       -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InCdata (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1), ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c                -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (Int -> BlankState
InCdata Int
0    , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                            -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InCdata Int
0    , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                                   -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (InRem Int
n, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
2 -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketright, (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_hyphen            -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InRem (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)  , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c               -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (Int -> BlankState
InRem Int
0      , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                           -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InRem Int
0      , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                                  -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing
        go (InBang Int
n, ByteString
bs) = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_less              -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketleft , (Int -> BlankState
InBang (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketright, (BlankState
InXml        , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater           -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_bracketright, (Int -> BlankState
InBang (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) , ByteString
cs))
          Just (!Word8
c, !ByteString
cs) | Word8 -> Bool
isSpace Word8
c               -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
c            , (Int -> BlankState
InBang Int
n     , ByteString
cs))
          Just ( Word8
_, !ByteString
cs)                           -> (Word8, (BlankState, ByteString))
-> Maybe (Word8, (BlankState, ByteString))
forall a. a -> Maybe a
Just (Word8
_space       , (Int -> BlankState
InBang Int
n     , ByteString
cs))
          Maybe (Word8, ByteString)
Nothing                                  -> Maybe (Word8, (BlankState, ByteString))
forall a. Maybe a
Nothing

isEndTag :: Word8 -> ByteString -> Bool
isEndTag :: Word8 -> ByteString -> Bool
isEndTag Word8
c ByteString
cs = Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_less Bool -> Bool -> Bool
&& (Word8 -> Bool) -> ByteString -> Bool
headIs (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_slash) ByteString
cs
{-# INLINE isEndTag #-}

isTagClose :: Word8 -> ByteString -> Bool
isTagClose :: Word8 -> ByteString -> Bool
isTagClose Word8
c ByteString
cs = (Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_slash) Bool -> Bool -> Bool
|| ((Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_slash Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_question) Bool -> Bool -> Bool
&& (Word8 -> Bool) -> ByteString -> Bool
headIs (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater) ByteString
cs)
{-# INLINE isTagClose #-}

isMetaStart :: Word8 -> ByteString -> Bool
isMetaStart :: Word8 -> ByteString -> Bool
isMetaStart Word8
c ByteString
cs = Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_less Bool -> Bool -> Bool
&& (Word8 -> Bool) -> ByteString -> Bool
headIs (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_exclam) ByteString
cs
{-# INLINE isMetaStart #-}

isCdataEnd :: Word8 -> ByteString -> Bool
isCdataEnd :: Word8 -> ByteString -> Bool
isCdataEnd Word8
c ByteString
cs = Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_bracketright Bool -> Bool -> Bool
&& (Word8 -> Bool) -> ByteString -> Bool
headIs (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_greater) ByteString
cs
{-# INLINE isCdataEnd #-}

headIs :: (Word8 -> Bool) -> ByteString -> Bool
headIs :: (Word8 -> Bool) -> ByteString -> Bool
headIs Word8 -> Bool
p ByteString
bs = case ByteString -> Maybe (Word8, ByteString)
BS.uncons ByteString
bs of
  Just (!Word8
c, ByteString
_) -> Word8 -> Bool
p Word8
c
  Maybe (Word8, ByteString)
Nothing      -> Bool
False
{-# INLINE headIs #-}