A list of Elements or Tree Tokens

>>> markup Html "<foo class=\"bar\">baz</foo>"
That (Markup {elements = [Node {rootLabel = OpenTag StartTag "foo" [Attr {attrName = "class", attrValue = "bar"}], subForest = [Node {rootLabel = Content "baz", subForest = []}]}]})

From a parsing pov, Html & Xml (& Svg) are close enough that they share a lot of parsing logic, so that parsing and printing just need some tweaking.

The xml parsing logic is based on the XML productions found in https://www.w3.org/TR/xml/

The html parsing was based on a reading of html-parse, but ignores the various 'x00' to 'xfffd' & eof directives that form part of the html standards.

Convert bytestrings to Markup

>>> 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.

Indented 0 puts newlines in between the tags.

Convert Markup to bytestrings

>>> markdown (Indented 4) Html (markup_ Html [i|<foo><br></foo>|])
That "<foo>\n    <br>\n</foo>"

Convert Markup to ByteString and error on warnings.

>>> B.putStr $ markdown_ (Indented 4) Html (markup_ Html [i|<foo><br></foo>|])
<foo>
    <br>
</foo>

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

>>> B.putStr $ warnError $ markdown Compact Xml $ normalize (markup_ Xml [i|<foo class="a" class="b" bar="first" bar="last"/>|])
<foo bar="last" class="a b"/>

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

>>> normContent $ content "a" <> content "" <> content "b"
Markup {elements = [Node {rootLabel = Content "ab", subForest = []}]}

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?

markup-parse generally tries to continue on parse errors, and return what has/can still be parsed, together with any warnings.

A type synonym for the common returning type of many functions. A common computation pipeline is to take advantage of the These Monad instance eg

markup s bs = bs & (tokenize s >=> gather s) & second (Markup s)

Convert any warnings to an error

>>> warnError $ (tokenize Html) "<foo"
*** Exception: MarkupParser (ParserLeftover "<foo")
...

Returns Left on any warnings

>>> warnEither $ (tokenize Html) "<foo><baz"
Left [MarkupParser (ParserLeftover "<baz")]

Returns results, if any, ignoring warnings.

>>> warnMaybe $ (tokenize Html) "<foo><baz"
Just [OpenTag StartTag "foo" []]

Most functions return a Markup rather than an Element because it is more ergonimc to use the free monoid wrap (aka a list) in preference to returning a 'Maybe Element', say.

Create a Markup element from a NameTag 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 a Markup element from a NameTag and attributes that doesn't wrap some other Markup. OpenTagType is StartTag. Use emptyElem if you want to create a EmptyElemTag.

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

Create a Markup element from a NameTag 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 a Markup element from a NameTag and attributes that wraps some Content.

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

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

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

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

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

>>> markup_ Html $ markdown_ Compact Html $ contentRaw "<content>"
*** Exception: UnclosedTag
...

Name of token

Html tags that self-close

Append attributes to the existing Token attribute list.

Standard Html Doctype

>>> markdown_ Compact Html doctypeHtml
"<!DOCTYPE html>"

Standard Xml Doctype

>>> markdown_ Compact Xml doctypeXml
"<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n    \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">"

Name of an attribute.

Value of an attribute. "" is equivalent to true with respect to boolean attributes.

An attribute of a tag

In parsing, boolean attributes, which are not required to have a value in HTML, will be set a value of "", which is ok. But this will then be rendered.

>>> detokenize Html <$> tokenize_ Html [i|<input checked>|]
["<input checked=\"\">"]

Parse attributions

Parse a tag name. Each standard is slightly different.

Whether an opening tag is a start tag or an empty element tag.

A Markup token

>>> runParser_ (many (tokenP Html)) [i|<foo>content</foo>|]
[OpenTag StartTag "foo" [],Content "content",EndTag "foo"]

>>> runParser_ (tokenP Xml) [i|<foo/>|]
OpenTag EmptyElemTag "foo" []

>>> runParser_ (tokenP Html) "<!-- Comment -->"
Comment " Comment "

>>> runParser_ (tokenP Xml) [i|<?xml version="1.0" encoding="UTF-8"?>|]
Decl "xml" [Attr {attrName = "version", attrValue = " version=\"1.0\""},Attr {attrName = "encoding", attrValue = "UTF-8"}]

>>> runParser_ (tokenP Html) "<!DOCTYPE html>"
Doctype "DOCTYPE html"

>>> runParser_ (tokenP Xml) "<!DOCTYPE foo [ declarations ]>"
Doctype "DOCTYPE foo [ declarations ]"

>>> runParser (tokenP Html) [i|<foo a="a" b="b" c=c check>|]
OK (OpenTag StartTag "foo" [Attr {attrName = "a", attrValue = "a"},Attr {attrName = "b", attrValue = "b"},Attr {attrName = "c", attrValue = "c"},Attr {attrName = "check", attrValue = ""}]) ""

>>> runParser (tokenP Xml) [i|<foo a="a" b="b" c=c check>|]
Fail

Parse a bytestring into tokens

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

tokenize but errors on warnings.

A flatparse Token parser.

>>> runParser (tokenP Html) "<foo>content</foo>"
OK (OpenTag StartTag "foo" []) "content</foo>"

bytestring representation of Token.

>>> detokenize Html (OpenTag StartTag "foo" [])
"<foo>"

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

>>> gather Html =<< tokenize Html "<foo class=\"bar\">baz</foo>"
That (Markup {elements = [Node {rootLabel = OpenTag StartTag "foo" [Attr {attrName = "class", attrValue = "bar"}], subForest = [Node {rootLabel = Content "baz", subForest = []}]}]})

gather but errors on warnings.

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

>>> degather Html =<< markup Html "<foo class=\"bar\">baz</foo>"
That [OpenTag StartTag "foo" [Attr {attrName = "class", attrValue = "bar"}],Content "baz",EndTag "foo"]

degather but errors on warning

xml production [24]

xml production [80]

Xml production [32]

xml production [26]

xml production [81]

Xml yes/no

Convert a ByteString to an UTF8-encoded String.

Convert an UTF8-encoded String to a ByteString.

Escape a single character.

Escape Content

>>> escape [i|<foo class="a" bar='b'>|]
"&ltfoo class=&quota&quot bar=&aposb&apos&gt"

Non-empty, possibly infinite, multi-way trees; also known as rose trees.