{- This module was generated from data in the Kate syntax
   highlighting file html.xml, version 3, by Wilbert Berendsen (wilbert@kde.nl) -}

module Text.Highlighting.Kate.Syntax.Html
          (highlight, parseExpression, syntaxName, syntaxExtensions)
where
import Text.Highlighting.Kate.Types
import Text.Highlighting.Kate.Common
import qualified Text.Highlighting.Kate.Syntax.Alert
import qualified Text.Highlighting.Kate.Syntax.Css
import qualified Text.Highlighting.Kate.Syntax.Javascript
import Text.ParserCombinators.Parsec hiding (State)
import Control.Monad.State
import Data.Char (isSpace)

-- | Full name of language.
syntaxName :: String
syntaxName :: [Char]
syntaxName = [Char]
"HTML"

-- | Filename extensions for this language.
syntaxExtensions :: String
syntaxExtensions :: [Char]
syntaxExtensions = [Char]
"*.htm;*.html;*.shtml;*.shtm"

-- | Highlight source code using this syntax definition.
highlight :: String -> [SourceLine]
highlight :: [Char] -> [SourceLine]
highlight [Char]
input = State SyntaxState [SourceLine] -> SyntaxState -> [SourceLine]
forall s a. State s a -> s -> a
evalState (([Char] -> StateT SyntaxState Identity SourceLine)
-> [[Char]] -> State SyntaxState [SourceLine]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM [Char] -> StateT SyntaxState Identity SourceLine
parseSourceLine ([[Char]] -> State SyntaxState [SourceLine])
-> [[Char]] -> State SyntaxState [SourceLine]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
lines [Char]
input) SyntaxState
startingState

parseSourceLine :: String -> State SyntaxState SourceLine
parseSourceLine :: [Char] -> StateT SyntaxState Identity SourceLine
parseSourceLine = KateParser Token
-> [Char] -> StateT SyntaxState Identity SourceLine
mkParseSourceLine (Maybe ([Char], [Char]) -> KateParser Token
parseExpression Maybe ([Char], [Char])
forall a. Maybe a
Nothing)

-- | Parse an expression using appropriate local context.
parseExpression :: Maybe (String,String)
                -> KateParser Token
parseExpression :: Maybe ([Char], [Char]) -> KateParser Token
parseExpression Maybe ([Char], [Char])
mbcontext = do
  ([Char]
lang,[Char]
cont) <- KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser ([Char], [Char]))
-> Maybe ([Char], [Char])
-> KateParser ([Char], [Char])
forall b a. b -> (a -> b) -> Maybe a -> b
maybe KateParser ([Char], [Char])
currentContext ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ([Char], [Char])
mbcontext
  Token
result <- ([Char], [Char]) -> KateParser Token
parseRules ([Char]
lang,[Char]
cont)
  ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT [Char] SyntaxState Identity ()
 -> ParsecT [Char] SyntaxState Identity ())
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ do ParsecT [Char] SyntaxState Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
                (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState)
 -> ParsecT [Char] SyntaxState Identity ())
-> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevChar :: Char
synStPrevChar = Char
'\n' }
                ParsecT [Char] SyntaxState Identity ()
pEndLine
  Token -> KateParser Token
forall (m :: * -> *) a. Monad m => a -> m a
return Token
result

startingState :: SyntaxState
startingState = SyntaxState :: ContextStack
-> Int
-> Char
-> Bool
-> Bool
-> Bool
-> Bool
-> [[Char]]
-> SyntaxState
SyntaxState {synStContexts :: ContextStack
synStContexts = [([Char]
"HTML",[Char]
"Start")], synStLineNumber :: Int
synStLineNumber = Int
0, synStPrevChar :: Char
synStPrevChar = Char
'\n', synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False, synStContinuation :: Bool
synStContinuation = Bool
False, synStCaseSensitive :: Bool
synStCaseSensitive = Bool
True, synStKeywordCaseSensitive :: Bool
synStKeywordCaseSensitive = Bool
True, synStCaptures :: [[Char]]
synStCaptures = []}

pEndLine :: ParsecT [Char] SyntaxState Identity ()
pEndLine = do
  (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState)
 -> ParsecT [Char] SyntaxState Identity ())
-> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStPrevNonspace :: Bool
synStPrevNonspace = Bool
False }
  ([Char], [Char])
context <- KateParser ([Char], [Char])
currentContext
  ContextStack
contexts <- SyntaxState -> ContextStack
synStContexts (SyntaxState -> ContextStack)
-> ParsecT [Char] SyntaxState Identity SyntaxState
-> ParsecT [Char] SyntaxState Identity ContextStack
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ParsecT [Char] SyntaxState Identity SyntaxState
forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  SyntaxState
st <- ParsecT [Char] SyntaxState Identity SyntaxState
forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  if ContextStack -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ContextStack
contexts Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
2
    then case ([Char], [Char])
context of
      ([Char], [Char])
_ | SyntaxState -> Bool
synStContinuation SyntaxState
st -> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState)
 -> ParsecT [Char] SyntaxState Identity ())
-> (SyntaxState -> SyntaxState)
-> ParsecT [Char] SyntaxState Identity ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st{ synStContinuation :: Bool
synStContinuation = Bool
False }
      ([Char]
"HTML",[Char]
"Start") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"FindHTML") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"FindEntityRefs") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"FindPEntityRefs") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"FindAttributes") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"FindDTDRules") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Comment") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"CDATA") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"PI") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Doctype") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Doctype Internal Subset") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Doctype Markupdecl") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Doctype Markupdecl DQ") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Doctype Markupdecl SQ") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"El Open") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"El Close") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"El Close 2") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"El Close 3") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"CSS") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"CSS content") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"JS") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"JS content") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"JS comment close") -> (ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"HTML",[Char]
"Value") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Value NQ") -> (ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
pEndLine
      ([Char]
"HTML",[Char]
"Value DQ") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char]
"HTML",[Char]
"Value SQ") -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      ([Char], [Char])
_ -> () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    else () -> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

withAttribute :: a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute a
attr [Char]
txt = do
  Bool -> ParsecT s SyntaxState m () -> ParsecT s SyntaxState m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([Char] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
txt) (ParsecT s SyntaxState m () -> ParsecT s SyntaxState m ())
-> ParsecT s SyntaxState m () -> ParsecT s SyntaxState m ()
forall a b. (a -> b) -> a -> b
$ [Char] -> ParsecT s SyntaxState m ()
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Parser matched no text"
  (SyntaxState -> SyntaxState) -> ParsecT s SyntaxState m ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState ((SyntaxState -> SyntaxState) -> ParsecT s SyntaxState m ())
-> (SyntaxState -> SyntaxState) -> ParsecT s SyntaxState m ()
forall a b. (a -> b) -> a -> b
$ \SyntaxState
st -> SyntaxState
st { synStPrevChar :: Char
synStPrevChar = [Char] -> Char
forall a. [a] -> a
last [Char]
txt
                          , synStPrevNonspace :: Bool
synStPrevNonspace = SyntaxState -> Bool
synStPrevNonspace SyntaxState
st Bool -> Bool -> Bool
|| Bool -> Bool
not ((Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isSpace [Char]
txt) }
  (a, [Char]) -> ParsecT s SyntaxState m (a, [Char])
forall (m :: * -> *) a. Monad m => a -> m a
return (a
attr, [Char]
txt)


regex_'3c'21DOCTYPE'5cs'2b :: Regex
regex_'3c'21DOCTYPE'5cs'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<!DOCTYPE\\s+"
regex_'3c'5c'3f'5b'5cw'3a'2d'5d'2a :: Regex
regex_'3c'5c'3f'5b'5cw'3a'2d'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<\\?[\\w:-]*"
regex_'3cstyle'5cb :: Regex
regex_'3cstyle'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<style\\b"
regex_'3cscript'5cb :: Regex
regex_'3cscript'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<script\\b"
regex_'3cpre'5cb :: Regex
regex_'3cpre'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<pre\\b"
regex_'3cdiv'5cb :: Regex
regex_'3cdiv'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<div\\b"
regex_'3ctable'5cb :: Regex
regex_'3ctable'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<table\\b"
regex_'3cul'5cb :: Regex
regex_'3cul'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<ul\\b"
regex_'3col'5cb :: Regex
regex_'3col'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<ol\\b"
regex_'3cdl'5cb :: Regex
regex_'3cdl'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<dl\\b"
regex_'3carticle'5cb :: Regex
regex_'3carticle'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<article\\b"
regex_'3caside'5cb :: Regex
regex_'3caside'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<aside\\b"
regex_'3cdetails'5cb :: Regex
regex_'3cdetails'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<details\\b"
regex_'3cfigure'5cb :: Regex
regex_'3cfigure'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<figure\\b"
regex_'3cfooter'5cb :: Regex
regex_'3cfooter'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<footer\\b"
regex_'3cheader'5cb :: Regex
regex_'3cheader'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<header\\b"
regex_'3cmain'5cb :: Regex
regex_'3cmain'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<main\\b"
regex_'3cnav'5cb :: Regex
regex_'3cnav'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<nav\\b"
regex_'3csection'5cb :: Regex
regex_'3csection'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<section\\b"
regex_'3c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a :: Regex
regex_'3c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<[A-Za-z_:][\\w.:_-]*"
regex_'3c'2fpre'5cb :: Regex
regex_'3c'2fpre'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</pre\\b"
regex_'3c'2fdiv'5cb :: Regex
regex_'3c'2fdiv'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</div\\b"
regex_'3c'2ftable'5cb :: Regex
regex_'3c'2ftable'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</table\\b"
regex_'3c'2ful'5cb :: Regex
regex_'3c'2ful'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</ul\\b"
regex_'3c'2fol'5cb :: Regex
regex_'3c'2fol'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</ol\\b"
regex_'3c'2fdl'5cb :: Regex
regex_'3c'2fdl'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</dl\\b"
regex_'3c'2farticle'5cb :: Regex
regex_'3c'2farticle'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</article\\b"
regex_'3c'2faside'5cb :: Regex
regex_'3c'2faside'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</aside\\b"
regex_'3c'2fdetails'5cb :: Regex
regex_'3c'2fdetails'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</details\\b"
regex_'3c'2ffigure'5cb :: Regex
regex_'3c'2ffigure'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</figure\\b"
regex_'3c'2ffooter'5cb :: Regex
regex_'3c'2ffooter'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</footer\\b"
regex_'3c'2fheader'5cb :: Regex
regex_'3c'2fheader'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</header\\b"
regex_'3c'2fmain'5cb :: Regex
regex_'3c'2fmain'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</main\\b"
regex_'3c'2fnav'5cb :: Regex
regex_'3c'2fnav'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</nav\\b"
regex_'3c'2fsection'5cb :: Regex
regex_'3c'2fsection'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</section\\b"
regex_'3c'2f'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a :: Regex
regex_'3c'2f'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</[A-Za-z_:][\\w.:_-]*"
regex_'26'28'23'5b0'2d9'5d'2b'7c'23'5bxX'5d'5b0'2d9A'2dFa'2df'5d'2b'7c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'29'3b :: Regex
regex_'26'28'23'5b0'2d9'5d'2b'7c'23'5bxX'5d'5b0'2d9A'2dFa'2df'5d'2b'7c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'29'3b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);"
regex_'25'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'3b :: Regex
regex_'25'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'3b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"%[A-Za-z_:][\\w.:_-]*;"
regex_'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a :: Regex
regex_'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[A-Za-z_:][\\w.:_-]*"
regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a :: Regex
regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\s+[A-Za-z_:][\\w.:_-]*"
regex_'3c'21'28ELEMENT'7cENTITY'7cATTLIST'7cNOTATION'29'5cb :: Regex
regex_'3c'21'28ELEMENT'7cENTITY'7cATTLIST'7cNOTATION'29'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"<!(ELEMENT|ENTITY|ATTLIST|NOTATION)\\b"
regex_'2d'28'2d'28'3f'21'2d'3e'29'29'2b :: Regex
regex_'2d'28'2d'28'3f'21'2d'3e'29'29'2b = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"-(-(?!->))+"
regex_'5cS :: Regex
regex_'5cS = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"\\S"
regex_'3c'2fstyle'5cb :: Regex
regex_'3c'2fstyle'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</style\\b"
regex_'3c'2fscript'5cb :: Regex
regex_'3c'2fscript'5cb = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"</script\\b"
regex_'2f'2f'28'3f'3d'2e'2a'3c'2fscript'5cb'29 :: Regex
regex_'2f'2f'28'3f'3d'2e'2a'3c'2fscript'5cb'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"//(?=.*</script\\b)"
regex_'2f'28'3f'21'3e'29 :: Regex
regex_'2f'28'3f'21'3e'29 = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"/(?!>)"
regex_'5b'5e'2f'3e'3c'22'27'5cs'5d :: Regex
regex_'5b'5e'2f'3e'3c'22'27'5cs'5d = Bool -> [Char] -> Regex
compileRegex Bool
True [Char]
"[^/><\"'\\s]"

parseRules :: ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"Start") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindHTML")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Start")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"FindHTML") =
  (((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity [Char]
pDetectIdentifier ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"<!--" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Comment"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"<![CDATA[" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"CDATA"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'21DOCTYPE'5cs'2b ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Doctype"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'5c'3f'5b'5cw'3a'2d'5d'2a ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"PI"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cstyle'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"CSS"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cscript'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"JS"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cpre'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cdiv'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3ctable'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cul'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3col'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cdl'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3carticle'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3caside'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cdetails'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cfigure'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cfooter'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cheader'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cmain'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3cnav'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3csection'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Open"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fpre'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fdiv'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2ftable'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2ful'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fol'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fdl'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2farticle'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2faside'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fdetails'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2ffigure'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2ffooter'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fheader'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fmain'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fnav'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fsection'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2f'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindDTDRules")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"FindHTML")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"FindEntityRefs") =
  (((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'26'28'23'5b0'2d9'5d'2b'7c'23'5bxX'5d'5b0'2d9A'2dFa'2df'5d'2b'7c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'29'3b ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"&<" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"FindEntityRefs")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"FindPEntityRefs") =
  (((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'26'28'23'5b0'2d9'5d'2b'7c'23'5bxX'5d'5b0'2d9A'2dFa'2df'5d'2b'7c'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'29'3b ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'25'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'3b ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char] -> ParsecT [Char] SyntaxState Identity [Char]
pAnyChar [Char]
"&%" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"FindPEntityRefs")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"FindAttributes") =
  (((Int -> ParsecT [Char] SyntaxState Identity ()
forall tok st. Int -> GenParser tok st ()
pColumn Int
0 ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'=' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
OtherTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Value"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"FindAttributes")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"FindDTDRules") =
  (((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'21'28ELEMENT'7cENTITY'7cATTLIST'7cNOTATION'29'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Doctype Markupdecl"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"FindDTDRules")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"Comment") =
  (((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
"Alerts",[Char]
"")) KateParser Token -> (Token -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) ([Char] -> KateParser Token)
-> (Token -> [Char]) -> Token -> KateParser Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> [Char]
forall a b. (a, b) -> b
snd)))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity [Char]
pDetectIdentifier ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"-->" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2d'28'2d'28'3f'21'2d'3e'29'29'2b ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Comment")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))

parseRules ([Char]
"HTML",[Char]
"CDATA") =
  (((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity [Char]
pDetectIdentifier ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"]]>" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
BaseNTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"]]&gt;" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DecValTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"CDATA")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"PI") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'?' Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"PI")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"Doctype") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'[' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Doctype Internal Subset"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Doctype")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"Doctype Internal Subset") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
']' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindDTDRules")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> [Char] -> ParsecT [Char] SyntaxState Identity [Char]
pString Bool
False [Char]
"<!--" ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Comment"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'5c'3f'5b'5cw'3a'2d'5d'2a ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"PI"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindPEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Doctype Internal Subset")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"Doctype Markupdecl") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
DataTypeTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Doctype Markupdecl DQ"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Doctype Markupdecl SQ"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Doctype Markupdecl")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"Doctype Markupdecl DQ") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindPEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Doctype Markupdecl DQ")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))

parseRules ([Char]
"HTML",[Char]
"Doctype Markupdecl SQ") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindPEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Doctype Markupdecl SQ")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))

parseRules ([Char]
"HTML",[Char]
"El Open") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'/' Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindAttributes")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cS ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"El Open")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"El Close") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cS ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"El Close")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"El Close 2") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cS ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"El Close 2")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"El Close 3") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cS ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"El Close 3")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"CSS") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'/' Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"CSS content"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindAttributes")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cS ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"CSS")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"CSS content") =
  (((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fstyle'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close 2"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Css.parseExpression (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
"CSS",[Char]
""))))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"CSS content")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"JS") =
  (((Bool -> Char -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetect2Chars Bool
False Char
'/' Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'>' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"JS content"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindAttributes")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5cS ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
ErrorTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"JS")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"JS content") =
  (((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fscript'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close 2"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2f'2f'28'3f'3d'2e'2a'3c'2fscript'5cb'29 ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"JS comment close"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Javascript.parseExpression (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
"JavaScript",[Char]
"Normal"))))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"JS content")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))

parseRules ([Char]
"HTML",[Char]
"JS comment close") =
  (((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'3c'2fscript'5cb ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
KeywordTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"El Close 3"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
"Alerts",[Char]
"")) KateParser Token -> (Token -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok) ([Char] -> KateParser Token)
-> (Token -> [Char]) -> Token -> KateParser Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> [Char]
forall a b. (a, b) -> b
snd)))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"JS comment close")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
CommentTok))

parseRules ([Char]
"HTML",[Char]
"Value") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Value DQ"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ ([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Value SQ"))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity [Char]
pDetectSpaces ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
NormalTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (([Char], [Char]) -> ParsecT [Char] SyntaxState Identity ()
pushContext ([Char]
"HTML",[Char]
"Value NQ") ParsecT [Char] SyntaxState Identity ()
-> KateParser ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"HTML",[Char]
"Value NQ") =
  (((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'2f'28'3f'21'3e'29 ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((Regex -> ParsecT [Char] SyntaxState Identity [Char]
pRegExpr Regex
regex_'5b'5e'2f'3e'3c'22'27'5cs'5d ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext) ParsecT [Char] SyntaxState Identity ()
-> KateParser ([Char], [Char]) -> KateParser ([Char], [Char])
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Char], [Char]) -> KateParser Token
parseRules))

parseRules ([Char]
"HTML",[Char]
"Value DQ") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'"' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Value DQ")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))

parseRules ([Char]
"HTML",[Char]
"Value SQ") =
  (((Bool -> Char -> ParsecT [Char] SyntaxState Identity [Char]
pDetectChar Bool
False Char
'\'' ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok) KateParser Token
-> ParsecT [Char] SyntaxState Identity () -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
>>~ (ParsecT [Char] SyntaxState Identity ()
popContext ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity ()
popContext))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   ((([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"FindEntityRefs")))
   KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
   (KateParser ([Char], [Char])
currentContext KateParser ([Char], [Char])
-> (([Char], [Char]) -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char], [Char])
x -> Bool -> ParsecT [Char] SyntaxState Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (([Char], [Char])
x ([Char], [Char]) -> ([Char], [Char]) -> Bool
forall a. Eq a => a -> a -> Bool
== ([Char]
"HTML",[Char]
"Value SQ")) ParsecT [Char] SyntaxState Identity ()
-> ParsecT [Char] SyntaxState Identity [Char]
-> ParsecT [Char] SyntaxState Identity [Char]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT [Char] SyntaxState Identity [Char]
pDefault ParsecT [Char] SyntaxState Identity [Char]
-> ([Char] -> KateParser Token) -> KateParser Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TokenType -> [Char] -> KateParser Token
forall {m :: * -> *} {a} {s}.
Monad m =>
a -> [Char] -> ParsecT s SyntaxState m (a, [Char])
withAttribute TokenType
StringTok))

parseRules ([Char]
"Alerts", [Char]
_) = Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Alert.parseExpression Maybe ([Char], [Char])
forall a. Maybe a
Nothing
parseRules ([Char]
"CSS", [Char]
_) = Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Css.parseExpression Maybe ([Char], [Char])
forall a. Maybe a
Nothing
parseRules ([Char]
"JavaScript", [Char]
_) = Maybe ([Char], [Char]) -> KateParser Token
Text.Highlighting.Kate.Syntax.Javascript.parseExpression Maybe ([Char], [Char])
forall a. Maybe a
Nothing

parseRules ([Char], [Char])
x = ([Char], [Char]) -> KateParser Token
parseRules ([Char]
"HTML",[Char]
"Start") KateParser Token -> KateParser Token -> KateParser Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [Char] -> KateParser Token
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char]
"Unknown context" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ([Char], [Char]) -> [Char]
forall a. Show a => a -> [Char]
show ([Char], [Char])
x)