Top Level Namespace

Defined in:

Method Summary

Macro Summary

Method Detail

def a(attrs : NamedTuple) #

def a(content : String | Int) #

def a(attrs : NamedTuple, *elements) #

def a #

def a(attrs : NamedTuple, &) #

def a(&) #

Block Based DSL


def a(*elements) #

Argument Based DSL


def abbr(attrs : NamedTuple) #

def abbr(content : String | Int) #

def abbr(attrs : NamedTuple, *elements) #

def abbr #

def abbr(attrs : NamedTuple, &) #

def abbr(&) #

Block Based DSL


def abbr(*elements) #

Argument Based DSL


def address(attrs : NamedTuple) #

def address(content : String | Int) #

def address(attrs : NamedTuple, *elements) #

def address #

def address(attrs : NamedTuple, &) #

def address(&) #

Block Based DSL


def address(*elements) #

Argument Based DSL


def area(attrs : NamedTuple) #

def area(content : String | Int) #

def area(attrs : NamedTuple, *elements) #

def area #

def area(attrs : NamedTuple, &) #

def area(&) #

Block Based DSL


def area(*elements) #

Argument Based DSL


def article(attrs : NamedTuple) #

def article(content : String | Int) #

def article(attrs : NamedTuple, *elements) #

def article #

def article(attrs : NamedTuple, &) #

def article(&) #

Block Based DSL


def article(*elements) #

Argument Based DSL


def aside(attrs : NamedTuple) #

def aside(content : String | Int) #

def aside(attrs : NamedTuple, *elements) #

def aside #

def aside(attrs : NamedTuple, &) #

def aside(&) #

Block Based DSL


def aside(*elements) #

Argument Based DSL


def audio(attrs : NamedTuple) #

def audio(content : String | Int) #

def audio(attrs : NamedTuple, *elements) #

def audio #

def audio(attrs : NamedTuple, &) #

def audio(&) #

Block Based DSL


def audio(*elements) #

Argument Based DSL


def b(attrs : NamedTuple) #

def b(content : String | Int) #

def b(attrs : NamedTuple, *elements) #

def b #

def b(attrs : NamedTuple, &) #

def b(&) #

Block Based DSL


def b(*elements) #

Argument Based DSL


def base(attrs : NamedTuple) #

def base(content : String | Int) #

def base(attrs : NamedTuple, *elements) #

def base #

def base(attrs : NamedTuple, &) #

def base(&) #

Block Based DSL


def base(*elements) #

Argument Based DSL


def bdi(attrs : NamedTuple) #

def bdi(content : String | Int) #

def bdi(attrs : NamedTuple, *elements) #

def bdi #

def bdi(attrs : NamedTuple, &) #

def bdi(&) #

Block Based DSL


def bdi(*elements) #

Argument Based DSL


def bdo(attrs : NamedTuple) #

def bdo(content : String | Int) #

def bdo(attrs : NamedTuple, *elements) #

def bdo #

def bdo(attrs : NamedTuple, &) #

def bdo(&) #

Block Based DSL


def bdo(*elements) #

Argument Based DSL


def blockquote(attrs : NamedTuple) #

def blockquote(content : String | Int) #

def blockquote(attrs : NamedTuple, *elements) #

def blockquote #

def blockquote(attrs : NamedTuple, &) #

def blockquote(&) #

Block Based DSL


def blockquote(*elements) #

Argument Based DSL


def body(attrs : NamedTuple) #

def body(content : String | Int) #

def body(attrs : NamedTuple, *elements) #

def body #

def body(attrs : NamedTuple, &) #

def body(&) #

Block Based DSL


def body(*elements) #

Argument Based DSL


def br(attrs : NamedTuple) #

def br(content : String | Int) #

def br(attrs : NamedTuple, *elements) #

def br #

def br(attrs : NamedTuple, &) #

def br(&) #

Block Based DSL


def br(*elements) #

Argument Based DSL


def button(attrs : NamedTuple) #

def button(content : String | Int) #

def button(attrs : NamedTuple, *elements) #

def button #

def button(attrs : NamedTuple, &) #

def button(&) #

Block Based DSL


def button(*elements) #

Argument Based DSL


def canvas(attrs : NamedTuple) #

def canvas(content : String | Int) #

def canvas(attrs : NamedTuple, *elements) #

def canvas #

def canvas(attrs : NamedTuple, &) #

def canvas(&) #

Block Based DSL


def canvas(*elements) #

Argument Based DSL


def caption(attrs : NamedTuple) #

def caption(content : String | Int) #

def caption(attrs : NamedTuple, *elements) #

def caption #

def caption(attrs : NamedTuple, &) #

def caption(&) #

Block Based DSL


def caption(*elements) #

Argument Based DSL


def cite(attrs : NamedTuple) #

def cite(content : String | Int) #

def cite(attrs : NamedTuple, *elements) #

def cite #

def cite(attrs : NamedTuple, &) #

def cite(&) #

Block Based DSL


def cite(*elements) #

Argument Based DSL


def code(attrs : NamedTuple) #

def code(content : String | Int) #

def code(attrs : NamedTuple, *elements) #

def code #

def code(attrs : NamedTuple, &) #

def code(&) #

Block Based DSL


def code(*elements) #

Argument Based DSL


def col(attrs : NamedTuple) #

def col(content : String | Int) #

def col(attrs : NamedTuple, *elements) #

def col #

def col(attrs : NamedTuple, &) #

def col(&) #

Block Based DSL


def col(*elements) #

Argument Based DSL


def colgroup(attrs : NamedTuple) #

def colgroup(content : String | Int) #

def colgroup(attrs : NamedTuple, *elements) #

def colgroup #

def colgroup(attrs : NamedTuple, &) #

def colgroup(&) #

Block Based DSL


def colgroup(*elements) #

Argument Based DSL


def command(attrs : NamedTuple) #

def command(content : String | Int) #

def command(attrs : NamedTuple, *elements) #

def command #

def command(attrs : NamedTuple, &) #

def command(&) #

Block Based DSL


def command(*elements) #

Argument Based DSL


def comment(text) #

[View source]
def datalist(attrs : NamedTuple) #

def datalist(content : String | Int) #

def datalist(attrs : NamedTuple, *elements) #

def datalist #

def datalist(attrs : NamedTuple, &) #

def datalist(&) #

Block Based DSL


def datalist(*elements) #

Argument Based DSL


def dd(attrs : NamedTuple) #

def dd(content : String | Int) #

def dd(attrs : NamedTuple, *elements) #

def dd #

def dd(attrs : NamedTuple, &) #

def dd(&) #

Block Based DSL


def dd(*elements) #

Argument Based DSL


def del(attrs : NamedTuple) #

def del(content : String | Int) #

def del(attrs : NamedTuple, *elements) #

def del #

def del(attrs : NamedTuple, &) #

def del(&) #

Block Based DSL


def del(*elements) #

Argument Based DSL


def details(attrs : NamedTuple) #

def details(content : String | Int) #

def details(attrs : NamedTuple, *elements) #

def details #

def details(attrs : NamedTuple, &) #

def details(&) #

Block Based DSL


def details(*elements) #

Argument Based DSL


def dfn(attrs : NamedTuple) #

def dfn(content : String | Int) #

def dfn(attrs : NamedTuple, *elements) #

def dfn #

def dfn(attrs : NamedTuple, &) #

def dfn(&) #

Block Based DSL


def dfn(*elements) #

Argument Based DSL


def div(attrs : NamedTuple) #

def div(content : String | Int) #

def div(attrs : NamedTuple, *elements) #

def div #

def div(attrs : NamedTuple, &) #

def div(&) #

Block Based DSL


def div(*elements) #

Argument Based DSL


def dl(attrs : NamedTuple) #

def dl(content : String | Int) #

def dl(attrs : NamedTuple, *elements) #

def dl #

def dl(attrs : NamedTuple, &) #

def dl(&) #

Block Based DSL


def dl(*elements) #

Argument Based DSL


def dt(attrs : NamedTuple) #

def dt(content : String | Int) #

def dt(attrs : NamedTuple, *elements) #

def dt #

def dt(attrs : NamedTuple, &) #

def dt(&) #

Block Based DSL


def dt(*elements) #

Argument Based DSL


def em(attrs : NamedTuple) #

def em(content : String | Int) #

def em(attrs : NamedTuple, *elements) #

def em #

def em(attrs : NamedTuple, &) #

def em(&) #

Block Based DSL


def em(*elements) #

Argument Based DSL


def embed(attrs : NamedTuple) #

def embed(content : String | Int) #

def embed(attrs : NamedTuple, *elements) #

def embed #

def embed(attrs : NamedTuple, &) #

def embed(&) #

Block Based DSL


def embed(*elements) #

Argument Based DSL


def fieldset(attrs : NamedTuple) #

def fieldset(content : String | Int) #

def fieldset(attrs : NamedTuple, *elements) #

def fieldset #

def fieldset(attrs : NamedTuple, &) #

def fieldset(&) #

Block Based DSL


def fieldset(*elements) #

Argument Based DSL


def figcaption(attrs : NamedTuple) #

def figcaption(content : String | Int) #

def figcaption(attrs : NamedTuple, *elements) #

def figcaption #

def figcaption(attrs : NamedTuple, &) #

def figcaption(&) #

Block Based DSL


def figcaption(*elements) #

Argument Based DSL


def figure(attrs : NamedTuple) #

def figure(content : String | Int) #

def figure(attrs : NamedTuple, *elements) #

def figure #

def figure(attrs : NamedTuple, &) #

def figure(&) #

Block Based DSL


def figure(*elements) #

Argument Based DSL


def footer(attrs : NamedTuple) #

def footer(content : String | Int) #

def footer(attrs : NamedTuple, *elements) #

def footer #

def footer(attrs : NamedTuple, &) #

def footer(&) #

Block Based DSL


def footer(*elements) #

Argument Based DSL


def form(attrs : NamedTuple) #

def form(content : String | Int) #

def form(attrs : NamedTuple, *elements) #

def form #

def form(attrs : NamedTuple, &) #

def form(&) #

Block Based DSL


def form(*elements) #

Argument Based DSL


def h1(attrs : NamedTuple) #

def h1(content : String | Int) #

def h1(attrs : NamedTuple, *elements) #

def h1 #

def h1(attrs : NamedTuple, &) #

def h1(&) #

Block Based DSL


def h1(*elements) #

Argument Based DSL


def h2(attrs : NamedTuple) #

def h2(content : String | Int) #

def h2(attrs : NamedTuple, *elements) #

def h2 #

def h2(attrs : NamedTuple, &) #

def h2(&) #

Block Based DSL


def h2(*elements) #

Argument Based DSL


def h3(attrs : NamedTuple) #

def h3(content : String | Int) #

def h3(attrs : NamedTuple, *elements) #

def h3 #

def h3(attrs : NamedTuple, &) #

def h3(&) #

Block Based DSL


def h3(*elements) #

Argument Based DSL


def h4(attrs : NamedTuple) #

def h4(content : String | Int) #

def h4(attrs : NamedTuple, *elements) #

def h4 #

def h4(attrs : NamedTuple, &) #

def h4(&) #

Block Based DSL


def h4(*elements) #

Argument Based DSL


def h5(attrs : NamedTuple) #

def h5(content : String | Int) #

def h5(attrs : NamedTuple, *elements) #

def h5 #

def h5(attrs : NamedTuple, &) #

def h5(&) #

Block Based DSL


def h5(*elements) #

Argument Based DSL


def h6(attrs : NamedTuple) #

def h6(content : String | Int) #

def h6(attrs : NamedTuple, *elements) #

def h6 #

def h6(attrs : NamedTuple, &) #

def h6(&) #

Block Based DSL


def h6(*elements) #

Argument Based DSL


def head(attrs : NamedTuple) #

def head(content : String | Int) #

def head(attrs : NamedTuple, *elements) #

def head #

def head(attrs : NamedTuple, &) #

def head(&) #

Block Based DSL


def head(*elements) #

Argument Based DSL


def header(attrs : NamedTuple) #

def header(content : String | Int) #

def header(attrs : NamedTuple, *elements) #

def header #

def header(attrs : NamedTuple, &) #

def header(&) #

Block Based DSL


def header(*elements) #

Argument Based DSL


def hgroup(attrs : NamedTuple) #

def hgroup(content : String | Int) #

def hgroup(attrs : NamedTuple, *elements) #

def hgroup #

def hgroup(attrs : NamedTuple, &) #

def hgroup(&) #

Block Based DSL


def hgroup(*elements) #

Argument Based DSL


def hr(attrs : NamedTuple) #

def hr(content : String | Int) #

def hr(attrs : NamedTuple, *elements) #

def hr #

def hr(attrs : NamedTuple, &) #

def hr(&) #

Block Based DSL


def hr(*elements) #

Argument Based DSL


def html(attrs : NamedTuple) #

def html(content : String | Int) #

def html(attrs : NamedTuple, *elements) #

def html #

def html(attrs : NamedTuple, &) #

def html(&) #

Block Based DSL


def html(*elements) #

Argument Based DSL


def i(attrs : NamedTuple) #

def i(content : String | Int) #

def i(attrs : NamedTuple, *elements) #

def i #

def i(attrs : NamedTuple, &) #

def i(&) #

Block Based DSL


def i(*elements) #

Argument Based DSL


def iframe(attrs : NamedTuple) #

def iframe(content : String | Int) #

def iframe(attrs : NamedTuple, *elements) #

def iframe #

def iframe(attrs : NamedTuple, &) #

def iframe(&) #

Block Based DSL


def iframe(*elements) #

Argument Based DSL


def img(attrs : NamedTuple) #

def img(content : String | Int) #

def img(attrs : NamedTuple, *elements) #

def img #

def img(attrs : NamedTuple, &) #

def img(&) #

Block Based DSL


def img(*elements) #

Argument Based DSL


def input(attrs : NamedTuple) #

def input(content : String | Int) #

def input(attrs : NamedTuple, *elements) #

def input #

def input(attrs : NamedTuple, &) #

def input(&) #

Block Based DSL


def input(*elements) #

Argument Based DSL


def ins(attrs : NamedTuple) #

def ins(content : String | Int) #

def ins(attrs : NamedTuple, *elements) #

def ins #

def ins(attrs : NamedTuple, &) #

def ins(&) #

Block Based DSL


def ins(*elements) #

Argument Based DSL


def kbd(attrs : NamedTuple) #

def kbd(content : String | Int) #

def kbd(attrs : NamedTuple, *elements) #

def kbd #

def kbd(attrs : NamedTuple, &) #

def kbd(&) #

Block Based DSL


def kbd(*elements) #

Argument Based DSL


def keygen(attrs : NamedTuple) #

def keygen(content : String | Int) #

def keygen(attrs : NamedTuple, *elements) #

def keygen #

def keygen(attrs : NamedTuple, &) #

def keygen(&) #

Block Based DSL


def keygen(*elements) #

Argument Based DSL


def label(attrs : NamedTuple) #

def label(content : String | Int) #

def label(attrs : NamedTuple, *elements) #

def label #

def label(attrs : NamedTuple, &) #

def label(&) #

Block Based DSL


def label(*elements) #

Argument Based DSL


def legend(attrs : NamedTuple) #

def legend(content : String | Int) #

def legend(attrs : NamedTuple, *elements) #

def legend #

def legend(attrs : NamedTuple, &) #

def legend(&) #

Block Based DSL


def legend(*elements) #

Argument Based DSL


def li(attrs : NamedTuple) #

def li(content : String | Int) #

def li(attrs : NamedTuple, *elements) #

def li #

def li(attrs : NamedTuple, &) #

def li(&) #

Block Based DSL


def li(*elements) #

Argument Based DSL


def link(attrs : NamedTuple) #

def link(content : String | Int) #

def link(attrs : NamedTuple, *elements) #

def link #

def link(attrs : NamedTuple, &) #

def link(&) #

Block Based DSL


def link(*elements) #

Argument Based DSL


def map(attrs : NamedTuple) #

def map(content : String | Int) #

def map(attrs : NamedTuple, *elements) #

def map #

def map(attrs : NamedTuple, &) #

def map(&) #

Block Based DSL


def map(*elements) #

Argument Based DSL


def mark(attrs : NamedTuple) #

def mark(content : String | Int) #

def mark(attrs : NamedTuple, *elements) #

def mark #

def mark(attrs : NamedTuple, &) #

def mark(&) #

Block Based DSL


def mark(*elements) #

Argument Based DSL


def menu(attrs : NamedTuple) #

def menu(content : String | Int) #

def menu(attrs : NamedTuple, *elements) #

def menu #

def menu(attrs : NamedTuple, &) #

def menu(&) #

Block Based DSL


def menu(*elements) #

Argument Based DSL


def meta(attrs : NamedTuple) #

def meta(content : String | Int) #

def meta(attrs : NamedTuple, *elements) #

def meta #

def meta(attrs : NamedTuple, &) #

def meta(&) #

Block Based DSL


def meta(*elements) #

Argument Based DSL


def meter(attrs : NamedTuple) #

def meter(content : String | Int) #

def meter(attrs : NamedTuple, *elements) #

def meter #

def meter(attrs : NamedTuple, &) #

def meter(&) #

Block Based DSL


def meter(*elements) #

Argument Based DSL


def nav(attrs : NamedTuple) #

def nav(content : String | Int) #

def nav(attrs : NamedTuple, *elements) #

def nav #

def nav(attrs : NamedTuple, &) #

def nav(&) #

Block Based DSL


def nav(*elements) #

Argument Based DSL


def noscript(attrs : NamedTuple) #

def noscript(content : String | Int) #

def noscript(attrs : NamedTuple, *elements) #

def noscript #

def noscript(attrs : NamedTuple, &) #

def noscript(&) #

Block Based DSL


def noscript(*elements) #

Argument Based DSL


def object(attrs : NamedTuple) #

def object(content : String | Int) #

def object(attrs : NamedTuple, *elements) #

def object #

def object(attrs : NamedTuple, &) #

def object(&) #

Block Based DSL


def object(*elements) #

Argument Based DSL


def ol(attrs : NamedTuple) #

def ol(content : String | Int) #

def ol(attrs : NamedTuple, *elements) #

def ol #

def ol(attrs : NamedTuple, &) #

def ol(&) #

Block Based DSL


def ol(*elements) #

Argument Based DSL


def optgroup(attrs : NamedTuple) #

def optgroup(content : String | Int) #

def optgroup(attrs : NamedTuple, *elements) #

def optgroup #

def optgroup(attrs : NamedTuple, &) #

def optgroup(&) #

Block Based DSL


def optgroup(*elements) #

Argument Based DSL


def option(attrs : NamedTuple) #

def option(content : String | Int) #

def option(attrs : NamedTuple, *elements) #

def option #

def option(attrs : NamedTuple, &) #

def option(&) #

Block Based DSL


def option(*elements) #

Argument Based DSL


def output(attrs : NamedTuple) #

def output(content : String | Int) #

def output(attrs : NamedTuple, *elements) #

def output #

def output(attrs : NamedTuple, &) #

def output(&) #

Block Based DSL


def output(*elements) #

Argument Based DSL


def p(attrs : NamedTuple) #

def p(content : String | Int) #

def p(attrs : NamedTuple, *elements) #

def p #

def p(*elements) #

Argument Based DSL


def p(attrs : NamedTuple, &) #

def p(&) #

Block Based DSL


def param(attrs : NamedTuple) #

def param(content : String | Int) #

def param(attrs : NamedTuple, *elements) #

def param #

def param(attrs : NamedTuple, &) #

def param(&) #

Block Based DSL


def param(*elements) #

Argument Based DSL


def pre(attrs : NamedTuple) #

def pre(content : String | Int) #

def pre(attrs : NamedTuple, *elements) #

def pre #

def pre(attrs : NamedTuple, &) #

def pre(&) #

Block Based DSL


def pre(*elements) #

Argument Based DSL


def progress(attrs : NamedTuple) #

def progress(content : String | Int) #

def progress(attrs : NamedTuple, *elements) #

def progress #

def progress(attrs : NamedTuple, &) #

def progress(&) #

Block Based DSL


def progress(*elements) #

Argument Based DSL


def q(attrs : NamedTuple) #

def q(content : String | Int) #

def q(attrs : NamedTuple, *elements) #

def q #

def q(attrs : NamedTuple, &) #

def q(&) #

Block Based DSL


def q(*elements) #

Argument Based DSL


def rp(attrs : NamedTuple) #

def rp(content : String | Int) #

def rp(attrs : NamedTuple, *elements) #

def rp #

def rp(attrs : NamedTuple, &) #

def rp(&) #

Block Based DSL


def rp(*elements) #

Argument Based DSL


def rt(attrs : NamedTuple) #

def rt(content : String | Int) #

def rt(attrs : NamedTuple, *elements) #

def rt #

def rt(attrs : NamedTuple, &) #

def rt(&) #

Block Based DSL


def rt(*elements) #

Argument Based DSL


def ruby(attrs : NamedTuple) #

def ruby(content : String | Int) #

def ruby(attrs : NamedTuple, *elements) #

def ruby #

def ruby(attrs : NamedTuple, &) #

def ruby(&) #

Block Based DSL


def ruby(*elements) #

Argument Based DSL


def s(attrs : NamedTuple) #

def s(content : String | Int) #

def s(attrs : NamedTuple, *elements) #

def s #

def s(attrs : NamedTuple, &) #

def s(&) #

Block Based DSL


def s(*elements) #

Argument Based DSL


def samp(attrs : NamedTuple) #

def samp(content : String | Int) #

def samp(attrs : NamedTuple, *elements) #

def samp #

def samp(attrs : NamedTuple, &) #

def samp(&) #

Block Based DSL


def samp(*elements) #

Argument Based DSL


def script(attrs : NamedTuple) #

def script(content : String | Int) #

def script(attrs : NamedTuple, *elements) #

def script #

def script(attrs : NamedTuple, &) #

def script(&) #

Block Based DSL


def script(*elements) #

Argument Based DSL


def section(attrs : NamedTuple) #

def section(content : String | Int) #

def section(attrs : NamedTuple, *elements) #

def section #

def section(attrs : NamedTuple, &) #

def section(&) #

Block Based DSL


def section(*elements) #

Argument Based DSL


def select(attrs : NamedTuple) #

def select(content : String | Int) #

def select(attrs : NamedTuple, *elements) #

def select #

def select(attrs : NamedTuple, &) #

def select(&) #

Block Based DSL


def select(*elements) #

Argument Based DSL


def small(attrs : NamedTuple) #

def small(content : String | Int) #

def small(attrs : NamedTuple, *elements) #

def small #

def small(attrs : NamedTuple, &) #

def small(&) #

Block Based DSL


def small(*elements) #

Argument Based DSL


def source(attrs : NamedTuple) #

def source(content : String | Int) #

def source(attrs : NamedTuple, *elements) #

def source #

def source(attrs : NamedTuple, &) #

def source(&) #

Block Based DSL


def source(*elements) #

Argument Based DSL


def span(attrs : NamedTuple) #

def span(content : String | Int) #

def span(attrs : NamedTuple, *elements) #

def span #

def span(attrs : NamedTuple, &) #

def span(&) #

Block Based DSL


def span(*elements) #

Argument Based DSL


def strong(attrs : NamedTuple) #

def strong(content : String | Int) #

def strong(attrs : NamedTuple, *elements) #

def strong #

def strong(attrs : NamedTuple, &) #

def strong(&) #

Block Based DSL


def strong(*elements) #

Argument Based DSL


def style(attrs : NamedTuple) #

def style(content : String | Int) #

def style(attrs : NamedTuple, *elements) #

def style #

def style(attrs : NamedTuple, &) #

def style(&) #

Block Based DSL


def style(*elements) #

Argument Based DSL


def sub(attrs : NamedTuple) #

def sub(content : String | Int) #

def sub(attrs : NamedTuple, *elements) #

def sub #

def sub(attrs : NamedTuple, &) #

def sub(&) #

Block Based DSL


def sub(*elements) #

Argument Based DSL


def summary(attrs : NamedTuple) #

def summary(content : String | Int) #

def summary(attrs : NamedTuple, *elements) #

def summary #

def summary(attrs : NamedTuple, &) #

def summary(&) #

Block Based DSL


def summary(*elements) #

Argument Based DSL


def sup(attrs : NamedTuple) #

def sup(content : String | Int) #

def sup(attrs : NamedTuple, *elements) #

def sup #

def sup(attrs : NamedTuple, &) #

def sup(&) #

Block Based DSL


def sup(*elements) #

Argument Based DSL


def table(attrs : NamedTuple) #

def table(content : String | Int) #

def table(attrs : NamedTuple, *elements) #

def table #

def table(attrs : NamedTuple, &) #

def table(&) #

Block Based DSL


def table(*elements) #

Argument Based DSL


def tbody(attrs : NamedTuple) #

def tbody(content : String | Int) #

def tbody(attrs : NamedTuple, *elements) #

def tbody #

def tbody(attrs : NamedTuple, &) #

def tbody(&) #

Block Based DSL


def tbody(*elements) #

Argument Based DSL


def td(attrs : NamedTuple) #

def td(content : String | Int) #

def td(attrs : NamedTuple, *elements) #

def td #

def td(attrs : NamedTuple, &) #

def td(&) #

Block Based DSL


def td(*elements) #

Argument Based DSL


def textarea(attrs : NamedTuple) #

def textarea(content : String | Int) #

def textarea(attrs : NamedTuple, *elements) #

def textarea #

def textarea(attrs : NamedTuple, &) #

def textarea(&) #

Block Based DSL


def textarea(*elements) #

Argument Based DSL


def tfoot(attrs : NamedTuple) #

def tfoot(content : String | Int) #

def tfoot(attrs : NamedTuple, *elements) #

def tfoot #

def tfoot(attrs : NamedTuple, &) #

def tfoot(&) #

Block Based DSL


def tfoot(*elements) #

Argument Based DSL


def th(attrs : NamedTuple) #

def th(content : String | Int) #

def th(attrs : NamedTuple, *elements) #

def th #

def th(attrs : NamedTuple, &) #

def th(&) #

Block Based DSL


def th(*elements) #

Argument Based DSL


def thead(attrs : NamedTuple) #

def thead(content : String | Int) #

def thead(attrs : NamedTuple, *elements) #

def thead #

def thead(attrs : NamedTuple, &) #

def thead(&) #

Block Based DSL


def thead(*elements) #

Argument Based DSL


def time(attrs : NamedTuple) #

def time(content : String | Int) #

def time(attrs : NamedTuple, *elements) #

def time #

def time(attrs : NamedTuple, &) #

def time(&) #

Block Based DSL


def time(*elements) #

Argument Based DSL


def title(attrs : NamedTuple) #

def title(content : String | Int) #

def title(attrs : NamedTuple, *elements) #

def title #

def title(attrs : NamedTuple, &) #

def title(&) #

Block Based DSL


def title(*elements) #

Argument Based DSL


def tr(attrs : NamedTuple) #

def tr(content : String | Int) #

def tr(attrs : NamedTuple, *elements) #

def tr #

def tr(attrs : NamedTuple, &) #

def tr(&) #

Block Based DSL


def tr(*elements) #

Argument Based DSL


def track(attrs : NamedTuple) #

def track(content : String | Int) #

def track(attrs : NamedTuple, *elements) #

def track #

def track(attrs : NamedTuple, &) #

def track(&) #

Block Based DSL


def track(*elements) #

Argument Based DSL


def u(attrs : NamedTuple) #

def u(content : String | Int) #

def u(attrs : NamedTuple, *elements) #

def u #

def u(attrs : NamedTuple, &) #

def u(&) #

Block Based DSL


def u(*elements) #

Argument Based DSL


def ul(attrs : NamedTuple) #

def ul(content : String | Int) #

def ul(attrs : NamedTuple, *elements) #

def ul #

def ul(attrs : NamedTuple, &) #

def ul(&) #

Block Based DSL


def ul(*elements) #

Argument Based DSL


def var(attrs : NamedTuple) #

def var(content : String | Int) #

def var(attrs : NamedTuple, *elements) #

def var #

def var(attrs : NamedTuple, &) #

def var(&) #

Block Based DSL


def var(*elements) #

Argument Based DSL


def video(attrs : NamedTuple) #

def video(content : String | Int) #

def video(attrs : NamedTuple, *elements) #

def video #

def video(attrs : NamedTuple, &) #

def video(&) #

Block Based DSL


def video(*elements) #

Argument Based DSL


def wbr(attrs : NamedTuple) #

def wbr(content : String | Int) #

def wbr(attrs : NamedTuple, *elements) #

def wbr #

def wbr(attrs : NamedTuple, &) #

def wbr(&) #

Block Based DSL


def wbr(*elements) #

Argument Based DSL


Macro Detail

macro attributes(list) #

[View source]
macro legalize_tag(name) #

[View source]
macro tag(name) #

[View source]