nakai/html

Types

Node

pub type Node {
  Doctype(content: String)
  Html(attrs: List(Attr), children: List(Node))
  Head(children: List(Node))
  Body(attrs: List(Attr), children: List(Node))
  Fragment(children: List(Node))
  Element(tag: String, attrs: List(Attr), children: List(Node))
  LeafElement(tag: String, attrs: List(Attr))
  Comment(content: String)
  Text(content: String)
  UnsafeInlineHtml(content: String)
  Script(script: String)
  Nothing
}

Constructors

```
Doctype(content: String)
```
Can be used anywhere in the document, and will set the doctype of the document being rendered. Usually not necessary, as documents have a default of <!DOCTYPE html>.

Example
```
html.Doctype("html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\"")
```
```
Html(attrs: List(Attr), children: List(Node))
```
Used for setting attributes on the root <html> element of the document. Children will be rendered in-place, equivalent to using html.Fragment(children).

Example
```
html.Html([attrs.lang("en-US")], [
  ...
])
```

Head(children: List(Node))

Used for placing content in the <head> of the document. Useful for elements like <meta>, <title>, <link>, etc.

Example

html.Fragment([
  html.Head([
    html.title("List of puppies")
  ]),
  html.div([], [
    ...
  ])
])

```
Body(attrs: List(Attr), children: List(Node))
```
Used for setting attributes on the <body> element of the document. Children will be rendered in-place, equivalent to using html.Fragment(children).

Example
```
html.Body([attrs.class("dark-mode")], [
  ...
])
```

Fragment(children: List(Node))

An “transparent” container that will render it’s children, but does not add anything itself to the document. If you’ve ever used React.Fragment or <> and </> in JSX/React, this is that.

Example

html.ul([], [
  // some puppies are hard-coded
  html.li_text([], "August"),
  // some are loaded from a server
  html.Fragment(puppies_fetched_from_api |> list.map(html.li_text([], _)))
])
// <ul>
//   <li>August</li>
//   <li>Dot</li>
//   <li>Mody</li>
//   <li>Spot</li>
//   <li>Toby</li>
// </ul>

```
Element(tag: String, attrs: List(Attr), children: List(Node))
```
An HTML element. You shouldn’t need to reach for this very often, but it can be a handy escape hatch if there isn’t a shorthand function for the element type you need.

Example
```
// bad example, pls use `html.div`
html.Element("div", [], [html.Text("hello, lucy!")])
```
```
LeafElement(tag: String, attrs: List(Attr))
```
An HTML element, but that does not have any children, and should be self closing. Similarly to Element, you shouldn’t really need this, except as an escape hatch if there isn’t a shorthand function for the element type you need.

Example
```
// bad example, pls use `html.link`
html.LeafElement("link", [attrs.rel("stylesheet"), attrs.href(...)])
```

Comment(content: String)

An HTML comment, which will be included in the document.

Example

html.Comment("You've uncovered my secrets!")
// <!-- You've uncovered my secrets! -->

Text(content: String)

Some plain text to include in the document. The provided text will be escaped, to make it safe to include in the document.

Example

html.Text("hello, lucy!")
// hello, lucy!

// Time to trust some unvalidated user input! :^)
html.div_text([], "<script>alert('pwned');</script>")
// <div>&lt;script&gt;alert('pwned');&lt;/script&gt;</div>

UnsafeInlineHtml(content: String)

The dangerous cousin of Text. This will render the provided text as-is, without any santization. Good for things like including some HTML you just generated from a Markdown file. Bad for things like $_GET['search'].

Example

html.Text("hello, lucy!")
// hello, lucy!

// Time to trust some unvalidated user input! :^)
html.div([], [html.UnsafeInlineHtml("<script>alert('pwned');</script>")])
// <div><script>alert('pwned');</script></div>
// Oh no, we just got got! D:

```
Script(script: String)
```
Add some JavaScript to your page! Scripts will always be inserted at the end of the page, regardless of where in the document the Script node is, so that your content loads first.

Example
```
html.Script("alert('hello, lucy!')")
```
```
Nothing
```
Renders absolutely nothing. For when you may or may not have something to render, and need a way to say “I’ve got nothing.”

Example
```
html.div([], [
  case my_cool_feature {
    Enabled -> super_cool_stuff()
    Disabled -> html.Nothing
  }
])
```

Functions

a

</>

pub fn a(attrs: List(Attr), children: List(Node)) -> Node

The HTML <a> element

a_text

</>

pub fn a_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.a(attrs, children: [html.Text(text)])

abbr

</>

pub fn abbr(attrs: List(Attr), children: List(Node)) -> Node

The HTML <abbr> element

abbr_text

</>

pub fn abbr_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.abbr(attrs, children: [html.Text(text)])

address

</>

pub fn address(attrs: List(Attr), children: List(Node)) -> Node

The HTML <address> element

address_text

</>

pub fn address_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.address(attrs, children: [html.Text(text)])

area

</>

pub fn area(attrs: List(Attr)) -> Node

The HTML <area /> element

article

</>

pub fn article(attrs: List(Attr), children: List(Node)) -> Node

The HTML <article> element

article_text

</>

pub fn article_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.article(attrs, children: [html.Text(text)])

aside

</>

pub fn aside(attrs: List(Attr), children: List(Node)) -> Node

The HTML <aside> element

aside_text

</>

pub fn aside_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.aside(attrs, children: [html.Text(text)])

audio

</>

pub fn audio(attrs: List(Attr), children: List(Node)) -> Node

The HTML <audio> element

audio_text

</>

pub fn audio_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.audio(attrs, children: [html.Text(text)])

b

</>

pub fn b(attrs: List(Attr), children: List(Node)) -> Node

The HTML <b> element

b_text

</>

pub fn b_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.b(attrs, children: [html.Text(text)])

base

</>

pub fn base(attrs: List(Attr)) -> Node

The HTML <base /> element

bdi

</>

pub fn bdi(attrs: List(Attr), children: List(Node)) -> Node

The HTML <bdi> element

bdi_text

</>

pub fn bdi_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.bdi(attrs, children: [html.Text(text)])

bdo

</>

pub fn bdo(attrs: List(Attr), children: List(Node)) -> Node

The HTML <bdo> element

bdo_text

</>

pub fn bdo_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.bdo(attrs, children: [html.Text(text)])

blockquote

</>

pub fn blockquote(
  attrs: List(Attr),
  children: List(Node),
) -> Node

The HTML <blockquote> element

blockquote_text

</>

pub fn blockquote_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.blockquote(attrs, children: [html.Text(text)])

br

</>

pub fn br(attrs: List(Attr)) -> Node

The HTML <br /> element

button

</>

pub fn button(attrs: List(Attr), children: List(Node)) -> Node

The HTML <button> element

button_text

</>

pub fn button_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.button(attrs, children: [html.Text(text)])

canvas

</>

pub fn canvas(attrs: List(Attr), children: List(Node)) -> Node

The HTML <canvas> element

canvas_text

</>

pub fn canvas_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.canvas(attrs, children: [html.Text(text)])

caption

</>

pub fn caption(attrs: List(Attr), children: List(Node)) -> Node

The HTML <caption> element

caption_text

</>

pub fn caption_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.caption(attrs, children: [html.Text(text)])

cite

</>

pub fn cite(attrs: List(Attr), children: List(Node)) -> Node

The HTML <cite> element

cite_text

</>

pub fn cite_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.cite(attrs, children: [html.Text(text)])

code

</>

pub fn code(attrs: List(Attr), children: List(Node)) -> Node

The HTML <code> element

code_text

</>

pub fn code_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.code(attrs, children: [html.Text(text)])

col

</>

pub fn col(attrs: List(Attr), children: List(Node)) -> Node

The HTML <col> element

col_text

</>

pub fn col_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.col(attrs, children: [html.Text(text)])

colgroup

</>

pub fn colgroup(attrs: List(Attr), children: List(Node)) -> Node

The HTML <colgroup> element

colgroup_text

</>

pub fn colgroup_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.colgroup(attrs, children: [html.Text(text)])

data

</>

pub fn data(attrs: List(Attr), children: List(Node)) -> Node

The HTML <data> element

data_text

</>

pub fn data_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.data(attrs, children: [html.Text(text)])

datalist

</>

pub fn datalist(attrs: List(Attr), children: List(Node)) -> Node

The HTML <datalist> element

datalist_text

</>

pub fn datalist_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.datalist(attrs, children: [html.Text(text)])

dd

</>

pub fn dd(attrs: List(Attr), children: List(Node)) -> Node

The HTML <dd> element

dd_text

</>

pub fn dd_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.dd(attrs, children: [html.Text(text)])

del

</>

pub fn del(attrs: List(Attr), children: List(Node)) -> Node

The HTML <del> element

del_text

</>

pub fn del_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.del(attrs, children: [html.Text(text)])

details

</>

pub fn details(attrs: List(Attr), children: List(Node)) -> Node

The HTML <details> element

details_text

</>

pub fn details_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.details(attrs, children: [html.Text(text)])

dfn

</>

pub fn dfn(attrs: List(Attr), children: List(Node)) -> Node

The HTML <dfn> element

dfn_text

</>

pub fn dfn_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.dfn(attrs, children: [html.Text(text)])

dialog

</>

pub fn dialog(attrs: List(Attr), children: List(Node)) -> Node

The HTML <dialog> element

dialog_text

</>

pub fn dialog_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.dialog(attrs, children: [html.Text(text)])

div

</>

pub fn div(attrs: List(Attr), children: List(Node)) -> Node

The HTML <div> element

div_text

</>

pub fn div_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.div(attrs, children: [html.Text(text)])

dl

</>

pub fn dl(attrs: List(Attr), children: List(Node)) -> Node

The HTML <dl> element

dl_text

</>

pub fn dl_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.dl(attrs, children: [html.Text(text)])

dt

</>

pub fn dt(attrs: List(Attr), children: List(Node)) -> Node

The HTML <dt> element

dt_text

</>

pub fn dt_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.dt(attrs, children: [html.Text(text)])

em

</>

pub fn em(attrs: List(Attr), children: List(Node)) -> Node

The HTML <em> element

em_text

</>

pub fn em_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.em(attrs, children: [html.Text(text)])

embed

</>

pub fn embed(attrs: List(Attr), children: List(Node)) -> Node

The HTML <embed> element

embed_text

</>

pub fn embed_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.embed(attrs, children: [html.Text(text)])

fieldset

</>

pub fn fieldset(attrs: List(Attr), children: List(Node)) -> Node

The HTML <fieldset> element

fieldset_text

</>

pub fn fieldset_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.fieldset(attrs, children: [html.Text(text)])

figcaption

</>

pub fn figcaption(
  attrs: List(Attr),
  children: List(Node),
) -> Node

The HTML <figcaption> element

figcaption_text

</>

pub fn figcaption_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.figcaption(attrs, children: [html.Text(text)])

figure

</>

pub fn figure(attrs: List(Attr), children: List(Node)) -> Node

The HTML <figure> element

figure_text

</>

pub fn figure_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.figure(attrs, children: [html.Text(text)])

</>

pub fn footer(attrs: List(Attr), children: List(Node)) -> Node

The HTML <footer> element

footer_text

</>

pub fn footer_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.footer(attrs, children: [html.Text(text)])

form

</>

pub fn form(attrs: List(Attr), children: List(Node)) -> Node

The HTML <form> element

form_text

</>

pub fn form_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.form(attrs, children: [html.Text(text)])

h1

</>

pub fn h1(attrs: List(Attr), children: List(Node)) -> Node

The HTML <h1> element

h1_text

</>

pub fn h1_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.h1(attrs, children: [html.Text(text)])

h2

</>

pub fn h2(attrs: List(Attr), children: List(Node)) -> Node

The HTML <h2> element

h2_text

</>

pub fn h2_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.h2(attrs, children: [html.Text(text)])

h3

</>

pub fn h3(attrs: List(Attr), children: List(Node)) -> Node

The HTML <h3> element

h3_text

</>

pub fn h3_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.h3(attrs, children: [html.Text(text)])

h4

</>

pub fn h4(attrs: List(Attr), children: List(Node)) -> Node

The HTML <h4> element

h4_text

</>

pub fn h4_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.h4(attrs, children: [html.Text(text)])

h5

</>

pub fn h5(attrs: List(Attr), children: List(Node)) -> Node

The HTML <h5> element

h5_text

</>

pub fn h5_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.h5(attrs, children: [html.Text(text)])

h6

</>

pub fn h6(attrs: List(Attr), children: List(Node)) -> Node

The HTML <h6> element

h6_text

</>

pub fn h6_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.h6(attrs, children: [html.Text(text)])

</>

pub fn header(attrs: List(Attr), children: List(Node)) -> Node

The HTML <header> element

header_text

</>

pub fn header_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.header(attrs, children: [html.Text(text)])

hr

</>

pub fn hr(attrs: List(Attr)) -> Node

The HTML <hr /> element

i

</>

pub fn i(attrs: List(Attr), children: List(Node)) -> Node

The HTML <i> element

i_text

</>

pub fn i_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.i(attrs, children: [html.Text(text)])

iframe

</>

pub fn iframe(attrs: List(Attr), children: List(Node)) -> Node

The HTML <iframe> element

iframe_text

</>

pub fn iframe_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.iframe(attrs, children: [html.Text(text)])

img

</>

pub fn img(attrs: List(Attr)) -> Node

The HTML <img /> element

input

</>

pub fn input(attrs: List(Attr)) -> Node

The HTML <input /> element

ins

</>

pub fn ins(attrs: List(Attr), children: List(Node)) -> Node

The HTML <ins> element

ins_text

</>

pub fn ins_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.ins(attrs, children: [html.Text(text)])

kbd

</>

pub fn kbd(attrs: List(Attr), children: List(Node)) -> Node

The HTML <kbd> element

kbd_text

</>

pub fn kbd_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.kbd(attrs, children: [html.Text(text)])

label

</>

pub fn label(attrs: List(Attr), children: List(Node)) -> Node

The HTML <label> element

label_text

</>

pub fn label_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.label(attrs, children: [html.Text(text)])

legend

</>

pub fn legend(attrs: List(Attr), children: List(Node)) -> Node

The HTML <legend> element

legend_text

</>

pub fn legend_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.legend(attrs, children: [html.Text(text)])

li

</>

pub fn li(attrs: List(Attr), children: List(Node)) -> Node

The HTML <li> element

li_text

</>

pub fn li_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.li(attrs, children: [html.Text(text)])

link

</>

pub fn link(attrs: List(Attr)) -> Node

The HTML <link /> element

main

</>

pub fn main(attrs: List(Attr), children: List(Node)) -> Node

The HTML <main> element

main_text

</>

pub fn main_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.main(attrs, children: [html.Text(text)])

map

</>

pub fn map(attrs: List(Attr), children: List(Node)) -> Node

The HTML <map> element

map_text

</>

pub fn map_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.map(attrs, children: [html.Text(text)])

mark

</>

pub fn mark(attrs: List(Attr), children: List(Node)) -> Node

The HTML <mark> element

mark_text

</>

pub fn mark_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.mark(attrs, children: [html.Text(text)])

math

</>

pub fn math(attrs: List(Attr), children: List(Node)) -> Node

The HTML <math> element

math_text

</>

pub fn math_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.math(attrs, children: [html.Text(text)])

</>

pub fn menu(attrs: List(Attr), children: List(Node)) -> Node

The HTML <menu> element

menu_text

</>

pub fn menu_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.menu(attrs, children: [html.Text(text)])

menuitem

</>

pub fn menuitem(attrs: List(Attr), children: List(Node)) -> Node

The HTML <menuitem> element

menuitem_text

</>

pub fn menuitem_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.menuitem(attrs, children: [html.Text(text)])

meter

</>

pub fn meter(attrs: List(Attr), children: List(Node)) -> Node

The HTML <meter> element

meter_text

</>

pub fn meter_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.meter(attrs, children: [html.Text(text)])

nav

</>

pub fn nav(attrs: List(Attr), children: List(Node)) -> Node

The HTML <nav> element

nav_text

</>

pub fn nav_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.nav(attrs, children: [html.Text(text)])

noscript

</>

pub fn noscript(attrs: List(Attr), children: List(Node)) -> Node

The HTML <noscript> element

noscript_text

</>

pub fn noscript_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.noscript(attrs, children: [html.Text(text)])

object

</>

pub fn object(attrs: List(Attr), children: List(Node)) -> Node

The HTML <object> element

object_text

</>

pub fn object_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.object(attrs, children: [html.Text(text)])

ol

</>

pub fn ol(attrs: List(Attr), children: List(Node)) -> Node

The HTML <ol> element

ol_text

</>

pub fn ol_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.ol(attrs, children: [html.Text(text)])

optgroup

</>

pub fn optgroup(attrs: List(Attr), children: List(Node)) -> Node

The HTML <optgroup> element

optgroup_text

</>

pub fn optgroup_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.optgroup(attrs, children: [html.Text(text)])

option

</>

pub fn option(attrs: List(Attr), children: List(Node)) -> Node

The HTML <option> element

option_text

</>

pub fn option_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.option(attrs, children: [html.Text(text)])

output

</>

pub fn output(attrs: List(Attr), children: List(Node)) -> Node

The HTML <output> element

output_text

</>

pub fn output_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.output(attrs, children: [html.Text(text)])

p

</>

pub fn p(attrs: List(Attr), children: List(Node)) -> Node

The HTML <p> element

p_text

</>

pub fn p_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.p(attrs, children: [html.Text(text)])

param

</>

pub fn param(attrs: List(Attr), children: List(Node)) -> Node

The HTML <param> element

param_text

</>

pub fn param_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.param(attrs, children: [html.Text(text)])

picture

</>

pub fn picture(attrs: List(Attr), children: List(Node)) -> Node

The HTML <picture> element

picture_text

</>

pub fn picture_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.picture(attrs, children: [html.Text(text)])

pre

</>

pub fn pre(attrs: List(Attr), children: List(Node)) -> Node

The HTML <pre> element

pre_text

</>

pub fn pre_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.pre(attrs, children: [html.Text(text)])

progress

</>

pub fn progress(attrs: List(Attr), children: List(Node)) -> Node

The HTML <progress> element

progress_text

</>

pub fn progress_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.progress(attrs, children: [html.Text(text)])

q

</>

pub fn q(attrs: List(Attr), children: List(Node)) -> Node

The HTML <q> element

q_text

</>

pub fn q_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.q(attrs, children: [html.Text(text)])

rp

</>

pub fn rp(attrs: List(Attr), children: List(Node)) -> Node

The HTML <rp> element

rp_text

</>

pub fn rp_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.rp(attrs, children: [html.Text(text)])

rt

</>

pub fn rt(attrs: List(Attr), children: List(Node)) -> Node

The HTML <rt> element

rt_text

</>

pub fn rt_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.rt(attrs, children: [html.Text(text)])

ruby

</>

pub fn ruby(attrs: List(Attr), children: List(Node)) -> Node

The HTML <ruby> element

ruby_text

</>

pub fn ruby_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.ruby(attrs, children: [html.Text(text)])

s

</>

pub fn s(attrs: List(Attr), children: List(Node)) -> Node

The HTML <s> element

s_text

</>

pub fn s_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.s(attrs, children: [html.Text(text)])

samp

</>

pub fn samp(attrs: List(Attr), children: List(Node)) -> Node

The HTML <samp> element

samp_text

</>

pub fn samp_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.samp(attrs, children: [html.Text(text)])

section

</>

pub fn section(attrs: List(Attr), children: List(Node)) -> Node

The HTML <section> element

section_text

</>

pub fn section_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.section(attrs, children: [html.Text(text)])

select

</>

pub fn select(attrs: List(Attr), children: List(Node)) -> Node

The HTML <select> element

select_text

</>

pub fn select_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.select(attrs, children: [html.Text(text)])

small

</>

pub fn small(attrs: List(Attr), children: List(Node)) -> Node

The HTML <small> element

small_text

</>

pub fn small_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.small(attrs, children: [html.Text(text)])

source

</>

pub fn source(attrs: List(Attr)) -> Node

The HTML <source /> element

span

</>

pub fn span(attrs: List(Attr), children: List(Node)) -> Node

The HTML <span> element

span_text

</>

pub fn span_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.span(attrs, children: [html.Text(text)])

strong

</>

pub fn strong(attrs: List(Attr), children: List(Node)) -> Node

The HTML <strong> element

strong_text

</>

pub fn strong_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.strong(attrs, children: [html.Text(text)])

sub

</>

pub fn sub(attrs: List(Attr), children: List(Node)) -> Node

The HTML <sub> element

sub_text

</>

pub fn sub_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.sub(attrs, children: [html.Text(text)])

summary

</>

pub fn summary(attrs: List(Attr), children: List(Node)) -> Node

The HTML <summary> element

summary_text

</>

pub fn summary_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.summary(attrs, children: [html.Text(text)])

sup

</>

pub fn sup(attrs: List(Attr), children: List(Node)) -> Node

The HTML <sup> element

sup_text

</>

pub fn sup_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.sup(attrs, children: [html.Text(text)])

svg

</>

pub fn svg(attrs: List(Attr), children: List(Node)) -> Node

The HTML <svg> element

svg_text

</>

pub fn svg_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.svg(attrs, children: [html.Text(text)])

table

</>

pub fn table(attrs: List(Attr), children: List(Node)) -> Node

The HTML <table> element

table_text

</>

pub fn table_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.table(attrs, children: [html.Text(text)])

tbody

</>

pub fn tbody(attrs: List(Attr), children: List(Node)) -> Node

The HTML <tbody> element

tbody_text

</>

pub fn tbody_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.tbody(attrs, children: [html.Text(text)])

td

</>

pub fn td(attrs: List(Attr), children: List(Node)) -> Node

The HTML <td> element

td_text

</>

pub fn td_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.td(attrs, children: [html.Text(text)])

textarea

</>

pub fn textarea(attrs: List(Attr), children: List(Node)) -> Node

The HTML <textarea> element

textarea_text

</>

pub fn textarea_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.textarea(attrs, children: [html.Text(text)])

tfoot

</>

pub fn tfoot(attrs: List(Attr), children: List(Node)) -> Node

The HTML <tfoot> element

tfoot_text

</>

pub fn tfoot_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.tfoot(attrs, children: [html.Text(text)])

th

</>

pub fn th(attrs: List(Attr), children: List(Node)) -> Node

The HTML <th> element

th_text

</>

pub fn th_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.th(attrs, children: [html.Text(text)])

thead

</>

pub fn thead(attrs: List(Attr), children: List(Node)) -> Node

The HTML <thead> element

thead_text

</>

pub fn thead_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.thead(attrs, children: [html.Text(text)])

time

</>

pub fn time(attrs: List(Attr), children: List(Node)) -> Node

The HTML <time> element

time_text

</>

pub fn time_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.time(attrs, children: [html.Text(text)])

title

</>

pub fn title(text: String) -> Node

The HTML <title> element

tr

</>

pub fn tr(attrs: List(Attr), children: List(Node)) -> Node

The HTML <tr> element

tr_text

</>

pub fn tr_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.tr(attrs, children: [html.Text(text)])

track

</>

pub fn track(attrs: List(Attr)) -> Node

The HTML <track /> element

u

</>

pub fn u(attrs: List(Attr), children: List(Node)) -> Node

The HTML <u> element

u_text

</>

pub fn u_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.u(attrs, children: [html.Text(text)])

ul

</>

pub fn ul(attrs: List(Attr), children: List(Node)) -> Node

The HTML <ul> element

ul_text

</>

pub fn ul_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.ul(attrs, children: [html.Text(text)])

var

</>

pub fn var(attrs: List(Attr), children: List(Node)) -> Node

The HTML <var> element

var_text

</>

pub fn var_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.var(attrs, children: [html.Text(text)])

video

</>

pub fn video(attrs: List(Attr), children: List(Node)) -> Node

The HTML <video> element

video_text

</>

pub fn video_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.video(attrs, children: [html.Text(text)])

wbr

</>

pub fn wbr(attrs: List(Attr), children: List(Node)) -> Node

The HTML <wbr> element

wbr_text

</>

pub fn wbr_text(attrs: List(Attr), text: String) -> Node

Shorthand for html.wbr(attrs, children: [html.Text(text)])