autotags.go

package html

import "github.com/golazy/golazy/lazyview/nodes"

// A Creates a new a element
func A(options ...interface{}) nodes.Element {
	return nodes.NewElement("a", options...)
}

// Abbr Creates a new abbr element
func Abbr(options ...interface{}) nodes.Element {
	return nodes.NewElement("abbr", options...)
}

// Acronym Creates a new acronym element
func Acronym(options ...interface{}) nodes.Element {
	return nodes.NewElement("acronym", options...)
}

// Address Creates a new address element
func Address(options ...interface{}) nodes.Element {
	return nodes.NewElement("address", options...)
}

// Applet Creates a new applet element
func Applet(options ...interface{}) nodes.Element {
	return nodes.NewElement("applet", options...)
}

// Area Creates a new area element
func Area(options ...interface{}) nodes.Element {
	return nodes.NewElement("area", options...)
}

// Article Creates a new article element
func Article(options ...interface{}) nodes.Element {
	return nodes.NewElement("article", options...)
}

// Aside Creates a new aside element
func Aside(options ...interface{}) nodes.Element {
	return nodes.NewElement("aside", options...)
}

// Audio Creates a new audio element
func Audio(options ...interface{}) nodes.Element {
	return nodes.NewElement("audio", options...)
}

// B Creates a new b element
func B(options ...interface{}) nodes.Element {
	return nodes.NewElement("b", options...)
}

// Base Creates a new base element
func Base(options ...interface{}) nodes.Element {
	return nodes.NewElement("base", options...)
}

// Basefont Creates a new basefont element
func Basefont(options ...interface{}) nodes.Element {
	return nodes.NewElement("basefont", options...)
}

// Bb Creates a new bb element
func Bb(options ...interface{}) nodes.Element {
	return nodes.NewElement("bb", options...)
}

// Bdi Creates a new bdi element
func Bdi(options ...interface{}) nodes.Element {
	return nodes.NewElement("bdi", options...)
}

// Bdo Creates a new bdo element
func Bdo(options ...interface{}) nodes.Element {
	return nodes.NewElement("bdo", options...)
}

// Bgsound Creates a new bgsound element
func Bgsound(options ...interface{}) nodes.Element {
	return nodes.NewElement("bgsound", options...)
}

// Big Creates a new big element
func Big(options ...interface{}) nodes.Element {
	return nodes.NewElement("big", options...)
}

// Blink Creates a new blink element
func Blink(options ...interface{}) nodes.Element {
	return nodes.NewElement("blink", options...)
}

// Blockquote Creates a new blockquote element
func Blockquote(options ...interface{}) nodes.Element {
	return nodes.NewElement("blockquote", options...)
}

// Body Creates a new body element
func Body(options ...interface{}) nodes.Element {
	return nodes.NewElement("body", options...)
}

// Br Creates a new br element
func Br(options ...interface{}) nodes.Element {
	return nodes.NewElement("br", options...)
}

// Button Creates a new button element
func Button(options ...interface{}) nodes.Element {
	return nodes.NewElement("button", options...)
}

// Canvas Creates a new canvas element
func Canvas(options ...interface{}) nodes.Element {
	return nodes.NewElement("canvas", options...)
}

// Caption Creates a new caption element
func Caption(options ...interface{}) nodes.Element {
	return nodes.NewElement("caption", options...)
}

// Center Creates a new center element
func Center(options ...interface{}) nodes.Element {
	return nodes.NewElement("center", options...)
}

// Cite Creates a new cite element
func Cite(options ...interface{}) nodes.Element {
	return nodes.NewElement("cite", options...)
}

// Code Creates a new code element
func Code(options ...interface{}) nodes.Element {
	return nodes.NewElement("code", options...)
}

// Col Creates a new col element
func Col(options ...interface{}) nodes.Element {
	return nodes.NewElement("col", options...)
}

// Colgroup Creates a new colgroup element
func Colgroup(options ...interface{}) nodes.Element {
	return nodes.NewElement("colgroup", options...)
}

// Command Creates a new command element
func Command(options ...interface{}) nodes.Element {
	return nodes.NewElement("command", options...)
}

// Content Creates a new content element
func Content(options ...interface{}) nodes.Element {
	return nodes.NewElement("content", options...)
}

// Data Creates a new data element
func Data(options ...interface{}) nodes.Element {
	return nodes.NewElement("data", options...)
}

// Datagrid Creates a new datagrid element
func Datagrid(options ...interface{}) nodes.Element {
	return nodes.NewElement("datagrid", options...)
}

// Datalist Creates a new datalist element
func Datalist(options ...interface{}) nodes.Element {
	return nodes.NewElement("datalist", options...)
}

// Dd Creates a new dd element
func Dd(options ...interface{}) nodes.Element {
	return nodes.NewElement("dd", options...)
}

// Del Creates a new del element
func Del(options ...interface{}) nodes.Element {
	return nodes.NewElement("del", options...)
}

// Details Creates a new details element
func Details(options ...interface{}) nodes.Element {
	return nodes.NewElement("details", options...)
}

// Dfn Creates a new dfn element
func Dfn(options ...interface{}) nodes.Element {
	return nodes.NewElement("dfn", options...)
}

// Dialog Creates a new dialog element
func Dialog(options ...interface{}) nodes.Element {
	return nodes.NewElement("dialog", options...)
}

// Dir Creates a new dir element
func Dir(options ...interface{}) nodes.Element {
	return nodes.NewElement("dir", options...)
}

// Div Creates a new div element
func Div(options ...interface{}) nodes.Element {
	return nodes.NewElement("div", options...)
}

// Dl Creates a new dl element
func Dl(options ...interface{}) nodes.Element {
	return nodes.NewElement("dl", options...)
}

// Dt Creates a new dt element
func Dt(options ...interface{}) nodes.Element {
	return nodes.NewElement("dt", options...)
}

// Em Creates a new em element
func Em(options ...interface{}) nodes.Element {
	return nodes.NewElement("em", options...)
}

// Embed Creates a new embed element
func Embed(options ...interface{}) nodes.Element {
	return nodes.NewElement("embed", options...)
}

// Eventsource Creates a new eventsource element
func Eventsource(options ...interface{}) nodes.Element {
	return nodes.NewElement("eventsource", options...)
}

// Fieldset Creates a new fieldset element
func Fieldset(options ...interface{}) nodes.Element {
	return nodes.NewElement("fieldset", options...)
}

// Figcaption Creates a new figcaption element
func Figcaption(options ...interface{}) nodes.Element {
	return nodes.NewElement("figcaption", options...)
}

// Figure Creates a new figure element
func Figure(options ...interface{}) nodes.Element {
	return nodes.NewElement("figure", options...)
}

// Font Creates a new font element
func Font(options ...interface{}) nodes.Element {
	return nodes.NewElement("font", options...)
}

// Footer Creates a new footer element
func Footer(options ...interface{}) nodes.Element {
	return nodes.NewElement("footer", options...)
}

// Form Creates a new form element
func Form(options ...interface{}) nodes.Element {
	return nodes.NewElement("form", options...)
}

// Frame Creates a new frame element
func Frame(options ...interface{}) nodes.Element {
	return nodes.NewElement("frame", options...)
}

// Frameset Creates a new frameset element
func Frameset(options ...interface{}) nodes.Element {
	return nodes.NewElement("frameset", options...)
}

// H1 Creates a new h1 element
func H1(options ...interface{}) nodes.Element {
	return nodes.NewElement("h1", options...)
}

// Head Creates a new head element
func Head(options ...interface{}) nodes.Element {
	return nodes.NewElement("head", options...)
}

// Header Creates a new header element
func Header(options ...interface{}) nodes.Element {
	return nodes.NewElement("header", options...)
}

// Hgroup Creates a new hgroup element
func Hgroup(options ...interface{}) nodes.Element {
	return nodes.NewElement("hgroup", options...)
}

// Hr Creates a new hr element
func Hr(options ...interface{}) nodes.Element {
	return nodes.NewElement("hr", options...)
}

// Html Creates a new html element
func Html(options ...interface{}) nodes.Element {
	return nodes.NewElement("html", options...)
}

// I Creates a new i element
func I(options ...interface{}) nodes.Element {
	return nodes.NewElement("i", options...)
}

// Iframe Creates a new iframe element
func Iframe(options ...interface{}) nodes.Element {
	return nodes.NewElement("iframe", options...)
}

// Image Creates a new image element
func Image(options ...interface{}) nodes.Element {
	return nodes.NewElement("image", options...)
}

// Img Creates a new img element
func Img(options ...interface{}) nodes.Element {
	return nodes.NewElement("img", options...)
}

// Input Creates a new input element
func Input(options ...interface{}) nodes.Element {
	return nodes.NewElement("input", options...)
}

// Ins Creates a new ins element
func Ins(options ...interface{}) nodes.Element {
	return nodes.NewElement("ins", options...)
}

// Isindex Creates a new isindex element
func Isindex(options ...interface{}) nodes.Element {
	return nodes.NewElement("isindex", options...)
}

// Kbd Creates a new kbd element
func Kbd(options ...interface{}) nodes.Element {
	return nodes.NewElement("kbd", options...)
}

// Keygen Creates a new keygen element
func Keygen(options ...interface{}) nodes.Element {
	return nodes.NewElement("keygen", options...)
}

// Label Creates a new label element
func Label(options ...interface{}) nodes.Element {
	return nodes.NewElement("label", options...)
}

// Legend Creates a new legend element
func Legend(options ...interface{}) nodes.Element {
	return nodes.NewElement("legend", options...)
}

// Li Creates a new li element
func Li(options ...interface{}) nodes.Element {
	return nodes.NewElement("li", options...)
}

// Link Creates a new link element
func Link(options ...interface{}) nodes.Element {
	return nodes.NewElement("link", options...)
}

// Main Creates a new main element
func Main(options ...interface{}) nodes.Element {
	return nodes.NewElement("main", options...)
}

// Map Creates a new map element
func Map(options ...interface{}) nodes.Element {
	return nodes.NewElement("map", options...)
}

// Mark Creates a new mark element
func Mark(options ...interface{}) nodes.Element {
	return nodes.NewElement("mark", options...)
}

// Marquee Creates a new marquee element
func Marquee(options ...interface{}) nodes.Element {
	return nodes.NewElement("marquee", options...)
}

// Menu Creates a new menu element
func Menu(options ...interface{}) nodes.Element {
	return nodes.NewElement("menu", options...)
}

// Menuitem Creates a new menuitem element
func Menuitem(options ...interface{}) nodes.Element {
	return nodes.NewElement("menuitem", options...)
}

// Meta Creates a new meta element
func Meta(options ...interface{}) nodes.Element {
	return nodes.NewElement("meta", options...)
}

// Meter Creates a new meter element
func Meter(options ...interface{}) nodes.Element {
	return nodes.NewElement("meter", options...)
}

// Nav Creates a new nav element
func Nav(options ...interface{}) nodes.Element {
	return nodes.NewElement("nav", options...)
}

// Nobr Creates a new nobr element
func Nobr(options ...interface{}) nodes.Element {
	return nodes.NewElement("nobr", options...)
}

// Noembed Creates a new noembed element
func Noembed(options ...interface{}) nodes.Element {
	return nodes.NewElement("noembed", options...)
}

// Noframes Creates a new noframes element
func Noframes(options ...interface{}) nodes.Element {
	return nodes.NewElement("noframes", options...)
}

// Noscript Creates a new noscript element
func Noscript(options ...interface{}) nodes.Element {
	return nodes.NewElement("noscript", options...)
}

// Object Creates a new object element
func Object(options ...interface{}) nodes.Element {
	return nodes.NewElement("object", options...)
}

// Ol Creates a new ol element
func Ol(options ...interface{}) nodes.Element {
	return nodes.NewElement("ol", options...)
}

// Optgroup Creates a new optgroup element
func Optgroup(options ...interface{}) nodes.Element {
	return nodes.NewElement("optgroup", options...)
}

// Option Creates a new option element
func Option(options ...interface{}) nodes.Element {
	return nodes.NewElement("option", options...)
}

// Output Creates a new output element
func Output(options ...interface{}) nodes.Element {
	return nodes.NewElement("output", options...)
}

// P Creates a new p element
func P(options ...interface{}) nodes.Element {
	return nodes.NewElement("p", options...)
}

// Param Creates a new param element
func Param(options ...interface{}) nodes.Element {
	return nodes.NewElement("param", options...)
}

// Picture Creates a new picture element
func Picture(options ...interface{}) nodes.Element {
	return nodes.NewElement("picture", options...)
}

// Plaintext Creates a new plaintext element
func Plaintext(options ...interface{}) nodes.Element {
	return nodes.NewElement("plaintext", options...)
}

// Portal Creates a new portal element
func Portal(options ...interface{}) nodes.Element {
	return nodes.NewElement("portal", options...)
}

// Pre Creates a new pre element
func Pre(options ...interface{}) nodes.Element {
	return nodes.NewElement("pre", options...)
}

// Progress Creates a new progress element
func Progress(options ...interface{}) nodes.Element {
	return nodes.NewElement("progress", options...)
}

// Q Creates a new q element
func Q(options ...interface{}) nodes.Element {
	return nodes.NewElement("q", options...)
}

// Rb Creates a new rb element
func Rb(options ...interface{}) nodes.Element {
	return nodes.NewElement("rb", options...)
}

// Rp Creates a new rp element
func Rp(options ...interface{}) nodes.Element {
	return nodes.NewElement("rp", options...)
}

// Rt Creates a new rt element
func Rt(options ...interface{}) nodes.Element {
	return nodes.NewElement("rt", options...)
}

// Rtc Creates a new rtc element
func Rtc(options ...interface{}) nodes.Element {
	return nodes.NewElement("rtc", options...)
}

// Ruby Creates a new ruby element
func Ruby(options ...interface{}) nodes.Element {
	return nodes.NewElement("ruby", options...)
}

// S Creates a new s element
func S(options ...interface{}) nodes.Element {
	return nodes.NewElement("s", options...)
}

// Samp Creates a new samp element
func Samp(options ...interface{}) nodes.Element {
	return nodes.NewElement("samp", options...)
}

// Script Creates a new script element
func Script(options ...interface{}) nodes.Element {
	return nodes.NewElement("script", options...)
}

// Section Creates a new section element
func Section(options ...interface{}) nodes.Element {
	return nodes.NewElement("section", options...)
}

// Select Creates a new select element
func Select(options ...interface{}) nodes.Element {
	return nodes.NewElement("select", options...)
}

// Shadow Creates a new shadow element
func Shadow(options ...interface{}) nodes.Element {
	return nodes.NewElement("shadow", options...)
}

// Slot Creates a new slot element
func Slot(options ...interface{}) nodes.Element {
	return nodes.NewElement("slot", options...)
}

// Small Creates a new small element
func Small(options ...interface{}) nodes.Element {
	return nodes.NewElement("small", options...)
}

// Source Creates a new source element
func Source(options ...interface{}) nodes.Element {
	return nodes.NewElement("source", options...)
}

// Spacer Creates a new spacer element
func Spacer(options ...interface{}) nodes.Element {
	return nodes.NewElement("spacer", options...)
}

// Span Creates a new span element
func Span(options ...interface{}) nodes.Element {
	return nodes.NewElement("span", options...)
}

// Strike Creates a new strike element
func Strike(options ...interface{}) nodes.Element {
	return nodes.NewElement("strike", options...)
}

// Strong Creates a new strong element
func Strong(options ...interface{}) nodes.Element {
	return nodes.NewElement("strong", options...)
}

// Style Creates a new style element
func Style(options ...interface{}) nodes.Element {
	return nodes.NewElement("style", options...)
}

// Sub Creates a new sub element
func Sub(options ...interface{}) nodes.Element {
	return nodes.NewElement("sub", options...)
}

// Summary Creates a new summary element
func Summary(options ...interface{}) nodes.Element {
	return nodes.NewElement("summary", options...)
}

// Sup Creates a new sup element
func Sup(options ...interface{}) nodes.Element {
	return nodes.NewElement("sup", options...)
}

// Table Creates a new table element
func Table(options ...interface{}) nodes.Element {
	return nodes.NewElement("table", options...)
}

// Tbody Creates a new tbody element
func Tbody(options ...interface{}) nodes.Element {
	return nodes.NewElement("tbody", options...)
}

// Td Creates a new td element
func Td(options ...interface{}) nodes.Element {
	return nodes.NewElement("td", options...)
}

// Template Creates a new template element
func Template(options ...interface{}) nodes.Element {
	return nodes.NewElement("template", options...)
}

// Textarea Creates a new textarea element
func Textarea(options ...interface{}) nodes.Element {
	return nodes.NewElement("textarea", options...)
}

// Tfoot Creates a new tfoot element
func Tfoot(options ...interface{}) nodes.Element {
	return nodes.NewElement("tfoot", options...)
}

// Th Creates a new th element
func Th(options ...interface{}) nodes.Element {
	return nodes.NewElement("th", options...)
}

// Thead Creates a new thead element
func Thead(options ...interface{}) nodes.Element {
	return nodes.NewElement("thead", options...)
}

// Time Creates a new time element
func Time(options ...interface{}) nodes.Element {
	return nodes.NewElement("time", options...)
}

// Title Creates a new title element
func Title(options ...interface{}) nodes.Element {
	return nodes.NewElement("title", options...)
}

// Tr Creates a new tr element
func Tr(options ...interface{}) nodes.Element {
	return nodes.NewElement("tr", options...)
}

// Track Creates a new track element
func Track(options ...interface{}) nodes.Element {
	return nodes.NewElement("track", options...)
}

// Tt Creates a new tt element
func Tt(options ...interface{}) nodes.Element {
	return nodes.NewElement("tt", options...)
}

// U Creates a new u element
func U(options ...interface{}) nodes.Element {
	return nodes.NewElement("u", options...)
}

// Ul Creates a new ul element
func Ul(options ...interface{}) nodes.Element {
	return nodes.NewElement("ul", options...)
}

// Var Creates a new var element
func Var(options ...interface{}) nodes.Element {
	return nodes.NewElement("var", options...)
}

// Video Creates a new video element
func Video(options ...interface{}) nodes.Element {
	return nodes.NewElement("video", options...)
}

// Wbr Creates a new wbr element
func Wbr(options ...interface{}) nodes.Element {
	return nodes.NewElement("wbr", options...)
}

// Wbra Creates a new wbra element
func Wbra(options ...interface{}) nodes.Element {
	return nodes.NewElement("wbra", options...)
}

// Xmp Creates a new xmp element
func Xmp(options ...interface{}) nodes.Element {
	return nodes.NewElement("xmp", options...)
}