Convert bytestrings to Markup

Two-phase pipeline: lexical (tokenize) then semantic (gather)

>>> markup Html "<foo><br></foo><baz"
These [MarkupParser (ParserLeftover "<baz")] (Markup {elements = [Node {rootLabel = OpenTag StartTag "foo" [], subForest = [Node {rootLabel = OpenTag StartTag "br" [], subForest = []}]}]})

markup but errors on warnings.

Parse a bytestring into tokens

>>> tokenize Html "<foo>content</foo>"
That [OpenTag StartTag "foo" [],Content "content",EndTag "foo"]

tokenize but errors on warnings.

A Token parser.

>>> runMarkupParser (tokenP Html) "<foo>content</foo>"
("content</foo>",These () (OpenTag StartTag "foo" []))

Gather together token trees from a token list, placing child elements in nodes and removing EndTags.

gather but errors on warnings.

Convert a markup into a token list, adding end tags.

degather but errors on warning

Concatenate sequential content and normalize attributes; unwording class values and removing duplicate attributes (taking last).

Normalise Content in Markup, concatenating adjacent Content, and removing mempty Content.

Check for well-formedness and return warnings encountered.

>>> wellFormed Html $ Markup [Node (Comment "") [], Node (EndTag "foo") [], Node (OpenTag EmptyElemTag "foo" []) [Node (Content "bar") []], Node (OpenTag EmptyElemTag "foo" []) []]
[EmptyContent,EndTagInTree,LeafWithChildren,BadEmptyElemTag]

Are the trees in the markup well-formed?

Create Markup from a name tag and attributes that wraps some other markup.

>>> element "div" [] (element_ "br" [])
Markup {elements = [Node {rootLabel = OpenTag StartTag "div" [], subForest = [Node {rootLabel = OpenTag StartTag "br" [], subForest = []}]}]}

Create Markup from a name tag and attributes that doesn't wrap some other markup. The OpenTagType used is StartTag. Use emptyElem if you want to create EmptyElemTag based markup.

>>> (element_ "br" [])
Markup {elements = [Node {rootLabel = OpenTag StartTag "br" [], subForest = []}]}

Create Markup from a name tag and attributes using EmptyElemTag, that doesn't wrap some other markup. No checks are made on whether this creates well-formed markup.

>>> emptyElem "br" []
Markup {elements = [Node {rootLabel = OpenTag EmptyElemTag "br" [], subForest = []}]}

Create Markup from a name tag and attributes that wraps some Content. No escaping is performed.

>>> elementc "div" [] "content"
Markup {elements = [Node {rootLabel = OpenTag StartTag "div" [], subForest = [Node {rootLabel = Content "content", subForest = []}]}]}

Create a Markup element from a bytestring, not escaping the usual characters.

>>> contentRaw "<content>"
Markup {elements = [Node {rootLabel = Content "<content>", subForest = []}]}

Append attributes to an existing Token attribute list. Returns Nothing for tokens that do not have attributes.

Run a parser and return the remaining input and result as a tuple

Run parser, returning leftovers and errors as ParserWarnings.

>>> runParserWarn ws " "
That ' '

>>> runParserWarn ws "x"
This ParserUncaught

>>> runParserWarn ws " x"
These (ParserLeftover "x") ' '

Parse a tag name.

Parse an attribute. | Parse attributes list.

Alias for single whitespace (backward compat with mpar)

Alias for skip whitespace (backward compat with mpar)

Standard Html Doctype

Standard Xml Doctype

Html tags that self-close

Matched span as a ByteString (capturedBS — flatparse specialty).

equals sign with optional whitespace

quoted string: single or double quoted