module Lucky::BaseTags

Included Modules

Direct including types

Defined in:

lucky/tags/base_tags.cr

Constant Summary

EMPTY_HTML_ATTRS = {} of String => String
EMPTY_TAGS = [:img, :br, :hr, :input, :meta, :source] of ::Symbol
RENAMED_TAGS = {para: "p", select_tag: "select"}
TAGS = [:a, :abbr, :address, :area, :article, :aside, :b, :bdi, :bdo, :blockquote, :body, :button, :caption, :cite, :code, :col, :colgroup, :data, :datalist, :del, :details, :dfn, :dialog, :div, :dd, :dl, :dt, :em, :embed, :fieldset, :figcaption, :figure, :footer, :form, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :html, :i, :iframe, :ins, :kbd, :label, :legend, :li, :main, :map, :mark, :menuitem, :meter, :nav, :noscript, :object, :ol, :optgroup, :option, :output, :param, :picture, :pre, :progress, :q, :rp, :rt, :ruby, :s, :samp, :script, :section, :slot, :small, :span, :strong, :sub, :summary, :sup, :table, :tbody, :td, :template, :textarea, :tfoot, :th, :thead, :time, :title, :tr, :track, :u, :ul, :video, :wbr] of ::Symbol

Macro Summary

Instance Method Summary

Macro Detail

macro generate_tag_methods(method_name, tag) #

[View source]

Instance Method Detail

def a(content : Lucky::AllowedInTags | String) : Nil #

def a(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a <a></a> tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
a("Sample", {"class" => "cls-1 red"}, [:required]) #=> <a class="cls-1 red" required>Sample</a>

def a(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def a(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def a(options, **other_options) : Nil #

def a(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def a(&) : Nil #

def a(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def abbr(content : Lucky::AllowedInTags | String) : Nil #

def abbr(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;abbr&gt;&lt;/abbr&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
abbr("Sample", {"class" => "cls-1 red"}, [:required]) #=> <abbr class="cls-1 red" required>Sample</abbr>

def abbr(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def abbr(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def abbr(options, **other_options) : Nil #

def abbr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def abbr(&) : Nil #

def abbr(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def address(content : Lucky::AllowedInTags | String) : Nil #

def address(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;address&gt;&lt;/address&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
address("Sample", {"class" => "cls-1 red"}, [:required]) #=> <address class="cls-1 red" required>Sample</address>

def address(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def address(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def address(options, **other_options) : Nil #

def address(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def address(&) : Nil #

def address(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def area(content : Lucky::AllowedInTags | String) : Nil #

def area(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;area&gt;&lt;/area&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
area("Sample", {"class" => "cls-1 red"}, [:required]) #=> <area class="cls-1 red" required>Sample</area>

def area(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def area(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def area(options, **other_options) : Nil #

def area(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def area(&) : Nil #

def area(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def article(content : Lucky::AllowedInTags | String) : Nil #

def article(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;article&gt;&lt;/article&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
article("Sample", {"class" => "cls-1 red"}, [:required]) #=> <article class="cls-1 red" required>Sample</article>

def article(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def article(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def article(options, **other_options) : Nil #

def article(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def article(&) : Nil #

def article(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def aside(content : Lucky::AllowedInTags | String) : Nil #

def aside(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;aside&gt;&lt;/aside&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
aside("Sample", {"class" => "cls-1 red"}, [:required]) #=> <aside class="cls-1 red" required>Sample</aside>

def aside(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def aside(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def aside(options, **other_options) : Nil #

def aside(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def aside(&) : Nil #

def aside(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def b(content : Lucky::AllowedInTags | String) : Nil #

def b(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;b&gt;&lt;/b&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
b("Sample", {"class" => "cls-1 red"}, [:required]) #=> <b class="cls-1 red" required>Sample</b>

def b(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def b(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def b(options, **other_options) : Nil #

def b(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def b(&) : Nil #

def b(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def bdi(content : Lucky::AllowedInTags | String) : Nil #

def bdi(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;bdi&gt;&lt;/bdi&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
bdi("Sample", {"class" => "cls-1 red"}, [:required]) #=> <bdi class="cls-1 red" required>Sample</bdi>

def bdi(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdi(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdi(options, **other_options) : Nil #

def bdi(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def bdi(&) : Nil #

def bdi(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def bdo(content : Lucky::AllowedInTags | String) : Nil #

def bdo(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;bdo&gt;&lt;/bdo&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
bdo("Sample", {"class" => "cls-1 red"}, [:required]) #=> <bdo class="cls-1 red" required>Sample</bdo>

def bdo(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdo(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def bdo(options, **other_options) : Nil #

def bdo(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def bdo(&) : Nil #

def bdo(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def blockquote(content : Lucky::AllowedInTags | String) : Nil #

def blockquote(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;blockquote&gt;&lt;/blockquote&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
blockquote("Sample", {"class" => "cls-1 red"}, [:required]) #=> <blockquote class="cls-1 red" required>Sample</blockquote>

def blockquote(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def blockquote(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def blockquote(options, **other_options) : Nil #

def blockquote(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def blockquote(&) : Nil #

def blockquote(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def body(content : Lucky::AllowedInTags | String) : Nil #

def body(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;body&gt;&lt;/body&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
body("Sample", {"class" => "cls-1 red"}, [:required]) #=> <body class="cls-1 red" required>Sample</body>

def body(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def body(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def body(options, **other_options) : Nil #

def body(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def body(&) : Nil #

def body(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def br(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;br&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
br([:required], {"class" => "cls-1"}) #=> <br class="cls-1" required>

[View source]
def br : Nil #

Generates a &lt;br&gt; tag.


[View source]
def br(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def button(content : Lucky::AllowedInTags | String) : Nil #

def button(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;button&gt;&lt;/button&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
button("Sample", {"class" => "cls-1 red"}, [:required]) #=> <button class="cls-1 red" required>Sample</button>

def button(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def button(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def button(options, **other_options) : Nil #

def button(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def button(&) : Nil #

def button(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def caption(content : Lucky::AllowedInTags | String) : Nil #

def caption(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;caption&gt;&lt;/caption&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
caption("Sample", {"class" => "cls-1 red"}, [:required]) #=> <caption class="cls-1 red" required>Sample</caption>

def caption(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def caption(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def caption(options, **other_options) : Nil #

def caption(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def caption(&) : Nil #

def caption(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def cite(content : Lucky::AllowedInTags | String) : Nil #

def cite(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;cite&gt;&lt;/cite&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
cite("Sample", {"class" => "cls-1 red"}, [:required]) #=> <cite class="cls-1 red" required>Sample</cite>

def cite(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def cite(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def cite(options, **other_options) : Nil #

def cite(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def cite(&) : Nil #

def cite(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def code(content : Lucky::AllowedInTags | String) : Nil #

def code(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;code&gt;&lt;/code&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
code("Sample", {"class" => "cls-1 red"}, [:required]) #=> <code class="cls-1 red" required>Sample</code>

def code(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def code(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def code(options, **other_options) : Nil #

def code(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def code(&) : Nil #

def code(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def col(content : Lucky::AllowedInTags | String) : Nil #

def col(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;col&gt;&lt;/col&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
col("Sample", {"class" => "cls-1 red"}, [:required]) #=> <col class="cls-1 red" required>Sample</col>

def col(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def col(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def col(options, **other_options) : Nil #

def col(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def col(&) : Nil #

def col(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def colgroup(content : Lucky::AllowedInTags | String) : Nil #

def colgroup(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;colgroup&gt;&lt;/colgroup&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
colgroup("Sample", {"class" => "cls-1 red"}, [:required]) #=> <colgroup class="cls-1 red" required>Sample</colgroup>

def colgroup(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def colgroup(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def colgroup(options, **other_options) : Nil #

def colgroup(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def colgroup(&) : Nil #

def colgroup(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def data(content : Lucky::AllowedInTags | String) : Nil #

def data(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;data&gt;&lt;/data&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
data("Sample", {"class" => "cls-1 red"}, [:required]) #=> <data class="cls-1 red" required>Sample</data>

def data(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def data(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def data(options, **other_options) : Nil #

def data(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def data(&) : Nil #

def data(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def datalist(content : Lucky::AllowedInTags | String) : Nil #

def datalist(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;datalist&gt;&lt;/datalist&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
datalist("Sample", {"class" => "cls-1 red"}, [:required]) #=> <datalist class="cls-1 red" required>Sample</datalist>

def datalist(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def datalist(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def datalist(options, **other_options) : Nil #

def datalist(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def datalist(&) : Nil #

def datalist(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dd(content : Lucky::AllowedInTags | String) : Nil #

def dd(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dd&gt;&lt;/dd&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dd("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dd class="cls-1 red" required>Sample</dd>

def dd(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dd(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dd(options, **other_options) : Nil #

def dd(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dd(&) : Nil #

def dd(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def del(content : Lucky::AllowedInTags | String) : Nil #

def del(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;del&gt;&lt;/del&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
del("Sample", {"class" => "cls-1 red"}, [:required]) #=> <del class="cls-1 red" required>Sample</del>

def del(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def del(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def del(options, **other_options) : Nil #

def del(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def del(&) : Nil #

def del(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def details(content : Lucky::AllowedInTags | String) : Nil #

def details(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;details&gt;&lt;/details&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
details("Sample", {"class" => "cls-1 red"}, [:required]) #=> <details class="cls-1 red" required>Sample</details>

def details(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def details(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def details(options, **other_options) : Nil #

def details(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def details(&) : Nil #

def details(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dfn(content : Lucky::AllowedInTags | String) : Nil #

def dfn(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dfn&gt;&lt;/dfn&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dfn("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dfn class="cls-1 red" required>Sample</dfn>

def dfn(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dfn(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dfn(options, **other_options) : Nil #

def dfn(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dfn(&) : Nil #

def dfn(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dialog(content : Lucky::AllowedInTags | String) : Nil #

def dialog(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dialog&gt;&lt;/dialog&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dialog("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dialog class="cls-1 red" required>Sample</dialog>

def dialog(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dialog(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dialog(options, **other_options) : Nil #

def dialog(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dialog(&) : Nil #

def dialog(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def div(content : Lucky::AllowedInTags | String) : Nil #

def div(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;div&gt;&lt;/div&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
div("Sample", {"class" => "cls-1 red"}, [:required]) #=> <div class="cls-1 red" required>Sample</div>

def div(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def div(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def div(options, **other_options) : Nil #

def div(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def div(&) : Nil #

def div(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dl(content : Lucky::AllowedInTags | String) : Nil #

def dl(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dl&gt;&lt;/dl&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dl("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dl class="cls-1 red" required>Sample</dl>

def dl(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dl(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dl(options, **other_options) : Nil #

def dl(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dl(&) : Nil #

def dl(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dt(content : Lucky::AllowedInTags | String) : Nil #

def dt(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;dt&gt;&lt;/dt&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
dt("Sample", {"class" => "cls-1 red"}, [:required]) #=> <dt class="cls-1 red" required>Sample</dt>

def dt(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dt(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def dt(options, **other_options) : Nil #

def dt(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def dt(&) : Nil #

def dt(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def em(content : Lucky::AllowedInTags | String) : Nil #

def em(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;em&gt;&lt;/em&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
em("Sample", {"class" => "cls-1 red"}, [:required]) #=> <em class="cls-1 red" required>Sample</em>

def em(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def em(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def em(options, **other_options) : Nil #

def em(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def em(&) : Nil #

def em(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def embed(content : Lucky::AllowedInTags | String) : Nil #

def embed(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;embed&gt;&lt;/embed&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
embed("Sample", {"class" => "cls-1 red"}, [:required]) #=> <embed class="cls-1 red" required>Sample</embed>

def embed(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def embed(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def embed(options, **other_options) : Nil #

def embed(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def embed(&) : Nil #

def embed(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def fieldset(content : Lucky::AllowedInTags | String) : Nil #

def fieldset(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;fieldset&gt;&lt;/fieldset&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
fieldset("Sample", {"class" => "cls-1 red"}, [:required]) #=> <fieldset class="cls-1 red" required>Sample</fieldset>

def fieldset(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def fieldset(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def fieldset(options, **other_options) : Nil #

def fieldset(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def fieldset(&) : Nil #

def fieldset(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figcaption(content : Lucky::AllowedInTags | String) : Nil #

def figcaption(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;figcaption&gt;&lt;/figcaption&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
figcaption("Sample", {"class" => "cls-1 red"}, [:required]) #=> <figcaption class="cls-1 red" required>Sample</figcaption>

def figcaption(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figcaption(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figcaption(options, **other_options) : Nil #

def figcaption(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figcaption(&) : Nil #

def figcaption(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figure(content : Lucky::AllowedInTags | String) : Nil #

def figure(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;figure&gt;&lt;/figure&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
figure("Sample", {"class" => "cls-1 red"}, [:required]) #=> <figure class="cls-1 red" required>Sample</figure>

def figure(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figure(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def figure(options, **other_options) : Nil #

def figure(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def figure(&) : Nil #

def figure(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def footer(content : Lucky::AllowedInTags | String) : Nil #

def footer(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;footer&gt;&lt;/footer&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
footer("Sample", {"class" => "cls-1 red"}, [:required]) #=> <footer class="cls-1 red" required>Sample</footer>

def footer(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def footer(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def footer(options, **other_options) : Nil #

def footer(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def footer(&) : Nil #

def footer(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def form(content : Lucky::AllowedInTags | String) : Nil #

def form(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;form&gt;&lt;/form&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
form("Sample", {"class" => "cls-1 red"}, [:required]) #=> <form class="cls-1 red" required>Sample</form>

def form(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def form(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def form(options, **other_options) : Nil #

def form(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def form(&) : Nil #

def form(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h1(content : Lucky::AllowedInTags | String) : Nil #

def h1(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h1&gt;&lt;/h1&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h1("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h1 class="cls-1 red" required>Sample</h1>

def h1(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h1(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h1(options, **other_options) : Nil #

def h1(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h1(&) : Nil #

def h1(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h2(content : Lucky::AllowedInTags | String) : Nil #

def h2(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h2&gt;&lt;/h2&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h2("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h2 class="cls-1 red" required>Sample</h2>

def h2(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h2(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h2(options, **other_options) : Nil #

def h2(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h2(&) : Nil #

def h2(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h3(content : Lucky::AllowedInTags | String) : Nil #

def h3(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h3&gt;&lt;/h3&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h3("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h3 class="cls-1 red" required>Sample</h3>

def h3(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h3(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h3(options, **other_options) : Nil #

def h3(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h3(&) : Nil #

def h3(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h4(content : Lucky::AllowedInTags | String) : Nil #

def h4(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h4&gt;&lt;/h4&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h4("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h4 class="cls-1 red" required>Sample</h4>

def h4(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h4(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h4(options, **other_options) : Nil #

def h4(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h4(&) : Nil #

def h4(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h5(content : Lucky::AllowedInTags | String) : Nil #

def h5(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h5&gt;&lt;/h5&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h5("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h5 class="cls-1 red" required>Sample</h5>

def h5(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h5(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h5(options, **other_options) : Nil #

def h5(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h5(&) : Nil #

def h5(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h6(content : Lucky::AllowedInTags | String) : Nil #

def h6(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;h6&gt;&lt;/h6&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
h6("Sample", {"class" => "cls-1 red"}, [:required]) #=> <h6 class="cls-1 red" required>Sample</h6>

def h6(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h6(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def h6(options, **other_options) : Nil #

def h6(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def h6(&) : Nil #

def h6(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def head(content : Lucky::AllowedInTags | String) : Nil #

def head(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;head&gt;&lt;/head&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
head("Sample", {"class" => "cls-1 red"}, [:required]) #=> <head class="cls-1 red" required>Sample</head>

def head(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def head(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def head(options, **other_options) : Nil #

def head(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def head(&) : Nil #

def head(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def header(content : Lucky::AllowedInTags | String) : Nil #

def header(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;header&gt;&lt;/header&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
header("Sample", {"class" => "cls-1 red"}, [:required]) #=> <header class="cls-1 red" required>Sample</header>

def header(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def header(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def header(options, **other_options) : Nil #

def header(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def header(&) : Nil #

def header(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def hr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;hr&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
hr([:required], {"class" => "cls-1"}) #=> <hr class="cls-1" required>

[View source]
def hr : Nil #

Generates a &lt;hr&gt; tag.


[View source]
def hr(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def html(content : Lucky::AllowedInTags | String) : Nil #

def html(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;html&gt;&lt;/html&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
html("Sample", {"class" => "cls-1 red"}, [:required]) #=> <html class="cls-1 red" required>Sample</html>

def html(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def html(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def html(options, **other_options) : Nil #

def html(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def html(&) : Nil #

def html(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def i(content : Lucky::AllowedInTags | String) : Nil #

def i(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;i&gt;&lt;/i&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
i("Sample", {"class" => "cls-1 red"}, [:required]) #=> <i class="cls-1 red" required>Sample</i>

def i(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def i(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def i(options, **other_options) : Nil #

def i(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def i(&) : Nil #

def i(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def iframe(content : Lucky::AllowedInTags | String) : Nil #

def iframe(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;iframe&gt;&lt;/iframe&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
iframe("Sample", {"class" => "cls-1 red"}, [:required]) #=> <iframe class="cls-1 red" required>Sample</iframe>

def iframe(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def iframe(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def iframe(options, **other_options) : Nil #

def iframe(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def iframe(&) : Nil #

def iframe(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def img(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;img&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
img([:required], {"class" => "cls-1"}) #=> <img class="cls-1" required>

[View source]
def img : Nil #

Generates a &lt;img&gt; tag.


[View source]
def img(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def input(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;input&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
input([:required], {"class" => "cls-1"}) #=> <input class="cls-1" required>

[View source]
def input : Nil #

Generates a &lt;input&gt; tag.


[View source]
def input(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def ins(content : Lucky::AllowedInTags | String) : Nil #

def ins(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ins&gt;&lt;/ins&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ins("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ins class="cls-1 red" required>Sample</ins>

def ins(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ins(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ins(options, **other_options) : Nil #

def ins(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ins(&) : Nil #

def ins(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def kbd(content : Lucky::AllowedInTags | String) : Nil #

def kbd(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;kbd&gt;&lt;/kbd&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
kbd("Sample", {"class" => "cls-1 red"}, [:required]) #=> <kbd class="cls-1 red" required>Sample</kbd>

def kbd(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def kbd(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def kbd(options, **other_options) : Nil #

def kbd(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def kbd(&) : Nil #

def kbd(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def label(content : Lucky::AllowedInTags | String) : Nil #

def label(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;label&gt;&lt;/label&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
label("Sample", {"class" => "cls-1 red"}, [:required]) #=> <label class="cls-1 red" required>Sample</label>

def label(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def label(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def label(options, **other_options) : Nil #

def label(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def label(&) : Nil #

def label(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def legend(content : Lucky::AllowedInTags | String) : Nil #

def legend(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;legend&gt;&lt;/legend&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
legend("Sample", {"class" => "cls-1 red"}, [:required]) #=> <legend class="cls-1 red" required>Sample</legend>

def legend(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def legend(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def legend(options, **other_options) : Nil #

def legend(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def legend(&) : Nil #

def legend(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def li(content : Lucky::AllowedInTags | String) : Nil #

def li(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;li&gt;&lt;/li&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
li("Sample", {"class" => "cls-1 red"}, [:required]) #=> <li class="cls-1 red" required>Sample</li>

def li(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def li(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def li(options, **other_options) : Nil #

def li(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def li(&) : Nil #

def li(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def main(content : Lucky::AllowedInTags | String) : Nil #

def main(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;main&gt;&lt;/main&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
main("Sample", {"class" => "cls-1 red"}, [:required]) #=> <main class="cls-1 red" required>Sample</main>

def main(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def main(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def main(options, **other_options) : Nil #

def main(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def main(&) : Nil #

def main(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def map(content : Lucky::AllowedInTags | String) : Nil #

def map(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;map&gt;&lt;/map&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
map("Sample", {"class" => "cls-1 red"}, [:required]) #=> <map class="cls-1 red" required>Sample</map>

def map(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def map(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def map(options, **other_options) : Nil #

def map(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def map(&) : Nil #

def map(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def mark(content : Lucky::AllowedInTags | String) : Nil #

def mark(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;mark&gt;&lt;/mark&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
mark("Sample", {"class" => "cls-1 red"}, [:required]) #=> <mark class="cls-1 red" required>Sample</mark>

def mark(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def mark(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def mark(options, **other_options) : Nil #

def mark(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def mark(&) : Nil #

def mark(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def menuitem(content : Lucky::AllowedInTags | String) : Nil #

def menuitem(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;menuitem&gt;&lt;/menuitem&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
menuitem("Sample", {"class" => "cls-1 red"}, [:required]) #=> <menuitem class="cls-1 red" required>Sample</menuitem>

def menuitem(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def menuitem(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def menuitem(options, **other_options) : Nil #

def menuitem(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def menuitem(&) : Nil #

def menuitem(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def meta(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;meta&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
meta([:required], {"class" => "cls-1"}) #=> <meta class="cls-1" required>

[View source]
def meta : Nil #

Generates a &lt;meta&gt; tag.


[View source]
def meta(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def meter(content : Lucky::AllowedInTags | String) : Nil #

def meter(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;meter&gt;&lt;/meter&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
meter("Sample", {"class" => "cls-1 red"}, [:required]) #=> <meter class="cls-1 red" required>Sample</meter>

def meter(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def meter(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def meter(options, **other_options) : Nil #

def meter(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def meter(&) : Nil #

def meter(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def nav(content : Lucky::AllowedInTags | String) : Nil #

def nav(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;nav&gt;&lt;/nav&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
nav("Sample", {"class" => "cls-1 red"}, [:required]) #=> <nav class="cls-1 red" required>Sample</nav>

def nav(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def nav(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def nav(options, **other_options) : Nil #

def nav(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def nav(&) : Nil #

def nav(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def noscript(content : Lucky::AllowedInTags | String) : Nil #

def noscript(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;noscript&gt;&lt;/noscript&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
noscript("Sample", {"class" => "cls-1 red"}, [:required]) #=> <noscript class="cls-1 red" required>Sample</noscript>

def noscript(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def noscript(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def noscript(options, **other_options) : Nil #

def noscript(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def noscript(&) : Nil #

def noscript(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def object(content : Lucky::AllowedInTags | String) : Nil #

def object(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;object&gt;&lt;/object&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
object("Sample", {"class" => "cls-1 red"}, [:required]) #=> <object class="cls-1 red" required>Sample</object>

def object(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def object(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def object(options, **other_options) : Nil #

def object(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def object(&) : Nil #

def object(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ol(content : Lucky::AllowedInTags | String) : Nil #

def ol(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ol&gt;&lt;/ol&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ol("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ol class="cls-1 red" required>Sample</ol>

def ol(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ol(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ol(options, **other_options) : Nil #

def ol(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ol(&) : Nil #

def ol(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def optgroup(content : Lucky::AllowedInTags | String) : Nil #

def optgroup(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;optgroup&gt;&lt;/optgroup&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
optgroup("Sample", {"class" => "cls-1 red"}, [:required]) #=> <optgroup class="cls-1 red" required>Sample</optgroup>

def optgroup(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def optgroup(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def optgroup(options, **other_options) : Nil #

def optgroup(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def optgroup(&) : Nil #

def optgroup(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def option(content : Lucky::AllowedInTags | String) : Nil #

def option(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;option&gt;&lt;/option&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
option("Sample", {"class" => "cls-1 red"}, [:required]) #=> <option class="cls-1 red" required>Sample</option>

def option(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def option(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def option(options, **other_options) : Nil #

def option(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def option(&) : Nil #

def option(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def output(content : Lucky::AllowedInTags | String) : Nil #

def output(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;output&gt;&lt;/output&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
output("Sample", {"class" => "cls-1 red"}, [:required]) #=> <output class="cls-1 red" required>Sample</output>

def output(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def output(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def output(options, **other_options) : Nil #

def output(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def output(&) : Nil #

def output(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def para(content : Lucky::AllowedInTags | String) : Nil #

def para(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;para&gt;&lt;/para&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
para("Sample", {"class" => "cls-1 red"}, [:required]) #=> <para class="cls-1 red" required>Sample</para>

def para(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def para(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def para(options, **other_options) : Nil #

def para(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def para(&) : Nil #

def para(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def param(content : Lucky::AllowedInTags | String) : Nil #

def param(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;param&gt;&lt;/param&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
param("Sample", {"class" => "cls-1 red"}, [:required]) #=> <param class="cls-1 red" required>Sample</param>

def param(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def param(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def param(options, **other_options) : Nil #

def param(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def param(&) : Nil #

def param(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def picture(content : Lucky::AllowedInTags | String) : Nil #

def picture(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;picture&gt;&lt;/picture&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
picture("Sample", {"class" => "cls-1 red"}, [:required]) #=> <picture class="cls-1 red" required>Sample</picture>

def picture(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def picture(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def picture(options, **other_options) : Nil #

def picture(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def picture(&) : Nil #

def picture(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def pre(content : Lucky::AllowedInTags | String) : Nil #

def pre(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;pre&gt;&lt;/pre&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
pre("Sample", {"class" => "cls-1 red"}, [:required]) #=> <pre class="cls-1 red" required>Sample</pre>

def pre(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def pre(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def pre(options, **other_options) : Nil #

def pre(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def pre(&) : Nil #

def pre(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def progress(content : Lucky::AllowedInTags | String) : Nil #

def progress(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;progress&gt;&lt;/progress&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
progress("Sample", {"class" => "cls-1 red"}, [:required]) #=> <progress class="cls-1 red" required>Sample</progress>

def progress(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def progress(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def progress(options, **other_options) : Nil #

def progress(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def progress(&) : Nil #

def progress(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def q(content : Lucky::AllowedInTags | String) : Nil #

def q(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;q&gt;&lt;/q&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
q("Sample", {"class" => "cls-1 red"}, [:required]) #=> <q class="cls-1 red" required>Sample</q>

def q(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def q(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def q(options, **other_options) : Nil #

def q(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def q(&) : Nil #

def q(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rp(content : Lucky::AllowedInTags | String) : Nil #

def rp(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;rp&gt;&lt;/rp&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
rp("Sample", {"class" => "cls-1 red"}, [:required]) #=> <rp class="cls-1 red" required>Sample</rp>

def rp(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rp(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rp(options, **other_options) : Nil #

def rp(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rp(&) : Nil #

def rp(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rt(content : Lucky::AllowedInTags | String) : Nil #

def rt(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;rt&gt;&lt;/rt&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
rt("Sample", {"class" => "cls-1 red"}, [:required]) #=> <rt class="cls-1 red" required>Sample</rt>

def rt(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rt(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def rt(options, **other_options) : Nil #

def rt(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def rt(&) : Nil #

def rt(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ruby(content : Lucky::AllowedInTags | String) : Nil #

def ruby(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ruby&gt;&lt;/ruby&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ruby("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ruby class="cls-1 red" required>Sample</ruby>

def ruby(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ruby(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ruby(options, **other_options) : Nil #

def ruby(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ruby(&) : Nil #

def ruby(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def s(content : Lucky::AllowedInTags | String) : Nil #

def s(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;s&gt;&lt;/s&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
s("Sample", {"class" => "cls-1 red"}, [:required]) #=> <s class="cls-1 red" required>Sample</s>

def s(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def s(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def s(options, **other_options) : Nil #

def s(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def s(&) : Nil #

def s(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def samp(content : Lucky::AllowedInTags | String) : Nil #

def samp(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;samp&gt;&lt;/samp&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
samp("Sample", {"class" => "cls-1 red"}, [:required]) #=> <samp class="cls-1 red" required>Sample</samp>

def samp(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def samp(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def samp(options, **other_options) : Nil #

def samp(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def samp(&) : Nil #

def samp(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def script(content : Lucky::AllowedInTags | String) : Nil #

def script(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;script&gt;&lt;/script&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
script("Sample", {"class" => "cls-1 red"}, [:required]) #=> <script class="cls-1 red" required>Sample</script>

def script(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def script(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def script(options, **other_options) : Nil #

def script(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def script(&) : Nil #

def script(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def section(content : Lucky::AllowedInTags | String) : Nil #

def section(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;section&gt;&lt;/section&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
section("Sample", {"class" => "cls-1 red"}, [:required]) #=> <section class="cls-1 red" required>Sample</section>

def section(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def section(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def section(options, **other_options) : Nil #

def section(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def section(&) : Nil #

def section(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def select_tag(content : Lucky::AllowedInTags | String) : Nil #

def select_tag(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;select_tag&gt;&lt;/select_tag&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
select_tag("Sample", {"class" => "cls-1 red"}, [:required]) #=> <select_tag class="cls-1 red" required>Sample</select_tag>

def select_tag(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def select_tag(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def select_tag(options, **other_options) : Nil #

def select_tag(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def select_tag(&) : Nil #

def select_tag(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def slot(content : Lucky::AllowedInTags | String) : Nil #

def slot(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;slot&gt;&lt;/slot&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
slot("Sample", {"class" => "cls-1 red"}, [:required]) #=> <slot class="cls-1 red" required>Sample</slot>

def slot(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def slot(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def slot(options, **other_options) : Nil #

def slot(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def slot(&) : Nil #

def slot(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def small(content : Lucky::AllowedInTags | String) : Nil #

def small(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;small&gt;&lt;/small&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
small("Sample", {"class" => "cls-1 red"}, [:required]) #=> <small class="cls-1 red" required>Sample</small>

def small(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def small(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def small(options, **other_options) : Nil #

def small(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def small(&) : Nil #

def small(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def source(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options) : Nil #

Generates a &lt;source&gt; tag.

  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
source([:required], {"class" => "cls-1"}) #=> <source class="cls-1" required>

[View source]
def source : Nil #

Generates a &lt;source&gt; tag.


[View source]
def source(options = EMPTY_HTML_ATTRS, **other_options) : Nil #

[View source]
def span(content : Lucky::AllowedInTags | String) : Nil #

def span(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;span&gt;&lt;/span&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
span("Sample", {"class" => "cls-1 red"}, [:required]) #=> <span class="cls-1 red" required>Sample</span>

def span(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def span(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def span(options, **other_options) : Nil #

def span(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def span(&) : Nil #

def span(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def strong(content : Lucky::AllowedInTags | String) : Nil #

def strong(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;strong&gt;&lt;/strong&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
strong("Sample", {"class" => "cls-1 red"}, [:required]) #=> <strong class="cls-1 red" required>Sample</strong>

def strong(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def strong(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def strong(options, **other_options) : Nil #

def strong(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def strong(&) : Nil #

def strong(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def style(styles : String) : Nil #

Generates a &lt;style&gt;&lt;/style&gt; block for adding inline CSS

style("a { color: red; }") # => <style>a { color: red; }</style>

[View source]
def sub(content : Lucky::AllowedInTags | String) : Nil #

def sub(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;sub&gt;&lt;/sub&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
sub("Sample", {"class" => "cls-1 red"}, [:required]) #=> <sub class="cls-1 red" required>Sample</sub>

def sub(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sub(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sub(options, **other_options) : Nil #

def sub(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def sub(&) : Nil #

def sub(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def summary(content : Lucky::AllowedInTags | String) : Nil #

def summary(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;summary&gt;&lt;/summary&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
summary("Sample", {"class" => "cls-1 red"}, [:required]) #=> <summary class="cls-1 red" required>Sample</summary>

def summary(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def summary(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def summary(options, **other_options) : Nil #

def summary(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def summary(&) : Nil #

def summary(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def sup(content : Lucky::AllowedInTags | String) : Nil #

def sup(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;sup&gt;&lt;/sup&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
sup("Sample", {"class" => "cls-1 red"}, [:required]) #=> <sup class="cls-1 red" required>Sample</sup>

def sup(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sup(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def sup(options, **other_options) : Nil #

def sup(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def sup(&) : Nil #

def sup(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def table(content : Lucky::AllowedInTags | String) : Nil #

def table(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;table&gt;&lt;/table&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
table("Sample", {"class" => "cls-1 red"}, [:required]) #=> <table class="cls-1 red" required>Sample</table>

def table(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def table(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def table(options, **other_options) : Nil #

def table(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def table(&) : Nil #

def table(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tbody(content : Lucky::AllowedInTags | String) : Nil #

def tbody(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;tbody&gt;&lt;/tbody&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
tbody("Sample", {"class" => "cls-1 red"}, [:required]) #=> <tbody class="cls-1 red" required>Sample</tbody>

def tbody(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tbody(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tbody(options, **other_options) : Nil #

def tbody(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tbody(&) : Nil #

def tbody(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def td(content : Lucky::AllowedInTags | String) : Nil #

def td(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;td&gt;&lt;/td&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
td("Sample", {"class" => "cls-1 red"}, [:required]) #=> <td class="cls-1 red" required>Sample</td>

def td(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def td(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def td(options, **other_options) : Nil #

def td(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def td(&) : Nil #

def td(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def template(content : Lucky::AllowedInTags | String) : Nil #

def template(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;template&gt;&lt;/template&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
template("Sample", {"class" => "cls-1 red"}, [:required]) #=> <template class="cls-1 red" required>Sample</template>

def template(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def template(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def template(options, **other_options) : Nil #

def template(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def template(&) : Nil #

def template(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def text(content : String | Lucky::AllowedInTags) : Nil #

Outputs content and escapes it.

text("Hello") # => Hello
text("<div>") # => &lt;div&gt;

[View source]
def textarea(content : Lucky::AllowedInTags | String) : Nil #

def textarea(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;textarea&gt;&lt;/textarea&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
textarea("Sample", {"class" => "cls-1 red"}, [:required]) #=> <textarea class="cls-1 red" required>Sample</textarea>

def textarea(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def textarea(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def textarea(options, **other_options) : Nil #

def textarea(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def textarea(&) : Nil #

def textarea(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tfoot(content : Lucky::AllowedInTags | String) : Nil #

def tfoot(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;tfoot&gt;&lt;/tfoot&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
tfoot("Sample", {"class" => "cls-1 red"}, [:required]) #=> <tfoot class="cls-1 red" required>Sample</tfoot>

def tfoot(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tfoot(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tfoot(options, **other_options) : Nil #

def tfoot(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tfoot(&) : Nil #

def tfoot(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def th(content : Lucky::AllowedInTags | String) : Nil #

def th(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;th&gt;&lt;/th&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
th("Sample", {"class" => "cls-1 red"}, [:required]) #=> <th class="cls-1 red" required>Sample</th>

def th(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def th(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def th(options, **other_options) : Nil #

def th(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def th(&) : Nil #

def th(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def thead(content : Lucky::AllowedInTags | String) : Nil #

def thead(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;thead&gt;&lt;/thead&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
thead("Sample", {"class" => "cls-1 red"}, [:required]) #=> <thead class="cls-1 red" required>Sample</thead>

def thead(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def thead(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def thead(options, **other_options) : Nil #

def thead(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def thead(&) : Nil #

def thead(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def time(content : Lucky::AllowedInTags | String) : Nil #

def time(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;time&gt;&lt;/time&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
time("Sample", {"class" => "cls-1 red"}, [:required]) #=> <time class="cls-1 red" required>Sample</time>

def time(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def time(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def time(options, **other_options) : Nil #

def time(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def time(&) : Nil #

def time(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def title(content : Lucky::AllowedInTags | String) : Nil #

def title(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;title&gt;&lt;/title&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
title("Sample", {"class" => "cls-1 red"}, [:required]) #=> <title class="cls-1 red" required>Sample</title>

def title(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def title(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def title(options, **other_options) : Nil #

def title(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def title(&) : Nil #

def title(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tr(content : Lucky::AllowedInTags | String) : Nil #

def tr(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;tr&gt;&lt;/tr&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
tr("Sample", {"class" => "cls-1 red"}, [:required]) #=> <tr class="cls-1 red" required>Sample</tr>

def tr(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tr(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def tr(options, **other_options) : Nil #

def tr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def tr(&) : Nil #

def tr(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def track(content : Lucky::AllowedInTags | String) : Nil #

def track(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;track&gt;&lt;/track&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
track("Sample", {"class" => "cls-1 red"}, [:required]) #=> <track class="cls-1 red" required>Sample</track>

def track(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def track(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def track(options, **other_options) : Nil #

def track(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def track(&) : Nil #

def track(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def u(content : Lucky::AllowedInTags | String) : Nil #

def u(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;u&gt;&lt;/u&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
u("Sample", {"class" => "cls-1 red"}, [:required]) #=> <u class="cls-1 red" required>Sample</u>

def u(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def u(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def u(options, **other_options) : Nil #

def u(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def u(&) : Nil #

def u(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ul(content : Lucky::AllowedInTags | String) : Nil #

def ul(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;ul&gt;&lt;/ul&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
ul("Sample", {"class" => "cls-1 red"}, [:required]) #=> <ul class="cls-1 red" required>Sample</ul>

def ul(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ul(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def ul(options, **other_options) : Nil #

def ul(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def ul(&) : Nil #

def ul(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def video(content : Lucky::AllowedInTags | String) : Nil #

def video(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;video&gt;&lt;/video&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
video("Sample", {"class" => "cls-1 red"}, [:required]) #=> <video class="cls-1 red" required>Sample</video>

def video(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def video(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def video(options, **other_options) : Nil #

def video(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def video(&) : Nil #

def video(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def wbr(content : Lucky::AllowedInTags | String) : Nil #

def wbr(content : Lucky::AllowedInTags | String = "", options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

Generates a &lt;wbr&gt;&lt;/wbr&gt; tag.

  • The content argument is either a String, or any type that has included Lucky::AllowedInTags. This is the content that goes inside of the tag.
  • The options argument is a Hash(String, String) of any HTML attribute that has a key/value like class, id, type, etc...
  • The attrs argument is an Array(Symbol) for specifying Boolean Attributes such as required, disabled, autofocus, etc...
wbr("Sample", {"class" => "cls-1 red"}, [:required]) #=> <wbr class="cls-1 red" required>Sample</wbr>

def wbr(content : Nil, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def wbr(content : Time, options = EMPTY_HTML_ATTRS, attrs : Array(Symbol) = [] of Symbol, **other_options) : Nil #

def wbr(options, **other_options) : Nil #

def wbr(attrs : Array(Symbol), options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #

def wbr(&) : Nil #

def wbr(options = EMPTY_HTML_ATTRS, **other_options, &) : Nil #