Standardbibliothek

Antra::HTML

import Antra::HTML

Hiccup-style HTML rendering for Antra.

Nodes are plain data: [tag, attrs?, child1, child2, ...]. Tags are usually keywords like :div, attributes are maps, and child nodes may be nested element arrays, strings, numbers, or fragments. println(HTML.render(page, [colorize: true]))

Überblick#

Ein besonderes Modul, weil es Hiccup-artige HTML-Daten und HTML-Rendering zusammenbringt.

Das ist interessant, wenn du HTML nicht als bloßen String, sondern als strukturierte Daten behandeln willst.

Referenz#

Wichtige Referenzpunkte:

Hiccup-artige Datenform [tag, attrs?, ...children]
HTML.render(...), HTML.parse(...), HTML.parse(...).!, HTML.raw(...)
html-Codeblock-Literale mit $name, ${expr}, ${if ...} und ${for ...}
html-Codeblock-Literale erlauben auch Fence-Optionen wie raw="true"; damit bleibt der interpolierte HTML-Text roh statt direkt zu Hiccup geparst zu werden
Convenience-Wrapper wie div(...), body(...), title(...), html(...)

HTML.parse(...) liefert bei kaputtem Markup strukturierte %Err[%Error{...}]; HTML.parse(...).! wirft denselben %Error{...} dann direkt.

Funktionen#

afn</>

fn a(..args)

addressfn</>

fn address(..args)

articlefn</>

fn article(..args)

asidefn</>

fn aside(..args)

audiofn</>

fn audio(..args)

blockquotefn</>

fn blockquote(..args)

bodyfn</>

fn body(..args)

brfn</>

fn br(..args)

buttonfn</>

fn button(..args)

canvasfn</>

fn canvas(..args)

captionfn</>

fn caption(..args)

citefn</>

fn cite(..args)

codefn</>

fn code(..args)

colfn</>

fn col(..args)

colgroupfn</>

fn colgroup(..args)

datalistfn</>

fn datalist(..args)

ddfn</>

fn dd(..args)

detailsfn</>

fn details(..args)

dialogfn</>

fn dialog(..args)

divfn</>

fn div(..args)

dlfn</>

fn dl(..args)

dtfn</>

fn dt(..args)

emfn</>

fn em(..args)

escapefn</>

fn escape(value)

Escapes a text value for safe HTML output.

Example:

HTML.escape("<b>hi</b>")

fieldsetfn</>

fn fieldset(..args)

figcaptionfn</>

fn figcaption(..args)

figurefn</>

fn figure(..args)

formfn</>

fn form(..args)

h1fn</>

fn h1(..args)

h2fn</>

fn h2(..args)

h3fn</>

fn h3(..args)

h4fn</>

fn h4(..args)

h5fn</>

fn h5(..args)

h6fn</>

fn h6(..args)

headfn</>

fn head(..args)

hrfn</>

fn hr(..args)

htmlfn</>

fn html(..args)

Convenience wrappers for common HTML5 tags.

iframefn</>

fn iframe(..args)

imgfn</>

fn img(..args)

inputfn</>

fn input(..args)

labelfn</>

fn label(..args)

legendfn</>

fn legend(..args)

lifn</>

fn li(..args)

linkfn</>

fn link(..args)

mainfn</>

fn main(..args)

markfn</>

fn mark(..args)

metafn</>

fn meta(..args)

navfn</>

fn nav(..args)

noscriptfn</>

fn noscript(..args)

olfn</>

fn ol(..args)

optgroupfn</>

fn optgroup(..args)

optionfn</>

fn option(..args)

outputfn</>

fn output(..args)

pfn</>

fn p(..args)

parsefn</>

fn parse(html)

Parses an HTML string back into Hiccup-style data.

Example:

import Antra::HTML as HTML

my node = HTML.parse('<div class="panel">Hello <span>world</span></div>').!
println(node)

picturefn</>

fn picture(..args)

prefn</>

fn pre(..args)

qfn</>

fn q(..args)

rawfn</>

fn raw(html)

Marks a string as already-safe HTML so render(...) inserts it unescaped.

Example:

HTML.raw("<strong>safe</strong>")

renderfn</>

fn render(node)
fn render(node, [
        pretty: _ = false,
        indent: _ = 4,
        colorize: _ = false, ..
    ] as opts)

Renders a Hiccup-style node tree to an HTML string.

Example:

import Antra::HTML as HTML

fn panel(text) -> [:div, %{class: "panel"}, text]

my page = [
    :html,
    [:head, [:title, "Hello"]],
    [:body, panel("Welcome")]
]

println(HTML.render(page))
println(HTML.render(page, [pretty: true, indent: 4, colorize: false]))