{-|
Description:    Tokenization rules for characters comprising a markup element.

Copyright:      (c) 2020-2021 Sam May
License:        MPL-2.0
Maintainer:     ag.eitilt@gmail.com

Stability:      stable
Portability:    portable
-}
module Web.Mangrove.Parse.Tokenize.Tag
    ( tokenTagOpen
    , tokenBeforeAttributeName
    , tokenSelfClosingStartTag
    , tokenAppropriateEndTagLessThanSign
    , tokenAppropriateEndTagOpen
      -- * Types
    , TagParams' ( .. )
    , emptyTagData
    , packTagToken
    ) where


import qualified Control.Applicative as A
import qualified Control.Monad.Trans.State as N.S

import qualified Data.Bifunctor as F.B
import qualified Data.List as L
import qualified Data.HashMap.Strict as M
import qualified Data.Maybe as Y
import qualified Data.Text as T

import Data.Functor ( ($>) )

import Web.Willow.DOM

import Web.Mangrove.Parse.Common.Error
import Web.Mangrove.Parse.Tokenize.Common
import Web.Mangrove.Parse.Tokenize.Character
import Web.Mangrove.Parse.Tokenize.Comment
import Web.Mangrove.Parse.Tokenize.Doctype
import Web.Willow.Common.Encoding.Character
import Web.Willow.Common.Parser.Util

import {-# SOURCE #-} Web.Mangrove.Parse.Tokenize.Dispatcher


-- | An intermediate form of 'TagParams' with unpacked parameter types to
-- facilitate construction.  Specifically, 'Char'-by-'Char' construction of a
-- 'String' followed by a single 'T.pack' is much faster than repeated @O(n)@
-- calls to 'T.cons'.  Values may be easily instantiated as updates to
-- @emptyTagData@.
data TagParams' = TagParams'
    { TagParams' -> String
tagName' :: String
        -- ^ See 'tagName'.
    , TagParams' -> Bool
tagIsSelfClosing' :: Bool
        -- ^ See 'tagIsSelfClosing'.
    , TagParams' -> [(String, String)]
tagAttributes' :: [(String, String)]
        -- ^ See 'tagAttributes'.
    }
  deriving ( TagParams' -> TagParams' -> Bool
(TagParams' -> TagParams' -> Bool)
-> (TagParams' -> TagParams' -> Bool) -> Eq TagParams'
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TagParams' -> TagParams' -> Bool
$c/= :: TagParams' -> TagParams' -> Bool
== :: TagParams' -> TagParams' -> Bool
$c== :: TagParams' -> TagParams' -> Bool
Eq, Int -> TagParams' -> ShowS
[TagParams'] -> ShowS
TagParams' -> String
(Int -> TagParams' -> ShowS)
-> (TagParams' -> String)
-> ([TagParams'] -> ShowS)
-> Show TagParams'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TagParams'] -> ShowS
$cshowList :: [TagParams'] -> ShowS
show :: TagParams' -> String
$cshow :: TagParams' -> String
showsPrec :: Int -> TagParams' -> ShowS
$cshowsPrec :: Int -> TagParams' -> ShowS
Show, ReadPrec [TagParams']
ReadPrec TagParams'
Int -> ReadS TagParams'
ReadS [TagParams']
(Int -> ReadS TagParams')
-> ReadS [TagParams']
-> ReadPrec TagParams'
-> ReadPrec [TagParams']
-> Read TagParams'
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TagParams']
$creadListPrec :: ReadPrec [TagParams']
readPrec :: ReadPrec TagParams'
$creadPrec :: ReadPrec TagParams'
readList :: ReadS [TagParams']
$creadList :: ReadS [TagParams']
readsPrec :: Int -> ReadS TagParams'
$creadsPrec :: Int -> ReadS TagParams'
Read )

-- | A sane default collection for easy record initialization; namely,
-- 'null's and 'False'.
emptyTagData :: TagParams'
emptyTagData :: TagParams'
emptyTagData = TagParams' :: String -> Bool -> [(String, String)] -> TagParams'
TagParams'
    { tagName' :: String
tagName' = String
""
    , tagIsSelfClosing' :: Bool
tagIsSelfClosing' = Bool
False
    , tagAttributes' :: [(String, String)]
tagAttributes' = []
    }


-- | Wrap a given collection of data into the payload of a 'StartTag' or
-- 'EndTag', according to the given constructor.
packTagToken
    :: (TagParams -> Token)
    -> TokenizerOutput (Maybe TagParams')
    -> Tokenizer [TokenizerOutput Token]
packTagToken :: (TagParams -> Token)
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packTagToken TagParams -> Token
toToken TokenizerOutput (Maybe TagParams')
d' = case TokenizerOutput (Maybe TagParams') -> Maybe TagParams'
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput (Maybe TagParams')
d' of
    Just TagParams'
tagData -> do
        let tok :: Token
tok = TagParams -> Token
toToken (TagParams -> Token) -> TagParams -> Token
forall a b. (a -> b) -> a -> b
$ TagParams
emptyTagParams
                { tagName :: ElementName
tagName = String -> ElementName
T.pack (String -> ElementName) -> String -> ElementName
forall a b. (a -> b) -> a -> b
$ TagParams' -> String
tagName' TagParams'
tagData
                , tagIsSelfClosing :: Bool
tagIsSelfClosing = TagParams' -> Bool
tagIsSelfClosing' TagParams'
tagData
                , tagAttributes :: HashMap ElementName ElementName
tagAttributes = HashMap ElementName ElementName
attrs
                }
            ([ParseError]
attrErrs, HashMap ElementName ElementName
attrs) = [(String, String)]
-> ([ParseError], HashMap ElementName ElementName)
packAttributes ([(String, String)]
 -> ([ParseError], HashMap ElementName ElementName))
-> [(String, String)]
-> ([ParseError], HashMap ElementName ElementName)
forall a b. (a -> b) -> a -> b
$ TagParams' -> [(String, String)]
tagAttributes' TagParams'
tagData
        TokenizerOutput Token
tok' <- ([ParseError], Token) -> Tokenizer (TokenizerOutput Token)
emit (TokenizerOutput (Maybe TagParams') -> [ParseError]
forall out. TokenizerOutput out -> [ParseError]
tokenizedErrs TokenizerOutput (Maybe TagParams')
d' [ParseError] -> [ParseError] -> [ParseError]
forall a. [a] -> [a] -> [a]
++ [ParseError]
attrErrs, Token
tok)
        [TokenizerOutput Token] -> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a. Monad m => a -> m a
return [TokenizerOutput Token
tok' { tokenizedState :: DecoderOutputState
tokenizedState = TokenizerOutput (Maybe TagParams') -> DecoderOutputState
forall out. TokenizerOutput out -> DecoderOutputState
tokenizedState TokenizerOutput (Maybe TagParams')
d' }]
    Maybe TagParams'
Nothing -> case TokenizerOutput (Maybe TagParams') -> [ParseError]
forall out. TokenizerOutput out -> [ParseError]
tokenizedErrs TokenizerOutput (Maybe TagParams')
d' of
        [] -> [TokenizerOutput Token] -> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a. Monad m => a -> m a
return []
        [ParseError]
errs -> do
            Bool
atEOS <- TokenParserState -> Bool
atEndOfStream (TokenParserState -> Bool)
-> StateT
     TokenParserState (Parser [TokenizerInput]) TokenParserState
-> StateT TokenParserState (Parser [TokenizerInput]) Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT TokenParserState (Parser [TokenizerInput]) TokenParserState
forall (m :: * -> *) s. Monad m => StateT s m s
N.S.get
            [ParseError] -> [TokenizerOutput Token] -> [TokenizerOutput Token]
consTokenErrorsList [ParseError]
errs ([TokenizerOutput Token] -> [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> if Bool
atEOS
                then [TokenizerOutput Token]
-> Maybe [TokenizerOutput Token] -> [TokenizerOutput Token]
forall a. a -> Maybe a -> a
Y.fromMaybe [] (Maybe [TokenizerOutput Token] -> [TokenizerOutput Token])
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Maybe [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer [TokenizerOutput Token]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Maybe [TokenizerOutput Token])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
A.optional Tokenizer [TokenizerOutput Token]
dispatcher
                else Tokenizer [TokenizerOutput Token]
dispatcher

-- | Wrap a loose collection of unpacked 'String's into a form suitable for
-- representing the 'tagAttributes' of a markup element, removing all but the
-- first occurrence of any single name.
-- 
-- Note that any nameless attributes at the head of the list are dropped, to
-- work around the edge case where @newAttr@ is called immediately following
-- the tag name; this shouldn't cause any issue as the specification doesn't
-- seem to output any such attributes in the first place.
packAttributes
    :: [(String, String)]
    -> ([ParseError], M.HashMap T.Text T.Text)
packAttributes :: [(String, String)]
-> ([ParseError], HashMap ElementName ElementName)
packAttributes = ((String, String)
 -> ([ParseError], HashMap ElementName ElementName)
 -> ([ParseError], HashMap ElementName ElementName))
-> ([ParseError], HashMap ElementName ElementName)
-> [(String, String)]
-> ([ParseError], HashMap ElementName ElementName)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (String, String)
-> ([ParseError], HashMap ElementName ElementName)
-> ([ParseError], HashMap ElementName ElementName)
filterAttr ([], HashMap ElementName ElementName
forall k v. HashMap k v
M.empty) ([(String, String)]
 -> ([ParseError], HashMap ElementName ElementName))
-> ([(String, String)] -> [(String, String)])
-> [(String, String)]
-> ([ParseError], HashMap ElementName ElementName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((String, String) -> String)
-> [(String, String)] -> [(String, String)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
L.sortOn (String, String) -> String
forall a b. (a, b) -> a
fst ([(String, String)] -> [(String, String)])
-> ([(String, String)] -> [(String, String)])
-> [(String, String)]
-> [(String, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((String, String) -> Bool)
-> [(String, String)] -> [(String, String)]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (String -> Bool)
-> ((String, String) -> String) -> (String, String) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, String) -> String
forall a b. (a, b) -> a
fst)

-- | Add a single attribute to the processed collection, potentially throwing a
-- 'DuplicateAttribute' warning (with the old value) if one with the same name
-- already exists.
filterAttr
    :: (String, String)
    -> ([ParseError], M.HashMap T.Text T.Text)
    -> ([ParseError], M.HashMap T.Text T.Text)
filterAttr :: (String, String)
-> ([ParseError], HashMap ElementName ElementName)
-> ([ParseError], HashMap ElementName ElementName)
filterAttr (String
n, String
v) ([ParseError]
errs, HashMap ElementName ElementName
as)
    | HashMap ElementName ElementName -> Bool
forall k v. HashMap k v -> Bool
M.null HashMap ElementName ElementName
as = ([ParseError]
errs, ElementName -> ElementName -> HashMap ElementName ElementName
forall k v. Hashable k => k -> v -> HashMap k v
M.singleton ElementName
name ElementName
value)
    | Bool
otherwise = case ElementName -> HashMap ElementName ElementName -> Maybe ElementName
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup ElementName
name HashMap ElementName ElementName
as of
        Maybe ElementName
Nothing -> ([ParseError]
errs, ElementName
-> ElementName
-> HashMap ElementName ElementName
-> HashMap ElementName ElementName
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert ElementName
name ElementName
value HashMap ElementName ElementName
as)
        Just ElementName
value' -> (BasicAttribute -> ParseError
DuplicateAttribute (ElementName
name, ElementName
value') ParseError -> [ParseError] -> [ParseError]
forall a. a -> [a] -> [a]
: [ParseError]
errs, ElementName
-> ElementName
-> HashMap ElementName ElementName
-> HashMap ElementName ElementName
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert ElementName
name ElementName
value HashMap ElementName ElementName
as)
  where name :: ElementName
name = String -> ElementName
T.pack String
n
        value :: ElementName
value = String -> ElementName
T.pack String
v


-- | Finalize the currently "active" attribute, so that any further calls to,
-- e.g., @consAttrValue@ will be applied to a different (initially empty) pair
-- instead.
newAttr :: TokenizerOutput (Maybe TagParams') -> TokenizerOutput (Maybe TagParams')
newAttr :: TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr = (Maybe TagParams' -> Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Maybe TagParams' -> Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> ((TagParams' -> TagParams')
    -> Maybe TagParams' -> Maybe TagParams')
-> (TagParams' -> TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TagParams' -> TagParams') -> Maybe TagParams' -> Maybe TagParams'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((TagParams' -> TagParams')
 -> TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TagParams' -> TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall a b. (a -> b) -> a -> b
$ \TagParams'
d -> TagParams'
d
    { tagAttributes' :: [(String, String)]
tagAttributes' = case TagParams' -> [(String, String)]
tagAttributes' TagParams'
d of
        [] -> []
        as :: [(String, String)]
as@((String
"", String
""):[(String, String)]
_) -> [(String, String)]
as
        [(String, String)]
as -> (String
"", String
"") (String, String) -> [(String, String)] -> [(String, String)]
forall a. a -> [a] -> [a]
: [(String, String)]
as
    }

-- | Prepend a character to the unpacked key of the currently "active" metadata
-- pair in a markup element.
consAttrName :: Char -> TokenizerOutput (Maybe TagParams') -> TokenizerOutput (Maybe TagParams')
consAttrName :: Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrName Char
c = (Maybe TagParams' -> Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Maybe TagParams' -> Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> ((TagParams' -> TagParams')
    -> Maybe TagParams' -> Maybe TagParams')
-> (TagParams' -> TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TagParams' -> TagParams') -> Maybe TagParams' -> Maybe TagParams'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((TagParams' -> TagParams')
 -> TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TagParams' -> TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall a b. (a -> b) -> a -> b
$ \TagParams'
d -> TagParams'
d
    { tagAttributes' :: [(String, String)]
tagAttributes' = [(String, String)] -> [(String, String)]
consAttrName' ([(String, String)] -> [(String, String)])
-> [(String, String)] -> [(String, String)]
forall a b. (a -> b) -> a -> b
$ TagParams' -> [(String, String)]
tagAttributes' TagParams'
d
    }
  where consAttrName' :: [(String, String)] -> [(String, String)]
consAttrName' [] = [([Char
c], String
"")]
        consAttrName' ((String, String)
a:[(String, String)]
as) = ShowS -> (String, String) -> (String, String)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
F.B.first (Char
c Char -> ShowS
forall a. a -> [a] -> [a]
:) (String, String)
a (String, String) -> [(String, String)] -> [(String, String)]
forall a. a -> [a] -> [a]
: [(String, String)]
as

-- | Prepend a character to the unpacked value of the currently "active"
-- metadata pair in a markup element.
consAttrValue :: Char -> TokenizerOutput (Maybe TagParams') -> TokenizerOutput (Maybe TagParams')
consAttrValue :: Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
c = String
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValueString [Char
c]

-- | Prepend a character sequence to the unpacked value of the currently
-- "active" metadata pair in a markup element.
consAttrValueString :: String -> TokenizerOutput (Maybe TagParams') -> TokenizerOutput (Maybe TagParams')
consAttrValueString :: String
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValueString String
str = (Maybe TagParams' -> Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Maybe TagParams' -> Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> ((TagParams' -> TagParams')
    -> Maybe TagParams' -> Maybe TagParams')
-> (TagParams' -> TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TagParams' -> TagParams') -> Maybe TagParams' -> Maybe TagParams'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((TagParams' -> TagParams')
 -> TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TagParams' -> TagParams')
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall a b. (a -> b) -> a -> b
$ \TagParams'
d -> TagParams'
d
    { tagAttributes' :: [(String, String)]
tagAttributes' = [(String, String)] -> [(String, String)]
consAttrValueString' ([(String, String)] -> [(String, String)])
-> [(String, String)] -> [(String, String)]
forall a b. (a -> b) -> a -> b
$ TagParams' -> [(String, String)]
tagAttributes' TagParams'
d
    }
  where consAttrValueString' :: [(String, String)] -> [(String, String)]
consAttrValueString' [] = [(String
"", String
str)]
        consAttrValueString' ((String, String)
a:[(String, String)]
as) = ShowS -> (String, String) -> (String, String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (String
str String -> ShowS
forall a. [a] -> [a] -> [a]
++) (String, String)
a (String, String) -> [(String, String)] -> [(String, String)]
forall a. a -> [a] -> [a]
: [(String, String)]
as


-- | __HTML:__
--      @[tag open state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#tag-open-state)@
-- 
-- The parsing instructions for after reading @"\<"@ in a section of the state
-- machine which allows markup declarations.
tokenTagOpen :: Tokenizer [TokenizerOutput Token]
tokenTagOpen :: Tokenizer [TokenizerOutput Token]
tokenTagOpen = Maybe [([ParseError], Token)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)]
-> Tokenizer [TokenizerOutput Token]
forall out.
Maybe [([ParseError], out)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs out)]
-> Tokenizer [TokenizerOutput out]
tokenizers ([([ParseError], Token)] -> Maybe [([ParseError], Token)]
forall a. a -> Maybe a
Just [([ParseError
EOFBeforeTagName], Char -> Token
Character Char
'<')])
    [ (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'!') Tokenizer [TokenizerOutput Token]
tokenMarkupDeclarationOpen
    , (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') Tokenizer [TokenizerOutput Token]
tokenEndTagOpen
    , (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
(Char -> Bool)
-> Tokenizer out
-> SwitchCase TokenizerInput Tokenizer (Wrapped out)
ifPush_ Char -> Bool
isAsciiAlpha (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenTagName Tokenizer (TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> Tokenizer [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (TagParams -> Token)
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packTagToken TagParams -> Token
StartTag
    , (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
(Char -> Bool)
-> Tokenizer out
-> SwitchCase TokenizerInput Tokenizer (Wrapped out)
ifPush_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'?') (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput Token
-> [TokenizerOutput Token] -> [TokenizerOutput Token]
forall a. a -> [a] -> [a]
: []) (TokenizerOutput Token -> [TokenizerOutput Token])
-> (TokenizerOutput String -> TokenizerOutput Token)
-> TokenizerOutput String
-> [TokenizerOutput Token]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenizerOutput String -> TokenizerOutput Token
packCommentToken (TokenizerOutput String -> TokenizerOutput Token)
-> (TokenizerOutput String -> TokenizerOutput String)
-> TokenizerOutput String
-> TokenizerOutput Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
        ParseError -> TokenizerOutput String -> TokenizerOutput String
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedQuestionMarkInsteadOfTagName (TokenizerOutput String -> [TokenizerOutput Token])
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment
    , Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> Tokenizer [TokenizerOutput Token]
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
        ([ParseError], Token) -> Tokenizer [TokenizerOutput Token]
emit' ([ParseError
InvalidFirstCharacterOfTagName], Char -> Token
Character Char
'<')
    ]

-- | __HTML:__
--      @[end tag open state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#end-tag-open-state)@
-- 
-- The parsing instructions for after reading @"\</"@ in a section of the state
-- machine which allows markup declarations.
tokenEndTagOpen :: Tokenizer [TokenizerOutput Token]
tokenEndTagOpen :: Tokenizer [TokenizerOutput Token]
tokenEndTagOpen = Maybe [([ParseError], Token)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)]
-> Tokenizer [TokenizerOutput Token]
forall out.
Maybe [([ParseError], out)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs out)]
-> Tokenizer [TokenizerOutput out]
tokenizers ([([ParseError], Token)] -> Maybe [([ParseError], Token)]
forall a. a -> Maybe a
Just [([ParseError], Token)]
recovery)
    [ (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
(Char -> Bool)
-> Tokenizer out
-> SwitchCase TokenizerInput Tokenizer (Wrapped out)
ifPush_ Char -> Bool
isAsciiAlpha (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenTagName Tokenizer (TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> Tokenizer [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (TagParams -> Token)
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packTagToken TagParams -> Token
EndTag
    , (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ do
        CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState
        [ParseError] -> [TokenizerOutput Token] -> [TokenizerOutput Token]
consTokenErrorsList [ParseError
MissingEndTagName] ([TokenizerOutput Token] -> [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer [TokenizerOutput Token]
dispatcher
    , Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput Token
-> [TokenizerOutput Token] -> [TokenizerOutput Token]
forall a. a -> [a] -> [a]
: []) (TokenizerOutput Token -> [TokenizerOutput Token])
-> (TokenizerOutput String -> TokenizerOutput Token)
-> TokenizerOutput String
-> [TokenizerOutput Token]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenizerOutput String -> TokenizerOutput Token
packCommentToken (TokenizerOutput String -> TokenizerOutput Token)
-> (TokenizerOutput String -> TokenizerOutput String)
-> TokenizerOutput String
-> TokenizerOutput Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> TokenizerOutput String -> TokenizerOutput String
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
InvalidFirstCharacterOfTagName (TokenizerOutput String -> [TokenizerOutput Token])
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment
    ]
  where recovery :: [([ParseError], Token)]
recovery =
            [ ([], Char -> Token
Character Char
'<')
            , ([], Char -> Token
Character Char
'/')
            , ([ParseError
EOFBeforeTagName], Token
EndOfStream)
            ]

-- | __HTML:__
--      @[tag name state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state)@
-- 
-- The parsing instructions for after reading @"\<"@ followed by a letter in a
-- section of the state machine which allows markup declarations.
tokenTagName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenTagName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenTagName = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ Char -> Bool
isAsciiWhitespace Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenSelfClosingStartTag
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ([ParseError], Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just TagParams'
emptyTagData)
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\NUL') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedNullCharacter (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall (f :: * -> *) (f :: * -> *).
(Functor f, Functor f) =>
Char -> f (f TagParams') -> f (f TagParams')
consTagName Char
replacementChar (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenTagName
    , (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
elseChar ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall (f :: * -> *) (f :: * -> *).
(Functor f, Functor f) =>
Char -> f (f TagParams') -> f (f TagParams')
consTagName (Char -> Char
toAsciiLower Char
c) (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenTagName
    ]
  where consTagName :: Char -> f (f TagParams') -> f (f TagParams')
consTagName Char
char = (f TagParams' -> f TagParams')
-> f (f TagParams') -> f (f TagParams')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((f TagParams' -> f TagParams')
 -> f (f TagParams') -> f (f TagParams'))
-> ((TagParams' -> TagParams') -> f TagParams' -> f TagParams')
-> (TagParams' -> TagParams')
-> f (f TagParams')
-> f (f TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TagParams' -> TagParams') -> f TagParams' -> f TagParams'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((TagParams' -> TagParams')
 -> f (f TagParams') -> f (f TagParams'))
-> (TagParams' -> TagParams')
-> f (f TagParams')
-> f (f TagParams')
forall a b. (a -> b) -> a -> b
$ \TagParams'
d -> TagParams'
d
            { tagName' :: String
tagName' = Char
char Char -> ShowS
forall a. a -> [a] -> [a]
: TagParams' -> String
tagName' TagParams'
d
            }

-- | __HTML:__
--      @[before attribute name state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#before-attribute-name-state)@
-- 
-- The parsing instructions for reading whitespace interspersed with key-value
-- metadata pairs in the markup tag section of the state machine.
tokenBeforeAttributeName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ Char -> Bool
isAsciiWhitespace Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer out
-> SwitchCase TokenizerInput Tokenizer (Wrapped out)
ifPush_ (Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
"/>") Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeName
    , (Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
ifChar (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedEqualsSignBeforeAttributeName (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrName Char
c (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName
    , Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName
    ]

-- | __HTML:__
--      @[attribute name state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#attribute-name-state)@
-- 
-- The parsing instructions for reading the initial (key) part of a key-value
-- metadata pair in the markup tag section of the state machine.
tokenAttributeName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer out
-> SwitchCase TokenizerInput Tokenizer (Wrapped out)
ifPush_ (Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
"\t\n\f />") Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeName
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeValue
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\NUL') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedNullCharacter (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrName Char
replacementChar (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName
    , (Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
ifChar (Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
"\"'<") ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedCharacterInAttributeName (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrName Char
c (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName
    , (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
elseChar ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrName (Char -> Char
toAsciiLower Char
c) (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName
    ]

-- | __HTML:__
--      @[after attribute name state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#after-attribute-name-state)@
-- 
-- The parsing instructions for reading whitespace after the initial (key) part
-- of a key-value metadata pair in the markup tag section of the state machine.
tokenAfterAttributeName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeName :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeName = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ Char -> Bool
isAsciiWhitespace (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeName
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenSelfClosingStartTag
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeValue
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([ParseError], Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just TagParams'
emptyTagData)
    , Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeName
    ]

-- | __HTML:__
--      @[before attribute value state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#before-attribute-value-state)@
-- 
-- The parsing instructions for reading whitespace after @"="@ following the
-- initial (key) part of a key-value metadata pair in the markup tag section of
-- the state machine.
tokenBeforeAttributeValue :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeValue :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeValue = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ Char -> Bool
isAsciiWhitespace Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeValue
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'"') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueDoubleQuoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueSingleQuoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
        ([ParseError], Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([ParseError
MissingAttributeValue], TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just TagParams'
emptyTagData)
    , Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted
    ]

-- | __HTML:__
--      @[attribute value (double-quoted) state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#attribute-value-(double-quoted\)-state)@
-- 
-- The parsing instructions for reading the second (value) part of a key-value
-- metadata pair following a @'"'@ in the markup tag section of the state
-- machine.
tokenAttributeValueDoubleQuoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueDoubleQuoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueDoubleQuoted = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'"') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeValueQuoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'&') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeCharacterReference Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueDoubleQuoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\NUL') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedNullCharacter (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
replacementChar (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueDoubleQuoted
    , (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
elseChar ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
c (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueDoubleQuoted
    ]

-- | __HTML:__
--      @[attribute value (single-quoted) state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#attribute-value-(single-quoted\)-state)@
-- 
-- The parsing instructions for reading the second (value) part of a key-value
-- metadata pair following a @'\''@ in the markup tag section of the state
-- machine.
tokenAttributeValueSingleQuoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueSingleQuoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueSingleQuoted = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeValueQuoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'&') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeCharacterReference Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueSingleQuoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\NUL') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedNullCharacter (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
replacementChar (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueSingleQuoted
    , (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
elseChar ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
c (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueSingleQuoted
    ]

-- | __HTML:__
--      @[attribute value (unquoted) state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#attribute-value-(unquoted\)-state)@
-- 
-- The parsing instructions for reading the second (value) part of a key-value
-- metadata pair directly following a @'='@ in the markup tag section of the
-- state machine.
tokenAttributeValueUnquoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ Char -> Bool
isAsciiWhitespace (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'&') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeCharacterReference Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([ParseError], Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just TagParams'
emptyTagData)
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\NUL') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedNullCharacter (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
replacementChar (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted
    , (Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
ifChar (Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
"\"'<=`") ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c ->
        ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedCharacterInUnquotedAttributeValue (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
c (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted
    , (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
elseChar ((Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> (Char -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValue Char
c (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeValueUnquoted
    ]

-- | Resolve a character reference occurring within the second (value) part of
-- a key-value metadata pair, and continue parsing using the given tokenizer.
tokenAttributeCharacterReference
    :: Tokenizer (TokenizerOutput (Maybe TagParams'))
    -> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeCharacterReference :: Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAttributeCharacterReference Tokenizer (TokenizerOutput (Maybe TagParams'))
resume = do
    TokenizerOutput String
ref <- Bool
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenCharacterReference Bool
True
    TokenizerOutput (Maybe TagParams')
tag <- Tokenizer (TokenizerOutput (Maybe TagParams'))
resume
    TokenizerOutput (Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenizerOutput (Maybe TagParams')
 -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ParseError]
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
[ParseError] -> TokenizerOutput out -> TokenizerOutput out
consTokenErrors (TokenizerOutput String -> [ParseError]
forall out. TokenizerOutput out -> [ParseError]
tokenizedErrs TokenizerOutput String
ref) (TokenizerOutput (Maybe TagParams')
 -> Tokenizer (TokenizerOutput (Maybe TagParams')))
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ String
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
consAttrValueString (TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
ref) TokenizerOutput (Maybe TagParams')
tag

-- | __HTML:__
--      @[after attribute value (quoted) state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#after-attribute-value-(quoted\)-state)@
-- 
-- The parsing instructions for after reading a @'"'@ or @'\''@ matching the
-- opening mark of the second (value) part of a key-value metadata pair in the
-- markup tag section of the state machine.
tokenAfterAttributeValueQuoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeValueQuoted :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenAfterAttributeValueQuoted = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ Char -> Bool
isAsciiWhitespace (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenSelfClosingStartTag
    , (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([ParseError], Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just TagParams'
emptyTagData)
    , Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
MissingWhitespaceBetweenAttributes (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> TokenizerOutput (Maybe TagParams'))
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
newAttr (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName
    ]

-- | __HTML:__
--      @[self closing start tag state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#self-closing-start-tag-state)@
-- 
-- The parsing instructions for after reading @"/"@ in the markup tag section
-- of the state machine.
tokenSelfClosingStartTag :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenSelfClosingStartTag :: Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenSelfClosingStartTag = Maybe ([ParseError], Maybe TagParams')
-> [SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))]
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], Maybe TagParams')
-> Maybe ([ParseError], Maybe TagParams')
forall a. a -> Maybe a
Just ([ParseError
EOFInTag], Maybe TagParams'
forall a. Maybe a
Nothing))
    [ (Char -> Bool)
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([ParseError], Maybe TagParams')
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just (TagParams' -> Maybe TagParams') -> TagParams' -> Maybe TagParams'
forall a b. (a -> b) -> a -> b
$ TagParams'
emptyTagData
        { tagIsSelfClosing' :: Bool
tagIsSelfClosing' = Bool
True
        })
    , Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer (TokenizerOutput (Maybe TagParams'))
 -> SwitchCase
      TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams')))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> SwitchCase
     TokenizerInput Tokenizer (WrappedOutput (Maybe TagParams'))
forall a b. (a -> b) -> a -> b
$ ParseError
-> TokenizerOutput (Maybe TagParams')
-> TokenizerOutput (Maybe TagParams')
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedSolidusInTag (TokenizerOutput (Maybe TagParams')
 -> TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
-> Tokenizer (TokenizerOutput (Maybe TagParams'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName
    ]

-- | __HTML:__
--      @[bogus comment state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#bogus-comment-state)@
-- 
-- The parsing instructions for after reading @"\<?"@ in a section of the state
-- machine which allows markup declarations.
tokenBogusComment :: Tokenizer (TokenizerOutput String)
tokenBogusComment :: StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment = Maybe ([ParseError], String)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput String)]
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], String) -> Maybe ([ParseError], String)
forall a. a -> Maybe a
Just ([], String
""))
    [ (Char -> Bool)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (StateT
   TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutput String))
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall a b. (a -> b) -> a -> b
$ CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState Tokenizer ()
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([ParseError], String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], String
"")
    , (Char -> Bool)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall out.
(Char -> Bool)
-> Tokenizer (TokenizerOutput out)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
if_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\NUL') (StateT
   TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutput String))
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall a b. (a -> b) -> a -> b
$ ParseError -> TokenizerOutput String -> TokenizerOutput String
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
UnexpectedNullCharacter (TokenizerOutput String -> TokenizerOutput String)
-> (TokenizerOutput String -> TokenizerOutput String)
-> TokenizerOutput String
-> TokenizerOutput String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> TokenizerOutput String -> TokenizerOutput String
forall out. out -> TokenizerOutput [out] -> TokenizerOutput [out]
consOut Char
replacementChar (TokenizerOutput String -> TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment
    , (Char
 -> StateT
      TokenParserState
      (Parser [TokenizerInput])
      (TokenizerOutput String))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall out.
(Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
elseChar ((Char
  -> StateT
       TokenParserState
       (Parser [TokenizerInput])
       (TokenizerOutput String))
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutput String))
-> (Char
    -> StateT
         TokenParserState
         (Parser [TokenizerInput])
         (TokenizerOutput String))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char -> TokenizerOutput String -> TokenizerOutput String
forall out. out -> TokenizerOutput [out] -> TokenizerOutput [out]
consOut Char
c (TokenizerOutput String -> TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment
    ]

-- | __HTML:__
--      @[markup declaration open state]
--      (https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state)@
-- 
-- The parsing instructions for after reading @"\<!"@ in a section of the state
-- machine which allows markup declarations.
tokenMarkupDeclarationOpen :: Tokenizer [TokenizerOutput Token]
tokenMarkupDeclarationOpen :: Tokenizer [TokenizerOutput Token]
tokenMarkupDeclarationOpen = do
    Tokenizer [TokenizerOutput Token]
parserChoice <- [StateT
   TokenParserState
   (Parser [TokenizerInput])
   (Tokenizer [TokenizerOutput Token])]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (m :: * -> *) a. Alternative m => [m a] -> m a
choice
        [ (Char -> Char) -> String -> Tokenizer [TokenizerInput]
chunk' Char -> Char
forall a. a -> a
id String
"--" Tokenizer [TokenizerInput]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokenizer [TokenizerOutput Token]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (m :: * -> *) a. Monad m => a -> m a
return Tokenizer [TokenizerOutput Token]
commentParser
        , (Char -> Char) -> String -> Tokenizer [TokenizerInput]
chunk' Char -> Char
toAsciiUpper String
"DOCTYPE" Tokenizer [TokenizerInput]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokenizer [TokenizerOutput Token]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (m :: * -> *) a. Monad m => a -> m a
return Tokenizer [TokenizerOutput Token]
doctypeParser
        , (Char -> Char) -> String -> Tokenizer [TokenizerInput]
chunk' Char -> Char
forall a. a -> a
id String
"[CDATA[" Tokenizer [TokenizerInput]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Tokenizer [TokenizerOutput Token]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (m :: * -> *) a. Monad m => a -> m a
return Tokenizer [TokenizerOutput Token]
cdataParser
        , Tokenizer [TokenizerOutput Token]
-> StateT
     TokenParserState
     (Parser [TokenizerInput])
     (Tokenizer [TokenizerOutput Token])
forall (m :: * -> *) a. Monad m => a -> m a
return Tokenizer [TokenizerOutput Token]
failureParser
        ]
    Tokenizer [TokenizerOutput Token]
parserChoice
  where commentParser :: Tokenizer [TokenizerOutput Token]
commentParser = (TokenizerOutput String -> [TokenizerOutput Token])
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TokenizerOutput Token -> [TokenizerOutput Token]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TokenizerOutput Token -> [TokenizerOutput Token])
-> (TokenizerOutput String -> TokenizerOutput Token)
-> TokenizerOutput String
-> [TokenizerOutput Token]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenizerOutput String -> TokenizerOutput Token
packCommentToken) StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenCommentStart
        doctypeParser :: Tokenizer [TokenizerOutput Token]
doctypeParser = (TokenizerOutput Token -> [TokenizerOutput Token])
-> Tokenizer (TokenizerOutput Token)
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TokenizerOutput Token -> [TokenizerOutput Token]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Tokenizer (TokenizerOutput Token)
tokenDoctype
        cdataParser :: Tokenizer [TokenizerOutput Token]
cdataParser = do
            Maybe ElementName
currentNamespace <- TokenParserState -> Maybe ElementName
currentNodeNamespace (TokenParserState -> Maybe ElementName)
-> StateT
     TokenParserState (Parser [TokenizerInput]) TokenParserState
-> StateT
     TokenParserState (Parser [TokenizerInput]) (Maybe ElementName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT TokenParserState (Parser [TokenizerInput]) TokenParserState
forall (m :: * -> *) s. Monad m => StateT s m s
N.S.get
            case Maybe ElementName
currentNamespace of
                Just ElementName
ns | ElementName
ns ElementName -> ElementName -> Bool
forall a. Eq a => a -> a -> Bool
/= ElementName
htmlNamespace ->
                    CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
CDataState Tokenizer ()
-> [TokenizerOutput Token] -> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> []
                Maybe ElementName
_ -> TokenizerOutput Token -> [TokenizerOutput Token]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TokenizerOutput Token -> [TokenizerOutput Token])
-> (TokenizerOutput String -> TokenizerOutput Token)
-> TokenizerOutput String
-> [TokenizerOutput Token]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenizerOutput String -> TokenizerOutput Token
packCommentToken (TokenizerOutput String -> TokenizerOutput Token)
-> (TokenizerOutput String -> TokenizerOutput String)
-> TokenizerOutput String
-> TokenizerOutput Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    ParseError -> TokenizerOutput String -> TokenizerOutput String
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
CDataInHtmlContent (TokenizerOutput String -> TokenizerOutput String)
-> (TokenizerOutput String -> TokenizerOutput String)
-> TokenizerOutput String
-> TokenizerOutput String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> TokenizerOutput String -> TokenizerOutput String
forall out. [out] -> TokenizerOutput [out] -> TokenizerOutput [out]
consOuts String
"[CDATA[" (TokenizerOutput String -> [TokenizerOutput Token])
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                    StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment
        failureParser :: Tokenizer [TokenizerOutput Token]
failureParser = TokenizerOutput Token -> [TokenizerOutput Token]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TokenizerOutput Token -> [TokenizerOutput Token])
-> (TokenizerOutput String -> TokenizerOutput Token)
-> TokenizerOutput String
-> [TokenizerOutput Token]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenizerOutput String -> TokenizerOutput Token
packCommentToken (TokenizerOutput String -> TokenizerOutput Token)
-> (TokenizerOutput String -> TokenizerOutput String)
-> TokenizerOutput String
-> TokenizerOutput Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
            ParseError -> TokenizerOutput String -> TokenizerOutput String
forall out.
ParseError -> TokenizerOutput out -> TokenizerOutput out
consTokenError ParseError
IncorrectlyOpenedComment (TokenizerOutput String -> [TokenizerOutput Token])
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenBogusComment


-- | __HTML:__
-- 
--    * [@RAWTEXT less-than sign state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#rawtext-less-than-sign-state)
--    * [@RCDATA less-than sign state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#rcdata-less-than-sign-state)
-- 
-- The parsing instructions for after reading @"\<"@ in sections of the state
-- machine which may be closed by tag, and which emit only 'Character' tokens.
tokenAppropriateEndTagLessThanSign :: Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTagLessThanSign :: Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTagLessThanSign = Maybe [([ParseError], Token)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)]
-> Tokenizer [TokenizerOutput Token]
forall out.
Maybe [([ParseError], out)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs out)]
-> Tokenizer [TokenizerOutput out]
tokenizers ([([ParseError], Token)] -> Maybe [([ParseError], Token)]
forall a. a -> Maybe a
Just [([], Char -> Token
Character Char
'<')])
    [ (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTagOpen
    , Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ ([ParseError], Token) -> Tokenizer [TokenizerOutput Token]
emit' ([], Char -> Token
Character Char
'<')
    ]

-- | __HTML:__
-- 
--    * [@RAWTEXT end tag open state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#rawtext-end-tag-open-state)
--    * [@RCDATA end tag open state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#rcdata-end-tag-open-state)
--    * [@script data end tag open state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#script-data-end-tag-open-state)
--    * [@script data escaped end tag open state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#script-data-escaped-end-tag-open-state)
-- 
-- The parsing instructions for after reading @"\</"@ in sections of the state
-- machine which may be closed by tag, and which emit only 'Character' tokens.
tokenAppropriateEndTagOpen :: Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTagOpen :: Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTagOpen = Maybe [([ParseError], Token)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)]
-> Tokenizer [TokenizerOutput Token]
forall out.
Maybe [([ParseError], out)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs out)]
-> Tokenizer [TokenizerOutput out]
tokenizers ([([ParseError], Token)] -> Maybe [([ParseError], Token)]
forall a. a -> Maybe a
Just [([], Char -> Token
Character Char
'<'), ([], Char -> Token
Character Char
'/')])
    [ (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
(Char -> Bool)
-> Tokenizer out
-> SwitchCase TokenizerInput Tokenizer (Wrapped out)
ifPush_ Char -> Bool
isAsciiAlpha Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTag
    , Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ (([ParseError], Token) -> Tokenizer (TokenizerOutput Token))
-> [([ParseError], Token)] -> Tokenizer [TokenizerOutput Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([ParseError], Token) -> Tokenizer (TokenizerOutput Token)
emit
        [ ([], Char -> Token
Character Char
'<')
        , ([], Char -> Token
Character Char
'/')
        ]
    ]

-- | __HTML:__
-- 
--    * [@RAWTEXT end tag name state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#rawtext-end-tag-name-state)
--    * [@RCDATA end tag name state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#rcdata-end-tag-name-state)
--    * [@script data end tag name state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#script-data-end-tag-name-state)
--    * [@script data escaped end tag name state@]
--      (https://html.spec.whatwg.org/multipage/parsing.html#script-data-escaped-end-tag-name-state)
-- 
-- The parsing instructions for after reading @"\</"@ in sections of the state
-- machine which may be closed by tag, and which emit only 'Character' tokens.
tokenAppropriateEndTag :: Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTag :: Tokenizer [TokenizerOutput Token]
tokenAppropriateEndTag = StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenAppropriateEndTagName StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> (TokenizerOutput String -> Tokenizer [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TokenizerOutput String
t' -> do
    Bool
close <- String -> StateT TokenParserState (Parser [TokenizerInput]) Bool
appropriateEndTag ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toAsciiLower ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
t')
    if Bool
close
        then Maybe [([ParseError], Token)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)]
-> Tokenizer [TokenizerOutput Token]
forall out.
Maybe [([ParseError], out)]
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutputs out)]
-> Tokenizer [TokenizerOutput out]
tokenizers ([([ParseError], Token)] -> Maybe [([ParseError], Token)]
forall a. a -> Maybe a
Just ([([ParseError], Token)] -> Maybe [([ParseError], Token)])
-> [([ParseError], Token)] -> Maybe [([ParseError], Token)]
forall a b. (a -> b) -> a -> b
$ TokenizerOutput String -> [([ParseError], Token)]
fallback TokenizerOutput String
t')
            [ (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ Char -> Bool
isAsciiWhitespace (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$
                Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenBeforeAttributeName Tokenizer (TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> Tokenizer [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packName (TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
t')
            , (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$
                Tokenizer (TokenizerOutput (Maybe TagParams'))
tokenSelfClosingStartTag Tokenizer (TokenizerOutput (Maybe TagParams'))
-> (TokenizerOutput (Maybe TagParams')
    -> Tokenizer [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packName (TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
t')
            , (Char -> Bool)
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
ifs_ (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>') (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ do
                CurrentTokenizerState -> Tokenizer ()
changeState CurrentTokenizerState
DataState
                [TokenizerOutput Token]
out <- String
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packName (TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
t') (TokenizerOutput (Maybe TagParams')
 -> Tokenizer [TokenizerOutput Token])
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
forall a b. (a -> b) -> a -> b
$ TokenizerOutput String
t'
                    { tokenizedOut :: Maybe TagParams'
tokenizedOut = TagParams' -> Maybe TagParams'
forall a. a -> Maybe a
Just TagParams'
emptyTagData
                    }
                -- 'packName' keeps the state of the input (i.e. /before/ the
                -- closing @>@), and so that needs to be cleared so 'ifs_' will
                -- assign the state of the input token (/after/ the closing
                -- @>@).
                [TokenizerOutput Token] -> Tokenizer [TokenizerOutput Token]
forall (m :: * -> *) a. Monad m => a -> m a
return ([TokenizerOutput Token] -> Tokenizer [TokenizerOutput Token])
-> [TokenizerOutput Token] -> Tokenizer [TokenizerOutput Token]
forall a b. (a -> b) -> a -> b
$ (TokenizerOutput Token -> TokenizerOutput Token)
-> [TokenizerOutput Token] -> [TokenizerOutput Token]
forall a b. (a -> b) -> [a] -> [b]
map TokenizerOutput Token -> TokenizerOutput Token
forall out. TokenizerOutput out -> TokenizerOutput out
continueState [TokenizerOutput Token]
out
            , Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (Tokenizer [TokenizerOutput Token]
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token))
-> Tokenizer [TokenizerOutput Token]
-> SwitchCase TokenizerInput Tokenizer (WrappedOutputs Token)
forall a b. (a -> b) -> a -> b
$ DecoderOutputState
-> [([ParseError], Token)] -> Tokenizer [TokenizerOutput Token]
emits (TokenizerOutput String -> DecoderOutputState
forall out. TokenizerOutput out -> DecoderOutputState
tokenizedState TokenizerOutput String
t') ([ParseError] -> String -> [([ParseError], Token)]
forall a. [a] -> String -> [([a], Token)]
anythingElse (TokenizerOutput String -> [ParseError]
forall out. TokenizerOutput out -> [ParseError]
tokenizedErrs TokenizerOutput String
t') (TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
t'))
            ]
        else DecoderOutputState
-> [([ParseError], Token)] -> Tokenizer [TokenizerOutput Token]
emits (TokenizerOutput String -> DecoderOutputState
forall out. TokenizerOutput out -> DecoderOutputState
tokenizedState TokenizerOutput String
t') (TokenizerOutput String -> [([ParseError], Token)]
fallback TokenizerOutput String
t')
  where fallback :: TokenizerOutput String -> [([ParseError], Token)]
fallback TokenizerOutput String
t' = [ParseError] -> String -> [([ParseError], Token)]
forall a. [a] -> String -> [([a], Token)]
anythingElse (TokenizerOutput String -> [ParseError]
forall out. TokenizerOutput out -> [ParseError]
tokenizedErrs TokenizerOutput String
t') (TokenizerOutput String -> String
forall out. TokenizerOutput out -> out
tokenizedOut TokenizerOutput String
t')
        packName :: String
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packName String
buffer = (TagParams -> Token)
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
packTagToken ((TagParams -> Token)
 -> TokenizerOutput (Maybe TagParams')
 -> Tokenizer [TokenizerOutput Token])
-> (TagParams -> Token)
-> TokenizerOutput (Maybe TagParams')
-> Tokenizer [TokenizerOutput Token]
forall a b. (a -> b) -> a -> b
$ TagParams -> Token
EndTag (TagParams -> Token)
-> (TagParams -> TagParams) -> TagParams -> Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElementName -> TagParams -> TagParams
packName' (String -> ElementName
T.pack String
buffer)
        packName' :: ElementName -> TagParams -> TagParams
packName' ElementName
buffer TagParams
tagData = TagParams
tagData
            { tagName :: ElementName
tagName = (Char -> Char) -> ElementName -> ElementName
T.map Char -> Char
toAsciiLower ElementName
buffer
            }
        anythingElse :: [a] -> String -> [([a], Token)]
anythingElse [a]
errs String
buffer =
            [ ([], Char -> Token
Character Char
'<')
            , ([], Char -> Token
Character Char
'/')
            ] [([a], Token)] -> [([a], Token)] -> [([a], Token)]
forall a. [a] -> [a] -> [a]
++ case String
buffer of
                [] -> []
                (Char
c:String
cs) -> ([a]
errs, Char -> Token
Character Char
c) ([a], Token) -> [([a], Token)] -> [([a], Token)]
forall a. a -> [a] -> [a]
: [([], Char -> Token
Character Char
c') | Char
c' <- String
cs]
        emits :: DecoderOutputState
-> [([ParseError], Token)] -> Tokenizer [TokenizerOutput Token]
emits DecoderOutputState
state [([ParseError], Token)]
ts = DecoderOutputState
-> [TokenizerOutput Token] -> [TokenizerOutput Token]
forall out.
DecoderOutputState
-> [TokenizerOutput out] -> [TokenizerOutput out]
finalStateList DecoderOutputState
state ([TokenizerOutput Token] -> [TokenizerOutput Token])
-> Tokenizer [TokenizerOutput Token]
-> Tokenizer [TokenizerOutput Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (([ParseError], Token) -> Tokenizer (TokenizerOutput Token))
-> [([ParseError], Token)] -> Tokenizer [TokenizerOutput Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([ParseError], Token) -> Tokenizer (TokenizerOutput Token)
emit [([ParseError], Token)]
ts
        tokenAppropriateEndTagName :: StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenAppropriateEndTagName = Maybe ([ParseError], String)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput String)]
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall out.
Maybe ([ParseError], out)
-> [SwitchCase TokenizerInput Tokenizer (WrappedOutput out)]
-> Tokenizer (TokenizerOutput out)
tokenizer (([ParseError], String) -> Maybe ([ParseError], String)
forall a. a -> Maybe a
Just ([], String
""))
            [ (Char -> Bool)
-> (Char
    -> StateT
         TokenParserState
         (Parser [TokenizerInput])
         (TokenizerOutput String))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall out.
(Char -> Bool)
-> (Char -> Tokenizer (TokenizerOutput out))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput out)
ifChar Char -> Bool
isAsciiAlpha ((Char
  -> StateT
       TokenParserState
       (Parser [TokenizerInput])
       (TokenizerOutput String))
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutput String))
-> (Char
    -> StateT
         TokenParserState
         (Parser [TokenizerInput])
         (TokenizerOutput String))
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall a b. (a -> b) -> a -> b
$ \Char
c -> Char -> TokenizerOutput String -> TokenizerOutput String
forall out. out -> TokenizerOutput [out] -> TokenizerOutput [out]
consOut Char
c (TokenizerOutput String -> TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
tokenAppropriateEndTagName
            , StateT
  TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall out.
Tokenizer out -> SwitchCase TokenizerInput Tokenizer (Wrapped out)
elsePush_ (StateT
   TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
 -> SwitchCase TokenizerInput Tokenizer (WrappedOutput String))
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
-> SwitchCase TokenizerInput Tokenizer (WrappedOutput String)
forall a b. (a -> b) -> a -> b
$ ([ParseError], String)
-> StateT
     TokenParserState (Parser [TokenizerInput]) (TokenizerOutput String)
forall out. ([ParseError], out) -> Tokenizer (TokenizerOutput out)
packToken ([], String
"")
            ]