sprocket - v0.2.0

sprocket/html/elements

Functions

a

</> 
pub fn a(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <a> element

a_text

</> 
pub fn a_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

abbr

</> 
pub fn abbr(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <abbr> element

address

</> 
pub fn address(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <address> element

area

</> 
pub fn area(attrs: List(Attribute)) -> Element

The HTML <area /> element

article

</> 
pub fn article(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <article> element

article_text

</> 
pub fn article_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

aside

</> 
pub fn aside(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <aside> element

aside_text

</> 
pub fn aside_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

audio

</> 
pub fn audio(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <audio> element

audio_text

</> 
pub fn audio_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

b

</> 
pub fn b(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <b> element

b_text

</> 
pub fn b_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

base

</> 
pub fn base(attrs: List(Attribute)) -> Element

The HTML <base /> element

bdi

</> 
pub fn bdi(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <bdi> element

bdi_text

</> 
pub fn bdi_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

bdo

</> 
pub fn bdo(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <bdo> element

bdo_text

</> 
pub fn bdo_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

blockquote

</> 
pub fn blockquote(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <blockquote> element

blockquote_text

</> 
pub fn blockquote_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

body

</> 
pub fn body(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <body> element

br

</> 
pub fn br(attrs: List(Attribute)) -> Element

The HTML <br /> element

button

</> 
pub fn button(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <button> element

button_text

</> 
pub fn button_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

canvas

</> 
pub fn canvas(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <canvas> element

canvas_text

</> 
pub fn canvas_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

caption

</> 
pub fn caption(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <caption> element

caption_text

</> 
pub fn caption_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

cite

</> 
pub fn cite(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <cite> element

cite_text

</> 
pub fn cite_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

code

</> 
pub fn code(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <code> element

code_text

</> 
pub fn code_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

col

</> 
pub fn col(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <col> element

col_text

</> 
pub fn col_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

colgroup

</> 
pub fn colgroup(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <colgroup> element

colgroup_text

</> 
pub fn colgroup_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

data

</> 
pub fn data(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <data> element

data_text

</> 
pub fn data_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

datalist

</> 
pub fn datalist(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <datalist> element

datalist_text

</> 
pub fn datalist_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

dd

</> 
pub fn dd(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <dd> element

dd_text

</> 
pub fn dd_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

debug

</> 
pub fn debug(
  id: String,
  meta: Option(Dynamic),
  element: Element,
) -> Element

del

</> 
pub fn del(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <del> element

del_text

</> 
pub fn del_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

details

</> 
pub fn details(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <details> element

details_text

</> 
pub fn details_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

dfn

</> 
pub fn dfn(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <dfn> element

dfn_text

</> 
pub fn dfn_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

dialog

</> 
pub fn dialog(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <dialog> element

dialog_text

</> 
pub fn dialog_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

div

</> 
pub fn div(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <div> element

div_text

</> 
pub fn div_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

dl

</> 
pub fn dl(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <dl> element

dl_text

</> 
pub fn dl_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

dt

</> 
pub fn dt(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <dt> element

dt_text

</> 
pub fn dt_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

el

</> 
pub fn el(
  tag: String,
  attrs: List(Attribute),
  children: List(Element),
) -> Element

em

</> 
pub fn em(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <em> element

em_text

</> 
pub fn em_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

embed

</> 
pub fn embed(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <embed> element

embed_text

</> 
pub fn embed_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

fieldset

</> 
pub fn fieldset(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <fieldset> element

fieldset_text

</> 
pub fn fieldset_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

figcaption

</> 
pub fn figcaption(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <figcaption> element

figcaption_text

</> 
pub fn figcaption_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

figure

</> 
pub fn figure(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <figure> element

figure_text

</> 
pub fn figure_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

</> 
pub fn footer(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <footer> element

footer_text

</> 
pub fn footer_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

form

</> 
pub fn form(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <form> element

form_text

</> 
pub fn form_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

fragment

</> 
pub fn fragment(children: List(Element)) -> Element

h1

</> 
pub fn h1(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <h1> element

h1_text

</> 
pub fn h1_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

h2

</> 
pub fn h2(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <h2> element

h2_text

</> 
pub fn h2_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

h3

</> 
pub fn h3(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <h3> element

h3_text

</> 
pub fn h3_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

h4

</> 
pub fn h4(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <h4> element

h4_text

</> 
pub fn h4_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

h5

</> 
pub fn h5(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <h5> element

h5_text

</> 
pub fn h5_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

h6

</> 
pub fn h6(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <h6> element

h6_text

</> 
pub fn h6_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

</> 
pub fn head(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <head> element

</> 
pub fn header(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <header> element

header_text

</> 
pub fn header_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

hr

</> 
pub fn hr(attrs: List(Attribute)) -> Element

The HTML <hr /> element

html

</> 
pub fn html(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <html> element

i

</> 
pub fn i(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <i> element

i_text

</> 
pub fn i_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

iframe

</> 
pub fn iframe(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <iframe> element

iframe_text

</> 
pub fn iframe_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

ignored

</> 
pub fn ignored(element: Element) -> Element

img

</> 
pub fn img(attrs: List(Attribute)) -> Element

The HTML <img /> element

input

</> 
pub fn input(attrs: List(Attribute)) -> Element

The HTML <input /> element

ins

</> 
pub fn ins(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <ins> element

ins_text

</> 
pub fn ins_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

kbd

</> 
pub fn kbd(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <kbd> element

kbd_text

</> 
pub fn kbd_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

keyed

</> 
pub fn keyed(key: String, element: Element) -> Element

label

</> 
pub fn label(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <label> element

label_text

</> 
pub fn label_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

legend

</> 
pub fn legend(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <legend> element

legend_text

</> 
pub fn legend_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

li

</> 
pub fn li(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <li> element

li_text

</> 
pub fn li_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

</> 
pub fn link(attrs: List(Attribute)) -> Element

The HTML <link /> element

main

</> 
pub fn main(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <main> element

main_text

</> 
pub fn main_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

map

</> 
pub fn map(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <map> element

map_text

</> 
pub fn map_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

mark

</> 
pub fn mark(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <mark> element

mark_text

</> 
pub fn mark_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

math

</> 
pub fn math(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <math> element

math_text

</> 
pub fn math_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

</> 
pub fn menu(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <menu> element

menu_text

</> 
pub fn menu_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

</> 
pub fn menuitem(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <menuitem> element

menuitem_text

</> 
pub fn menuitem_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

meta

</> 
pub fn meta(attrs: List(Attribute)) -> Element

The HTML <meta /> element

meter

</> 
pub fn meter(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <meter> element

meter_text

</> 
pub fn meter_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

</> 
pub fn nav(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <nav> element

nav_text

</> 
pub fn nav_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

noscript

</> 
pub fn noscript(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <noscript> element

noscript_text

</> 
pub fn noscript_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

object

</> 
pub fn object(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <object> element

object_text

</> 
pub fn object_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

ol

</> 
pub fn ol(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <ol> element

ol_text

</> 
pub fn ol_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

optgroup

</> 
pub fn optgroup(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <optgroup> element

optgroup_text

</> 
pub fn optgroup_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

option

</> 
pub fn option(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <option> element

option_text

</> 
pub fn option_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

output

</> 
pub fn output(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <output> element

output_text

</> 
pub fn output_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

p

</> 
pub fn p(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <p> element

p_text

</> 
pub fn p_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

param

</> 
pub fn param(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <param> element

param_text

</> 
pub fn param_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

picture

</> 
pub fn picture(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <picture> element

picture_text

</> 
pub fn picture_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

pre

</> 
pub fn pre(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <pre> element

pre_text

</> 
pub fn pre_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

progress

</> 
pub fn progress(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <progress> element

progress_text

</> 
pub fn progress_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

q

</> 
pub fn q(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <q> element

q_text

</> 
pub fn q_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

rp

</> 
pub fn rp(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <rp> element

rp_text

</> 
pub fn rp_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

rt

</> 
pub fn rt(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <rt> element

rt_text

</> 
pub fn rt_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

ruby

</> 
pub fn ruby(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <ruby> element

ruby_text

</> 
pub fn ruby_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

s

</> 
pub fn s(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <s> element

s_text

</> 
pub fn s_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

samp

</> 
pub fn samp(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <samp> element

samp_text

</> 
pub fn samp_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

script

</> 
pub fn script(
  attrs: List(Attribute),
  body: Option(String),
) -> Element

The HTML <script> element

section

</> 
pub fn section(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <section> element

section_text

</> 
pub fn section_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

select

</> 
pub fn select(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <select> element

select_text

</> 
pub fn select_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

small

</> 
pub fn small(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <small> element

small_text

</> 
pub fn small_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

source

</> 
pub fn source(attrs: List(Attribute)) -> Element

The HTML <source /> element

span

</> 
pub fn span(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <span> element

span_text

</> 
pub fn span_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

strong

</> 
pub fn strong(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <strong> element

strong_text

</> 
pub fn strong_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

sub

</> 
pub fn sub(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <sub> element

sub_text

</> 
pub fn sub_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

summary

</> 
pub fn summary(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <summary> element

summary_text

</> 
pub fn summary_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

sup

</> 
pub fn sup(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <sup> element

sup_text

</> 
pub fn sup_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

svg

</> 
pub fn svg(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <svg> element

svg_text

</> 
pub fn svg_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

table

</> 
pub fn table(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <table> element

table_text

</> 
pub fn table_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

tbody

</> 
pub fn tbody(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <tbody> element

tbody_text

</> 
pub fn tbody_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

td

</> 
pub fn td(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <td> element

td_text

</> 
pub fn td_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

text

</> 
pub fn text(text: String) -> Element

textarea

</> 
pub fn textarea(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <textarea> element

textarea_text

</> 
pub fn textarea_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

tfoot

</> 
pub fn tfoot(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <tfoot> element

tfoot_text

</> 
pub fn tfoot_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

th

</> 
pub fn th(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <th> element

th_text

</> 
pub fn th_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

thead

</> 
pub fn thead(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <thead> element

thead_text

</> 
pub fn thead_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

time

</> 
pub fn time(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <time> element

time_text

</> 
pub fn time_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

title

</> 
pub fn title(title: String) -> Element

The HTML <title> element

tr

</> 
pub fn tr(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <tr> element

tr_text

</> 
pub fn tr_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

track

</> 
pub fn track(attrs: List(Attribute)) -> Element

The HTML <track /> element

u

</> 
pub fn u(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <u> element

u_text

</> 
pub fn u_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

ul

</> 
pub fn ul(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <ul> element

ul_text

</> 
pub fn ul_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

var

</> 
pub fn var(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <var> element

var_text

</> 
pub fn var_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

video

</> 
pub fn video(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <video> element

video_text

</> 
pub fn video_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

wbr

</> 
pub fn wbr(
  attrs: List(Attribute),
  children: List(Element),
) -> Element

The HTML <wbr> element

wbr_text

</> 
pub fn wbr_text(
  attrs: List(Attribute),
  text inner_text: String,
) -> Element

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

✨ Search Document