reacl-c.dom — de.active-group/reacl-c 0.11.2

This namespace contains functions for all HTML and SVG tags, which all return corresponding dom items. Additionally it contains the function h, a generic function that creates dom items.

a clj/s

(a & children)

(a attrs & children)

Returns a dom element item corresponding to a a tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

abbr clj/s

(abbr & children)

(abbr attrs & children)

Returns a dom element item corresponding to a abbr tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

address clj/s

(address & children)

(address attrs & children)

Returns a dom element item corresponding to a address tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

animate clj/s

(animate & children)

(animate attrs & children)

Returns a dom element item corresponding to a animate tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

animateColor clj/s

(animateColor & children)

(animateColor attrs & children)

Returns a dom element item corresponding to a animateColor tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

animateMotion clj/s

(animateMotion & children)

(animateMotion attrs & children)

Returns a dom element item corresponding to a animateMotion tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

animateTransform clj/s

(animateTransform & children)

(animateTransform attrs & children)

Returns a dom element item corresponding to a animateTransform tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

area clj/s

(area & children)

(area attrs & children)

Returns a dom element item corresponding to a area tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

article clj/s

(article & children)

(article attrs & children)

Returns a dom element item corresponding to a article tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

aside clj/s

(aside & children)

(aside attrs & children)

Returns a dom element item corresponding to a aside tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

audio clj/s

(audio & children)

(audio attrs & children)

Returns a dom element item corresponding to a audio tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

b clj/s

(b & children)

(b attrs & children)

Returns a dom element item corresponding to a b tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

base clj/s

(base & children)

(base attrs & children)

Returns a dom element item corresponding to a base tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

bdi clj/s

(bdi & children)

(bdi attrs & children)

Returns a dom element item corresponding to a bdi tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

bdo clj/s

(bdo & children)

(bdo attrs & children)

Returns a dom element item corresponding to a bdo tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

big clj/s

(big & children)

(big attrs & children)

Returns a dom element item corresponding to a big tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

blockquote clj/s

(blockquote & children)

(blockquote attrs & children)

Returns a dom element item corresponding to a blockquote tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

body clj/s

(body & children)

(body attrs & children)

Returns a dom element item corresponding to a body tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

br clj/s

(br & children)

(br attrs & children)

Returns a dom element item corresponding to a br tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

button clj/s

(button & children)

(button attrs & children)

Returns a dom element item corresponding to a button tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

canvas clj/s

(canvas & children)

(canvas attrs & children)

Returns a dom element item corresponding to a canvas tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

caption clj/s

(caption & children)

(caption attrs & children)

Returns a dom element item corresponding to a caption tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

circle clj/s

(circle & children)

(circle attrs & children)

Returns a dom element item corresponding to a circle tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

cite clj/s

(cite & children)

(cite attrs & children)

Returns a dom element item corresponding to a cite tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

clipPath clj/s

(clipPath & children)

(clipPath attrs & children)

Returns a dom element item corresponding to a clipPath tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

code clj/s

(code & children)

(code attrs & children)

Returns a dom element item corresponding to a code tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

col clj/s

(col & children)

(col attrs & children)

Returns a dom element item corresponding to a col tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

colgroup clj/s

(colgroup & children)

(colgroup attrs & children)

Returns a dom element item corresponding to a colgroup tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

cursor clj/s

(cursor & children)

(cursor attrs & children)

Returns a dom element item corresponding to a cursor tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

data clj/s

(data & children)

(data attrs & children)

Returns a dom element item corresponding to a data tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

datalist clj/s

(datalist & children)

(datalist attrs & children)

Returns a dom element item corresponding to a datalist tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

dd clj/s

(dd & children)

(dd attrs & children)

Returns a dom element item corresponding to a dd tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

def-dom clj/s macro

(def-dom name base & [attrs])

Defines an alias for a dom function, for example:

  (def-dom page div)

The var page will be bound to function that is essentially identical to div, but additionally, the name of the var is attached to the returned items, which can be helpful in testing and debugging utilities (see reacl-c.core/named).

Also, some default attributes can be specified, for example:

  (def-dom page div
    {:style {:margin "10px")})

These attributes will be merged with attributes passed by the caller of page using merge-attributes.

defn-dom clj/s macro

(defn-dom name params & body)

Defines a function that works like the dom element functions in this namespace (e.g. div), in that the first argument is an optional attributes map, followed by arbitrarily many child items.

If the defined function is called without an attribute map, then {} will be passed implicitly as the first argument.

Additionally, all attributes starting with :on must be event handlers and are automatically bound to the state of the returned item, via reacl-c.core/with-bind. That means you can assign these event handlers to any item in the body, or use reacl-c.core/call, irrespective of the state that those items get.

Tip: Pass the attributes to the toplevel dom element that is returned, and use merge-attributes to add some default attributes in your function body.

defs clj/s

(defs & children)

(defs attrs & children)

Returns a dom element item corresponding to a defs tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

del clj/s

(del & children)

(del attrs & children)

Returns a dom element item corresponding to a del tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

desc clj/s

(desc & children)

(desc attrs & children)

Returns a dom element item corresponding to a desc tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

details clj/s

(details & children)

(details attrs & children)

Returns a dom element item corresponding to a details tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

dfn clj/s

(dfn & children)

(dfn attrs & children)

Returns a dom element item corresponding to a dfn tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

div clj/s

(div & children)

(div attrs & children)

Returns a dom element item corresponding to a div tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

dl clj/s

(dl & children)

(dl attrs & children)

Returns a dom element item corresponding to a dl tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

dom-attributes? clj/s

(dom-attributes? v)

Returns if v is a map, and not an item.

dt clj/s

(dt & children)

(dt attrs & children)

Returns a dom element item corresponding to a dt tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

element? clj/s

(element? v)

Returns if v is a dom element.

ellipse clj/s

(ellipse & children)

(ellipse attrs & children)

Returns a dom element item corresponding to a ellipse tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

em clj/s

(em & children)

(em attrs & children)

Returns a dom element item corresponding to a em tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

embed clj/s

(embed & children)

(embed attrs & children)

Returns a dom element item corresponding to a embed tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feBlend clj/s

(feBlend & children)

(feBlend attrs & children)

Returns a dom element item corresponding to a feBlend tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feColorMatrix clj/s

(feColorMatrix & children)

(feColorMatrix attrs & children)

Returns a dom element item corresponding to a feColorMatrix tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feComponentTransfer clj/s

(feComponentTransfer & children)

(feComponentTransfer attrs & children)

Returns a dom element item corresponding to a feComponentTransfer tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feComposite clj/s

(feComposite & children)

(feComposite attrs & children)

Returns a dom element item corresponding to a feComposite tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feConvolveMatrix clj/s

(feConvolveMatrix & children)

(feConvolveMatrix attrs & children)

Returns a dom element item corresponding to a feConvolveMatrix tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feDiffuseLighting clj/s

(feDiffuseLighting & children)

(feDiffuseLighting attrs & children)

Returns a dom element item corresponding to a feDiffuseLighting tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feDisplacementMap clj/s

(feDisplacementMap & children)

(feDisplacementMap attrs & children)

Returns a dom element item corresponding to a feDisplacementMap tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feDistantLight clj/s

(feDistantLight & children)

(feDistantLight attrs & children)

Returns a dom element item corresponding to a feDistantLight tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feFlood clj/s

(feFlood & children)

(feFlood attrs & children)

Returns a dom element item corresponding to a feFlood tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feFuncA clj/s

(feFuncA & children)

(feFuncA attrs & children)

Returns a dom element item corresponding to a feFuncA tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feFuncB clj/s

(feFuncB & children)

(feFuncB attrs & children)

Returns a dom element item corresponding to a feFuncB tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feFuncG clj/s

(feFuncG & children)

(feFuncG attrs & children)

Returns a dom element item corresponding to a feFuncG tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feFuncR clj/s

(feFuncR & children)

(feFuncR attrs & children)

Returns a dom element item corresponding to a feFuncR tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feGaussianBlur clj/s

(feGaussianBlur & children)

(feGaussianBlur attrs & children)

Returns a dom element item corresponding to a feGaussianBlur tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feImage clj/s

(feImage & children)

(feImage attrs & children)

Returns a dom element item corresponding to a feImage tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feMerge clj/s

(feMerge & children)

(feMerge attrs & children)

Returns a dom element item corresponding to a feMerge tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feMergeNode clj/s

(feMergeNode & children)

(feMergeNode attrs & children)

Returns a dom element item corresponding to a feMergeNode tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feMorphology clj/s

(feMorphology & children)

(feMorphology attrs & children)

Returns a dom element item corresponding to a feMorphology tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feOffset clj/s

(feOffset & children)

(feOffset attrs & children)

Returns a dom element item corresponding to a feOffset tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

fePointLight clj/s

(fePointLight & children)

(fePointLight attrs & children)

Returns a dom element item corresponding to a fePointLight tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feSpecularLighting clj/s

(feSpecularLighting & children)

(feSpecularLighting attrs & children)

Returns a dom element item corresponding to a feSpecularLighting tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feSpotLight clj/s

(feSpotLight & children)

(feSpotLight attrs & children)

Returns a dom element item corresponding to a feSpotLight tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feTile clj/s

(feTile & children)

(feTile attrs & children)

Returns a dom element item corresponding to a feTile tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

feTurbulence clj/s

(feTurbulence & children)

(feTurbulence attrs & children)

Returns a dom element item corresponding to a feTurbulence tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

fieldset clj/s

(fieldset & children)

(fieldset attrs & children)

Returns a dom element item corresponding to a fieldset tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

figcaption clj/s

(figcaption & children)

(figcaption attrs & children)

Returns a dom element item corresponding to a figcaption tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

figure clj/s

(figure & children)

(figure attrs & children)

Returns a dom element item corresponding to a figure tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

font clj/s

(font & children)

(font attrs & children)

Returns a dom element item corresponding to a font tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

footer clj/s

(footer & children)

(footer attrs & children)

Returns a dom element item corresponding to a footer tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

form clj/s

(form & children)

(form attrs & children)

Returns a dom element item corresponding to a form tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

g clj/s

(g & children)

(g attrs & children)

Returns a dom element item corresponding to a g tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

h clj/s

(h type & args)

Returns a DOM item of the specified type, like "div" for example. Arguments are the same as the specific DOM functions, like div.

h1 clj/s

(h1 & children)

(h1 attrs & children)

Returns a dom element item corresponding to a h1 tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

h2 clj/s

(h2 & children)

(h2 attrs & children)

Returns a dom element item corresponding to a h2 tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

h3 clj/s

(h3 & children)

(h3 attrs & children)

Returns a dom element item corresponding to a h3 tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

h4 clj/s

(h4 & children)

(h4 attrs & children)

Returns a dom element item corresponding to a h4 tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

h5 clj/s

(h5 & children)

(h5 attrs & children)

Returns a dom element item corresponding to a h5 tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

h6 clj/s

(h6 & children)

(h6 attrs & children)

Returns a dom element item corresponding to a h6 tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

head clj/s

(head & children)

(head attrs & children)

Returns a dom element item corresponding to a head tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

header clj/s

(header & children)

(header attrs & children)

Returns a dom element item corresponding to a header tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

hr clj/s

(hr & children)

(hr attrs & children)

Returns a dom element item corresponding to a hr tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

html clj/s

(html & children)

(html attrs & children)

Returns a dom element item corresponding to a html tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

i clj/s

(i & children)

(i attrs & children)

Returns a dom element item corresponding to a i tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

iframe clj/s

(iframe & children)

(iframe attrs & children)

Returns a dom element item corresponding to a iframe tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

image clj/s

(image & children)

(image attrs & children)

Returns a dom element item corresponding to a image tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

img clj/s

(img & children)

(img attrs & children)

Returns a dom element item corresponding to a img tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

input clj/s

(input & children)

(input attrs & children)

Returns a dom element item corresponding to a input tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

ins clj/s

(ins & children)

(ins attrs & children)

Returns a dom element item corresponding to a ins tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

kbd clj/s

(kbd & children)

(kbd attrs & children)

Returns a dom element item corresponding to a kbd tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

keygen clj/s

(keygen & children)

(keygen attrs & children)

Returns a dom element item corresponding to a keygen tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

label clj/s

(label & children)

(label attrs & children)

Returns a dom element item corresponding to a label tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

legend clj/s

(legend & children)

(legend attrs & children)

Returns a dom element item corresponding to a legend tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

li clj/s

(li & children)

(li attrs & children)

Returns a dom element item corresponding to a li tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

line clj/s

(line & children)

(line attrs & children)

Returns a dom element item corresponding to a line tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

linearGradient clj/s

(linearGradient & children)

(linearGradient attrs & children)

Returns a dom element item corresponding to a linearGradient tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

link clj/s

(link & children)

(link attrs & children)

Returns a dom element item corresponding to a link tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

main clj/s

(main & children)

(main attrs & children)

Returns a dom element item corresponding to a main tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

map clj/s

(map & children)

(map attrs & children)

Returns a dom element item corresponding to a map tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

mark clj/s

(mark & children)

(mark attrs & children)

Returns a dom element item corresponding to a mark tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

marker clj/s

(marker & children)

(marker attrs & children)

Returns a dom element item corresponding to a marker tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

mask clj/s

(mask & children)

(mask attrs & children)

Returns a dom element item corresponding to a mask tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

menu clj/s

(menu & children)

(menu attrs & children)

Returns a dom element item corresponding to a menu tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

menuitem clj/s

(menuitem & children)

(menuitem attrs & children)

Returns a dom element item corresponding to a menuitem tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

merge-attributes clj/s

(merge-attributes & attrs)

Merge two or more attribute maps into one. This handles merging multiple :style maps into one, and concatenates :class and :className strings.

meta clj/s

(meta & children)

(meta attrs & children)

Returns a dom element item corresponding to a meta tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

metadata clj/s

(metadata & children)

(metadata attrs & children)

Returns a dom element item corresponding to a metadata tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

meter clj/s

(meter & children)

(meter attrs & children)

Returns a dom element item corresponding to a meter tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

mpath clj/s

(mpath & children)

(mpath attrs & children)

Returns a dom element item corresponding to a mpath tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

nav clj/s

(nav & children)

(nav attrs & children)

Returns a dom element item corresponding to a nav tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

noscript clj/s

(noscript & children)

(noscript attrs & children)

Returns a dom element item corresponding to a noscript tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

object clj/s

(object & children)

(object attrs & children)

Returns a dom element item corresponding to a object tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

ol clj/s

(ol & children)

(ol attrs & children)

Returns a dom element item corresponding to a ol tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

optgroup clj/s

(optgroup & children)

(optgroup attrs & children)

Returns a dom element item corresponding to a optgroup tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

option clj/s

(option & children)

(option attrs & children)

Returns a dom element item corresponding to a option tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

output clj/s

(output & children)

(output attrs & children)

Returns a dom element item corresponding to a output tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

p clj/s

(p & children)

(p attrs & children)

Returns a dom element item corresponding to a p tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

param clj/s

(param & children)

(param attrs & children)

Returns a dom element item corresponding to a param tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

path clj/s

(path & children)

(path attrs & children)

Returns a dom element item corresponding to a path tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

pattern clj/s

(pattern & children)

(pattern attrs & children)

Returns a dom element item corresponding to a pattern tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

polygon clj/s

(polygon & children)

(polygon attrs & children)

Returns a dom element item corresponding to a polygon tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

polyline clj/s

(polyline & children)

(polyline attrs & children)

Returns a dom element item corresponding to a polyline tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

pre clj/s

(pre & children)

(pre attrs & children)

Returns a dom element item corresponding to a pre tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

progress clj/s

(progress & children)

(progress attrs & children)

Returns a dom element item corresponding to a progress tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

q clj/s

(q & children)

(q attrs & children)

Returns a dom element item corresponding to a q tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

radialGradient clj/s

(radialGradient & children)

(radialGradient attrs & children)

Returns a dom element item corresponding to a radialGradient tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

rect clj/s

(rect & children)

(rect attrs & children)

Returns a dom element item corresponding to a rect tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

rp clj/s

(rp & children)

(rp attrs & children)

Returns a dom element item corresponding to a rp tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

rt clj/s

(rt & children)

(rt attrs & children)

Returns a dom element item corresponding to a rt tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

ruby clj/s

(ruby & children)

(ruby attrs & children)

Returns a dom element item corresponding to a ruby tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

s clj/s

(s & children)

(s attrs & children)

Returns a dom element item corresponding to a s tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

samp clj/s

(samp & children)

(samp attrs & children)

Returns a dom element item corresponding to a samp tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

script clj/s

(script & children)

(script attrs & children)

Returns a dom element item corresponding to a script tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

section clj/s

(section & children)

(section attrs & children)

Returns a dom element item corresponding to a section tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

select clj/s

(select & children)

(select attrs & children)

Returns a dom element item corresponding to a select tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

set clj/s

(set & children)

(set attrs & children)

Returns a dom element item corresponding to a set tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

small clj/s

(small & children)

(small attrs & children)

Returns a dom element item corresponding to a small tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

source clj/s

(source & children)

(source attrs & children)

Returns a dom element item corresponding to a source tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

span clj/s

(span & children)

(span attrs & children)

Returns a dom element item corresponding to a span tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

stop clj/s

(stop & children)

(stop attrs & children)

Returns a dom element item corresponding to a stop tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

strong clj/s

(strong & children)

(strong attrs & children)

Returns a dom element item corresponding to a strong tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

style clj/s

(style & children)

(style attrs & children)

Returns a dom element item corresponding to a style tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

sub clj/s

(sub & children)

(sub attrs & children)

Returns a dom element item corresponding to a sub tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

summary clj/s

(summary & children)

(summary attrs & children)

Returns a dom element item corresponding to a summary tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

sup clj/s

(sup & children)

(sup attrs & children)

Returns a dom element item corresponding to a sup tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

svg clj/s

(svg & children)

(svg attrs & children)

Returns a dom element item corresponding to a svg tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

switch clj/s

(switch & children)

(switch attrs & children)

Returns a dom element item corresponding to a switch tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

symbol clj/s

(symbol & children)

(symbol attrs & children)

Returns a dom element item corresponding to a symbol tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

table clj/s

(table & children)

(table attrs & children)

Returns a dom element item corresponding to a table tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

tbody clj/s

(tbody & children)

(tbody attrs & children)

Returns a dom element item corresponding to a tbody tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

td clj/s

(td & children)

(td attrs & children)

Returns a dom element item corresponding to a td tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

text clj/s

(text & children)

(text attrs & children)

Returns a dom element item corresponding to a text tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

textarea clj/s

(textarea & children)

(textarea attrs & children)

Returns a dom element item corresponding to a textarea tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

textPath clj/s

(textPath & children)

(textPath attrs & children)

Returns a dom element item corresponding to a textPath tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

tfoot clj/s

(tfoot & children)

(tfoot attrs & children)

Returns a dom element item corresponding to a tfoot tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

th clj/s

(th & children)

(th attrs & children)

Returns a dom element item corresponding to a th tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

thead clj/s

(thead & children)

(thead attrs & children)

Returns a dom element item corresponding to a thead tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

time clj/s

(time & children)

(time attrs & children)

Returns a dom element item corresponding to a time tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

title clj/s

(title & children)

(title attrs & children)

Returns a dom element item corresponding to a title tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

tr clj/s

(tr & children)

(tr attrs & children)

Returns a dom element item corresponding to a tr tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

track clj/s

(track & children)

(track attrs & children)

Returns a dom element item corresponding to a track tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

tspan clj/s

(tspan & children)

(tspan attrs & children)

Returns a dom element item corresponding to a tspan tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

u clj/s

(u & children)

(u attrs & children)

Returns a dom element item corresponding to a u tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

ul clj/s

(ul & children)

(ul attrs & children)

Returns a dom element item corresponding to a ul tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

use clj/s

(use & children)

(use attrs & children)

Returns a dom element item corresponding to a use tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

var clj/s

(var & children)

(var attrs & children)

Returns a dom element item corresponding to a var tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

video clj/s

(video & children)

(video attrs & children)

Returns a dom element item corresponding to a video tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

view clj/s

(view & children)

(view attrs & children)

Returns a dom element item corresponding to a view tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.

wbr clj/s

(wbr & children)

(wbr attrs & children)

Returns a dom element item corresponding to a wbr tag. The attrs argument is an optional map of attributes. Any attribute starting with on, is expected to be a function taking the state and an event and return a reacl-c.core/return value. The remaining children arguments must be other items or strings.