com.fulcrologic.fulcro.dom-server — com.fulcrologic/fulcro 3.6.0-RC4

Support for rendering DOM from CLJ. Must be separate to enable same-named macros in CLJS for performance.

Usage: Create your UI in CLJC files, and require with conditional reader tags:

(ns app.ui (:require #?(:clj [com.fulcrologic.fulcro.dom-server :as dom] :cljs [com.fulcrologic.fulcro.dom :as dom])))

*css-mode* clj

a clj

(a & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (a "hello") (a nil "hello")

These two are made equivalent at compile time (a {:onClick f} "hello") (a #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (a :#the-id.klass.other-klass "hello") (a :#the-id.klass.other-klass {:onClick f} "hello")

abbr clj

(abbr & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (abbr "hello") (abbr nil "hello")

These two are made equivalent at compile time (abbr {:onClick f} "hello") (abbr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (abbr :#the-id.klass.other-klass "hello") (abbr :#the-id.klass.other-klass {:onClick f} "hello")

address clj

(address & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (address "hello") (address nil "hello")

These two are made equivalent at compile time (address {:onClick f} "hello") (address #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (address :#the-id.klass.other-klass "hello") (address :#the-id.klass.other-klass {:onClick f} "hello")

adler32 clj

(adler32 sb)

altGlyph clj

(altGlyph & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (altGlyph "hello") (altGlyph nil "hello")

These two are made equivalent at compile time (altGlyph {:onClick f} "hello") (altGlyph #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (altGlyph :#the-id.klass.other-klass "hello") (altGlyph :#the-id.klass.other-klass {:onClick f} "hello")

altGlyphDef clj

(altGlyphDef & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (altGlyphDef "hello") (altGlyphDef nil "hello")

These two are made equivalent at compile time (altGlyphDef {:onClick f} "hello") (altGlyphDef #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (altGlyphDef :#the-id.klass.other-klass "hello") (altGlyphDef :#the-id.klass.other-klass {:onClick f} "hello")

altGlyphItem clj

(altGlyphItem & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (altGlyphItem "hello") (altGlyphItem nil "hello")

These two are made equivalent at compile time (altGlyphItem {:onClick f} "hello") (altGlyphItem #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (altGlyphItem :#the-id.klass.other-klass "hello") (altGlyphItem :#the-id.klass.other-klass {:onClick f} "hello")

animate clj

(animate & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (animate "hello") (animate nil "hello")

These two are made equivalent at compile time (animate {:onClick f} "hello") (animate #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (animate :#the-id.klass.other-klass "hello") (animate :#the-id.klass.other-klass {:onClick f} "hello")

animateColor clj

(animateColor & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (animateColor "hello") (animateColor nil "hello")

These two are made equivalent at compile time (animateColor {:onClick f} "hello") (animateColor #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (animateColor :#the-id.klass.other-klass "hello") (animateColor :#the-id.klass.other-klass {:onClick f} "hello")

animateMotion clj

(animateMotion & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (animateMotion "hello") (animateMotion nil "hello")

These two are made equivalent at compile time (animateMotion {:onClick f} "hello") (animateMotion #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (animateMotion :#the-id.klass.other-klass "hello") (animateMotion :#the-id.klass.other-klass {:onClick f} "hello")

animateTransform clj

(animateTransform & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (animateTransform "hello") (animateTransform nil "hello")

These two are made equivalent at compile time (animateTransform {:onClick f} "hello") (animateTransform #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (animateTransform :#the-id.klass.other-klass "hello") (animateTransform :#the-id.klass.other-klass {:onClick f} "hello")

append! clj

(append! sb s0)

(append! sb s0 s1)

(append! sb s0 s1 s2)

(append! sb s0 s1 s2 s3)

(append! sb s0 s1 s2 s3 s4)

(append! sb s0 s1 s2 s3 s4 & rest)

area clj

(area & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (area "hello") (area nil "hello")

These two are made equivalent at compile time (area {:onClick f} "hello") (area #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (area :#the-id.klass.other-klass "hello") (area :#the-id.klass.other-klass {:onClick f} "hello")

article clj

(article & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (article "hello") (article nil "hello")

These two are made equivalent at compile time (article {:onClick f} "hello") (article #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (article :#the-id.klass.other-klass "hello") (article :#the-id.klass.other-klass {:onClick f} "hello")

aside clj

(aside & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (aside "hello") (aside nil "hello")

These two are made equivalent at compile time (aside {:onClick f} "hello") (aside #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (aside :#the-id.klass.other-klass "hello") (aside :#the-id.klass.other-klass {:onClick f} "hello")

assign-react-checksum clj

(assign-react-checksum sb)

audio clj

(audio & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (audio "hello") (audio nil "hello")

These two are made equivalent at compile time (audio {:onClick f} "hello") (audio #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (audio :#the-id.klass.other-klass "hello") (audio :#the-id.klass.other-klass {:onClick f} "hello")

b clj

(b & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (b "hello") (b nil "hello")

These two are made equivalent at compile time (b {:onClick f} "hello") (b #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (b :#the-id.klass.other-klass "hello") (b :#the-id.klass.other-klass {:onClick f} "hello")

base clj

(base & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (base "hello") (base nil "hello")

These two are made equivalent at compile time (base {:onClick f} "hello") (base #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (base :#the-id.klass.other-klass "hello") (base :#the-id.klass.other-klass {:onClick f} "hello")

bdi clj

(bdi & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (bdi "hello") (bdi nil "hello")

These two are made equivalent at compile time (bdi {:onClick f} "hello") (bdi #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (bdi :#the-id.klass.other-klass "hello") (bdi :#the-id.klass.other-klass {:onClick f} "hello")

bdo clj

(bdo & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (bdo "hello") (bdo nil "hello")

These two are made equivalent at compile time (bdo {:onClick f} "hello") (bdo #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (bdo :#the-id.klass.other-klass "hello") (bdo :#the-id.klass.other-klass {:onClick f} "hello")

big clj

(big & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (big "hello") (big nil "hello")

These two are made equivalent at compile time (big {:onClick f} "hello") (big #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (big :#the-id.klass.other-klass "hello") (big :#the-id.klass.other-klass {:onClick f} "hello")

blockquote clj

(blockquote & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (blockquote "hello") (blockquote nil "hello")

These two are made equivalent at compile time (blockquote {:onClick f} "hello") (blockquote #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (blockquote :#the-id.klass.other-klass "hello") (blockquote :#the-id.klass.other-klass {:onClick f} "hello")

body clj

(body & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (body "hello") (body nil "hello")

These two are made equivalent at compile time (body {:onClick f} "hello") (body #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (body :#the-id.klass.other-klass "hello") (body :#the-id.klass.other-klass {:onClick f} "hello")

br clj

(br & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (br "hello") (br nil "hello")

These two are made equivalent at compile time (br {:onClick f} "hello") (br #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (br :#the-id.klass.other-klass "hello") (br :#the-id.klass.other-klass {:onClick f} "hello")

button clj

(button & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (button "hello") (button nil "hello")

These two are made equivalent at compile time (button {:onClick f} "hello") (button #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (button :#the-id.klass.other-klass "hello") (button :#the-id.klass.other-klass {:onClick f} "hello")

camel->colon-between clj

camel->kebab-case clj

camel->other-case clj

(camel->other-case sep)

canvas clj

(canvas & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (canvas "hello") (canvas nil "hello")

These two are made equivalent at compile time (canvas {:onClick f} "hello") (canvas #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (canvas :#the-id.klass.other-klass "hello") (canvas :#the-id.klass.other-klass {:onClick f} "hello")

caption clj

(caption & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (caption "hello") (caption nil "hello")

These two are made equivalent at compile time (caption {:onClick f} "hello") (caption #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (caption :#the-id.klass.other-klass "hello") (caption :#the-id.klass.other-klass {:onClick f} "hello")

circle clj

(circle & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (circle "hello") (circle nil "hello")

These two are made equivalent at compile time (circle {:onClick f} "hello") (circle #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (circle :#the-id.klass.other-klass "hello") (circle :#the-id.klass.other-klass {:onClick f} "hello")

cite clj

(cite & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (cite "hello") (cite nil "hello")

These two are made equivalent at compile time (cite {:onClick f} "hello") (cite #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (cite :#the-id.klass.other-klass "hello") (cite :#the-id.klass.other-klass {:onClick f} "hello")

clipPath clj

(clipPath & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (clipPath "hello") (clipPath nil "hello")

These two are made equivalent at compile time (clipPath {:onClick f} "hello") (clipPath #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (clipPath :#the-id.klass.other-klass "hello") (clipPath :#the-id.klass.other-klass {:onClick f} "hello")

code clj

(code & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (code "hello") (code nil "hello")

These two are made equivalent at compile time (code {:onClick f} "hello") (code #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (code :#the-id.klass.other-klass "hello") (code :#the-id.klass.other-klass {:onClick f} "hello")

coerce-attr-key clj

(coerce-attr-key k)

col clj

(col & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (col "hello") (col nil "hello")

These two are made equivalent at compile time (col {:onClick f} "hello") (col #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (col :#the-id.klass.other-klass "hello") (col :#the-id.klass.other-klass {:onClick f} "hello")

colgroup clj

(colgroup & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (colgroup "hello") (colgroup nil "hello")

These two are made equivalent at compile time (colgroup {:onClick f} "hello") (colgroup #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (colgroup :#the-id.klass.other-klass "hello") (colgroup :#the-id.klass.other-klass {:onClick f} "hello")

colon-between-attrs clj

color-profile clj

(color-profile & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (color-profile "hello") (color-profile nil "hello")

These two are made equivalent at compile time (color-profile {:onClick f} "hello") (color-profile #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (color-profile :#the-id.klass.other-klass "hello") (color-profile :#the-id.klass.other-klass {:onClick f} "hello")

container-tag? clj

(container-tag? tag content)

Returns true if the tag has content or is not a void tag. In non-HTML modes, all contentless tags are assumed to be void tags.

create-element clj

(create-element tag)

(create-element tag opts & children)

Create a DOM element for which there exists no corresponding function. Useful to create DOM elements not included in React.DOM. Equivalent to calling js/React.createElement

cursor clj

(cursor & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (cursor "hello") (cursor nil "hello")

These two are made equivalent at compile time (cursor {:onClick f} "hello") (cursor #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (cursor :#the-id.klass.other-klass "hello") (cursor :#the-id.klass.other-klass {:onClick f} "hello")

data clj

(data & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (data "hello") (data nil "hello")

These two are made equivalent at compile time (data {:onClick f} "hello") (data #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (data :#the-id.klass.other-klass "hello") (data :#the-id.klass.other-klass {:onClick f} "hello")

datalist clj

(datalist & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (datalist "hello") (datalist nil "hello")

These two are made equivalent at compile time (datalist {:onClick f} "hello") (datalist #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (datalist :#the-id.klass.other-klass "hello") (datalist :#the-id.klass.other-klass {:onClick f} "hello")

dd clj

(dd & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dd "hello") (dd nil "hello")

These two are made equivalent at compile time (dd {:onClick f} "hello") (dd #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dd :#the-id.klass.other-klass "hello") (dd :#the-id.klass.other-klass {:onClick f} "hello")

defs clj

(defs & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (defs "hello") (defs nil "hello")

These two are made equivalent at compile time (defs {:onClick f} "hello") (defs #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (defs :#the-id.klass.other-klass "hello") (defs :#the-id.klass.other-klass {:onClick f} "hello")

del clj

(del & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (del "hello") (del nil "hello")

These two are made equivalent at compile time (del {:onClick f} "hello") (del #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (del :#the-id.klass.other-klass "hello") (del :#the-id.klass.other-klass {:onClick f} "hello")

desc clj

(desc & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (desc "hello") (desc nil "hello")

These two are made equivalent at compile time (desc {:onClick f} "hello") (desc #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (desc :#the-id.klass.other-klass "hello") (desc :#the-id.klass.other-klass {:onClick f} "hello")

details clj

(details & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (details "hello") (details nil "hello")

These two are made equivalent at compile time (details {:onClick f} "hello") (details #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (details :#the-id.klass.other-klass "hello") (details :#the-id.klass.other-klass {:onClick f} "hello")

dfn clj

(dfn & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dfn "hello") (dfn nil "hello")

These two are made equivalent at compile time (dfn {:onClick f} "hello") (dfn #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dfn :#the-id.klass.other-klass "hello") (dfn :#the-id.klass.other-klass {:onClick f} "hello")

dialog clj

(dialog & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dialog "hello") (dialog nil "hello")

These two are made equivalent at compile time (dialog {:onClick f} "hello") (dialog #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dialog :#the-id.klass.other-klass "hello") (dialog :#the-id.klass.other-klass {:onClick f} "hello")

discard clj

(discard & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (discard "hello") (discard nil "hello")

These two are made equivalent at compile time (discard {:onClick f} "hello") (discard #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (discard :#the-id.klass.other-klass "hello") (discard :#the-id.klass.other-klass {:onClick f} "hello")

div clj

(div & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (div "hello") (div nil "hello")

These two are made equivalent at compile time (div {:onClick f} "hello") (div #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (div :#the-id.klass.other-klass "hello") (div :#the-id.klass.other-klass {:onClick f} "hello")

dl clj

(dl & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dl "hello") (dl nil "hello")

These two are made equivalent at compile time (dl {:onClick f} "hello") (dl #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dl :#the-id.klass.other-klass "hello") (dl :#the-id.klass.other-klass {:onClick f} "hello")

dt clj

(dt & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (dt "hello") (dt nil "hello")

These two are made equivalent at compile time (dt {:onClick f} "hello") (dt #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (dt :#the-id.klass.other-klass "hello") (dt :#the-id.klass.other-klass {:onClick f} "hello")

element clj

(element {:keys [tag attrs react-key children] :as elem})

Creates a dom node.

element? clj

(element? x)

Returns true if the given arg is a server-side react element.

ellipse clj

(ellipse & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ellipse "hello") (ellipse nil "hello")

These two are made equivalent at compile time (ellipse {:onClick f} "hello") (ellipse #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ellipse :#the-id.klass.other-klass "hello") (ellipse :#the-id.klass.other-klass {:onClick f} "hello")

em clj

(em & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (em "hello") (em nil "hello")

These two are made equivalent at compile time (em {:onClick f} "hello") (em #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (em :#the-id.klass.other-klass "hello") (em :#the-id.klass.other-klass {:onClick f} "hello")

embed clj

(embed & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (embed "hello") (embed nil "hello")

These two are made equivalent at compile time (embed {:onClick f} "hello") (embed #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (embed :#the-id.klass.other-klass "hello") (embed :#the-id.klass.other-klass {:onClick f} "hello")

escape-html clj

(escape-html s)

feBlend clj

(feBlend & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feBlend "hello") (feBlend nil "hello")

These two are made equivalent at compile time (feBlend {:onClick f} "hello") (feBlend #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feBlend :#the-id.klass.other-klass "hello") (feBlend :#the-id.klass.other-klass {:onClick f} "hello")

feColorMatrix clj

(feColorMatrix & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feColorMatrix "hello") (feColorMatrix nil "hello")

These two are made equivalent at compile time (feColorMatrix {:onClick f} "hello") (feColorMatrix #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feColorMatrix :#the-id.klass.other-klass "hello") (feColorMatrix :#the-id.klass.other-klass {:onClick f} "hello")

feComponentTransfer clj

(feComponentTransfer & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feComponentTransfer "hello") (feComponentTransfer nil "hello")

These two are made equivalent at compile time (feComponentTransfer {:onClick f} "hello") (feComponentTransfer #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feComponentTransfer :#the-id.klass.other-klass "hello") (feComponentTransfer :#the-id.klass.other-klass {:onClick f} "hello")

feComposite clj

(feComposite & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feComposite "hello") (feComposite nil "hello")

These two are made equivalent at compile time (feComposite {:onClick f} "hello") (feComposite #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feComposite :#the-id.klass.other-klass "hello") (feComposite :#the-id.klass.other-klass {:onClick f} "hello")

feConvolveMatrix clj

(feConvolveMatrix & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feConvolveMatrix "hello") (feConvolveMatrix nil "hello")

These two are made equivalent at compile time (feConvolveMatrix {:onClick f} "hello") (feConvolveMatrix #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feConvolveMatrix :#the-id.klass.other-klass "hello") (feConvolveMatrix :#the-id.klass.other-klass {:onClick f} "hello")

feDiffuseLighting clj

(feDiffuseLighting & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feDiffuseLighting "hello") (feDiffuseLighting nil "hello")

These two are made equivalent at compile time (feDiffuseLighting {:onClick f} "hello") (feDiffuseLighting #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feDiffuseLighting :#the-id.klass.other-klass "hello") (feDiffuseLighting :#the-id.klass.other-klass {:onClick f} "hello")

feDisplacementMap clj

(feDisplacementMap & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feDisplacementMap "hello") (feDisplacementMap nil "hello")

These two are made equivalent at compile time (feDisplacementMap {:onClick f} "hello") (feDisplacementMap #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feDisplacementMap :#the-id.klass.other-klass "hello") (feDisplacementMap :#the-id.klass.other-klass {:onClick f} "hello")

feDistantLight clj

(feDistantLight & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feDistantLight "hello") (feDistantLight nil "hello")

These two are made equivalent at compile time (feDistantLight {:onClick f} "hello") (feDistantLight #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feDistantLight :#the-id.klass.other-klass "hello") (feDistantLight :#the-id.klass.other-klass {:onClick f} "hello")

feDropShadow clj

(feDropShadow & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feDropShadow "hello") (feDropShadow nil "hello")

These two are made equivalent at compile time (feDropShadow {:onClick f} "hello") (feDropShadow #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feDropShadow :#the-id.klass.other-klass "hello") (feDropShadow :#the-id.klass.other-klass {:onClick f} "hello")

feFlood clj

(feFlood & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feFlood "hello") (feFlood nil "hello")

These two are made equivalent at compile time (feFlood {:onClick f} "hello") (feFlood #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feFlood :#the-id.klass.other-klass "hello") (feFlood :#the-id.klass.other-klass {:onClick f} "hello")

feFuncA clj

(feFuncA & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feFuncA "hello") (feFuncA nil "hello")

These two are made equivalent at compile time (feFuncA {:onClick f} "hello") (feFuncA #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feFuncA :#the-id.klass.other-klass "hello") (feFuncA :#the-id.klass.other-klass {:onClick f} "hello")

feFuncB clj

(feFuncB & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feFuncB "hello") (feFuncB nil "hello")

These two are made equivalent at compile time (feFuncB {:onClick f} "hello") (feFuncB #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feFuncB :#the-id.klass.other-klass "hello") (feFuncB :#the-id.klass.other-klass {:onClick f} "hello")

feFuncG clj

(feFuncG & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feFuncG "hello") (feFuncG nil "hello")

These two are made equivalent at compile time (feFuncG {:onClick f} "hello") (feFuncG #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feFuncG :#the-id.klass.other-klass "hello") (feFuncG :#the-id.klass.other-klass {:onClick f} "hello")

feFuncR clj

(feFuncR & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feFuncR "hello") (feFuncR nil "hello")

These two are made equivalent at compile time (feFuncR {:onClick f} "hello") (feFuncR #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feFuncR :#the-id.klass.other-klass "hello") (feFuncR :#the-id.klass.other-klass {:onClick f} "hello")

feGaussianBlur clj

(feGaussianBlur & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feGaussianBlur "hello") (feGaussianBlur nil "hello")

These two are made equivalent at compile time (feGaussianBlur {:onClick f} "hello") (feGaussianBlur #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feGaussianBlur :#the-id.klass.other-klass "hello") (feGaussianBlur :#the-id.klass.other-klass {:onClick f} "hello")

feImage clj

(feImage & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feImage "hello") (feImage nil "hello")

These two are made equivalent at compile time (feImage {:onClick f} "hello") (feImage #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feImage :#the-id.klass.other-klass "hello") (feImage :#the-id.klass.other-klass {:onClick f} "hello")

feMerge clj

(feMerge & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feMerge "hello") (feMerge nil "hello")

These two are made equivalent at compile time (feMerge {:onClick f} "hello") (feMerge #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feMerge :#the-id.klass.other-klass "hello") (feMerge :#the-id.klass.other-klass {:onClick f} "hello")

feMergeNode clj

(feMergeNode & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feMergeNode "hello") (feMergeNode nil "hello")

These two are made equivalent at compile time (feMergeNode {:onClick f} "hello") (feMergeNode #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feMergeNode :#the-id.klass.other-klass "hello") (feMergeNode :#the-id.klass.other-klass {:onClick f} "hello")

feMorphology clj

(feMorphology & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feMorphology "hello") (feMorphology nil "hello")

These two are made equivalent at compile time (feMorphology {:onClick f} "hello") (feMorphology #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feMorphology :#the-id.klass.other-klass "hello") (feMorphology :#the-id.klass.other-klass {:onClick f} "hello")

feOffset clj

(feOffset & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feOffset "hello") (feOffset nil "hello")

These two are made equivalent at compile time (feOffset {:onClick f} "hello") (feOffset #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feOffset :#the-id.klass.other-klass "hello") (feOffset :#the-id.klass.other-klass {:onClick f} "hello")

fePointLight clj

(fePointLight & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (fePointLight "hello") (fePointLight nil "hello")

These two are made equivalent at compile time (fePointLight {:onClick f} "hello") (fePointLight #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (fePointLight :#the-id.klass.other-klass "hello") (fePointLight :#the-id.klass.other-klass {:onClick f} "hello")

feSpecularLighting clj

(feSpecularLighting & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feSpecularLighting "hello") (feSpecularLighting nil "hello")

These two are made equivalent at compile time (feSpecularLighting {:onClick f} "hello") (feSpecularLighting #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feSpecularLighting :#the-id.klass.other-klass "hello") (feSpecularLighting :#the-id.klass.other-klass {:onClick f} "hello")

feSpotLight clj

(feSpotLight & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feSpotLight "hello") (feSpotLight nil "hello")

These two are made equivalent at compile time (feSpotLight {:onClick f} "hello") (feSpotLight #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feSpotLight :#the-id.klass.other-klass "hello") (feSpotLight :#the-id.klass.other-klass {:onClick f} "hello")

feTile clj

(feTile & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feTile "hello") (feTile nil "hello")

These two are made equivalent at compile time (feTile {:onClick f} "hello") (feTile #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feTile :#the-id.klass.other-klass "hello") (feTile :#the-id.klass.other-klass {:onClick f} "hello")

feTurbulence clj

(feTurbulence & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (feTurbulence "hello") (feTurbulence nil "hello")

These two are made equivalent at compile time (feTurbulence {:onClick f} "hello") (feTurbulence #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (feTurbulence :#the-id.klass.other-klass "hello") (feTurbulence :#the-id.klass.other-klass {:onClick f} "hello")

fieldset clj

(fieldset & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (fieldset "hello") (fieldset nil "hello")

These two are made equivalent at compile time (fieldset {:onClick f} "hello") (fieldset #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (fieldset :#the-id.klass.other-klass "hello") (fieldset :#the-id.klass.other-klass {:onClick f} "hello")

figcaption clj

(figcaption & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (figcaption "hello") (figcaption nil "hello")

These two are made equivalent at compile time (figcaption {:onClick f} "hello") (figcaption #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (figcaption :#the-id.klass.other-klass "hello") (figcaption :#the-id.klass.other-klass {:onClick f} "hello")

figure clj

(figure & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (figure "hello") (figure nil "hello")

These two are made equivalent at compile time (figure {:onClick f} "hello") (figure #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (figure :#the-id.klass.other-klass "hello") (figure :#the-id.klass.other-klass {:onClick f} "hello")

filter clj

(filter & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (filter "hello") (filter nil "hello")

These two are made equivalent at compile time (filter {:onClick f} "hello") (filter #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (filter :#the-id.klass.other-klass "hello") (filter :#the-id.klass.other-klass {:onClick f} "hello")

font clj

(font & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (font "hello") (font nil "hello")

These two are made equivalent at compile time (font {:onClick f} "hello") (font #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (font :#the-id.klass.other-klass "hello") (font :#the-id.klass.other-klass {:onClick f} "hello")

font-face clj

(font-face & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (font-face "hello") (font-face nil "hello")

These two are made equivalent at compile time (font-face {:onClick f} "hello") (font-face #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (font-face :#the-id.klass.other-klass "hello") (font-face :#the-id.klass.other-klass {:onClick f} "hello")

font-face-format clj

(font-face-format & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (font-face-format "hello") (font-face-format nil "hello")

These two are made equivalent at compile time (font-face-format {:onClick f} "hello") (font-face-format #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (font-face-format :#the-id.klass.other-klass "hello") (font-face-format :#the-id.klass.other-klass {:onClick f} "hello")

font-face-name clj

(font-face-name & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (font-face-name "hello") (font-face-name nil "hello")

These two are made equivalent at compile time (font-face-name {:onClick f} "hello") (font-face-name #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (font-face-name :#the-id.klass.other-klass "hello") (font-face-name :#the-id.klass.other-klass {:onClick f} "hello")

font-face-src clj

(font-face-src & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (font-face-src "hello") (font-face-src nil "hello")

These two are made equivalent at compile time (font-face-src {:onClick f} "hello") (font-face-src #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (font-face-src :#the-id.klass.other-klass "hello") (font-face-src :#the-id.klass.other-klass {:onClick f} "hello")

font-face-uri clj

(font-face-uri & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (font-face-uri "hello") (font-face-uri nil "hello")

These two are made equivalent at compile time (font-face-uri {:onClick f} "hello") (font-face-uri #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (font-face-uri :#the-id.klass.other-klass "hello") (font-face-uri :#the-id.klass.other-klass {:onClick f} "hello")

footer clj

(footer & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (footer "hello") (footer nil "hello")

These two are made equivalent at compile time (footer {:onClick f} "hello") (footer #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (footer :#the-id.klass.other-klass "hello") (footer :#the-id.klass.other-klass {:onClick f} "hello")

foreignObject clj

(foreignObject & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (foreignObject "hello") (foreignObject nil "hello")

These two are made equivalent at compile time (foreignObject {:onClick f} "hello") (foreignObject #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (foreignObject :#the-id.klass.other-klass "hello") (foreignObject :#the-id.klass.other-klass {:onClick f} "hello")

form clj

(form & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (form "hello") (form nil "hello")

These two are made equivalent at compile time (form {:onClick f} "hello") (form #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (form :#the-id.klass.other-klass "hello") (form :#the-id.klass.other-klass {:onClick f} "hello")

g clj

(g & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (g "hello") (g nil "hello")

These two are made equivalent at compile time (g {:onClick f} "hello") (g #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (g :#the-id.klass.other-klass "hello") (g :#the-id.klass.other-klass {:onClick f} "hello")

gen-all-tags clj macro

(gen-all-tags)

gen-tag-fn clj

(gen-tag-fn tag)

glyph clj

(glyph & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (glyph "hello") (glyph nil "hello")

These two are made equivalent at compile time (glyph {:onClick f} "hello") (glyph #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (glyph :#the-id.klass.other-klass "hello") (glyph :#the-id.klass.other-klass {:onClick f} "hello")

glyphRef clj

(glyphRef & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (glyphRef "hello") (glyphRef nil "hello")

These two are made equivalent at compile time (glyphRef {:onClick f} "hello") (glyphRef #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (glyphRef :#the-id.klass.other-klass "hello") (glyphRef :#the-id.klass.other-klass {:onClick f} "hello")

h1 clj

(h1 & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h1 "hello") (h1 nil "hello")

These two are made equivalent at compile time (h1 {:onClick f} "hello") (h1 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h1 :#the-id.klass.other-klass "hello") (h1 :#the-id.klass.other-klass {:onClick f} "hello")

h2 clj

(h2 & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h2 "hello") (h2 nil "hello")

These two are made equivalent at compile time (h2 {:onClick f} "hello") (h2 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h2 :#the-id.klass.other-klass "hello") (h2 :#the-id.klass.other-klass {:onClick f} "hello")

h3 clj

(h3 & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h3 "hello") (h3 nil "hello")

These two are made equivalent at compile time (h3 {:onClick f} "hello") (h3 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h3 :#the-id.klass.other-klass "hello") (h3 :#the-id.klass.other-klass {:onClick f} "hello")

h4 clj

(h4 & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h4 "hello") (h4 nil "hello")

These two are made equivalent at compile time (h4 {:onClick f} "hello") (h4 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h4 :#the-id.klass.other-klass "hello") (h4 :#the-id.klass.other-klass {:onClick f} "hello")

h5 clj

(h5 & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h5 "hello") (h5 nil "hello")

These two are made equivalent at compile time (h5 {:onClick f} "hello") (h5 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h5 :#the-id.klass.other-klass "hello") (h5 :#the-id.klass.other-klass {:onClick f} "hello")

h6 clj

(h6 & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (h6 "hello") (h6 nil "hello")

These two are made equivalent at compile time (h6 {:onClick f} "hello") (h6 #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (h6 :#the-id.klass.other-klass "hello") (h6 :#the-id.klass.other-klass {:onClick f} "hello")

hatch clj

(hatch & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (hatch "hello") (hatch nil "hello")

These two are made equivalent at compile time (hatch {:onClick f} "hello") (hatch #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (hatch :#the-id.klass.other-klass "hello") (hatch :#the-id.klass.other-klass {:onClick f} "hello")

hatchpath clj

(hatchpath & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (hatchpath "hello") (hatchpath nil "hello")

These two are made equivalent at compile time (hatchpath {:onClick f} "hello") (hatchpath #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (hatchpath :#the-id.klass.other-klass "hello") (hatchpath :#the-id.klass.other-klass {:onClick f} "hello")

head clj

(head & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (head "hello") (head nil "hello")

These two are made equivalent at compile time (head {:onClick f} "hello") (head #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (head :#the-id.klass.other-klass "hello") (head :#the-id.klass.other-klass {:onClick f} "hello")

header clj

(header & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (header "hello") (header nil "hello")

These two are made equivalent at compile time (header {:onClick f} "hello") (header #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (header :#the-id.klass.other-klass "hello") (header :#the-id.klass.other-klass {:onClick f} "hello")

hkern clj

(hkern & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (hkern "hello") (hkern nil "hello")

These two are made equivalent at compile time (hkern {:onClick f} "hello") (hkern #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (hkern :#the-id.klass.other-klass "hello") (hkern :#the-id.klass.other-klass {:onClick f} "hello")

hr clj

(hr & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (hr "hello") (hr nil "hello")

These two are made equivalent at compile time (hr {:onClick f} "hello") (hr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (hr :#the-id.klass.other-klass "hello") (hr :#the-id.klass.other-klass {:onClick f} "hello")

html clj

(html & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (html "hello") (html nil "hello")

These two are made equivalent at compile time (html {:onClick f} "hello") (html #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (html :#the-id.klass.other-klass "hello") (html :#the-id.klass.other-klass {:onClick f} "hello")

i clj

(i & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (i "hello") (i nil "hello")

These two are made equivalent at compile time (i {:onClick f} "hello") (i #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (i :#the-id.klass.other-klass "hello") (i :#the-id.klass.other-klass {:onClick f} "hello")

iframe clj

(iframe & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (iframe "hello") (iframe nil "hello")

These two are made equivalent at compile time (iframe {:onClick f} "hello") (iframe #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (iframe :#the-id.klass.other-klass "hello") (iframe :#the-id.klass.other-klass {:onClick f} "hello")

image clj

(image & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (image "hello") (image nil "hello")

These two are made equivalent at compile time (image {:onClick f} "hello") (image #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (image :#the-id.klass.other-klass "hello") (image :#the-id.klass.other-klass {:onClick f} "hello")

img clj

(img & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (img "hello") (img nil "hello")

These two are made equivalent at compile time (img {:onClick f} "hello") (img #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (img :#the-id.klass.other-klass "hello") (img :#the-id.klass.other-klass {:onClick f} "hello")

input clj

(input & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (input "hello") (input nil "hello")

These two are made equivalent at compile time (input {:onClick f} "hello") (input #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (input :#the-id.klass.other-klass "hello") (input :#the-id.klass.other-klass {:onClick f} "hello")

ins clj

(ins & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ins "hello") (ins nil "hello")

These two are made equivalent at compile time (ins {:onClick f} "hello") (ins #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ins :#the-id.klass.other-klass "hello") (ins :#the-id.klass.other-klass {:onClick f} "hello")

kbd clj

(kbd & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (kbd "hello") (kbd nil "hello")

These two are made equivalent at compile time (kbd {:onClick f} "hello") (kbd #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (kbd :#the-id.klass.other-klass "hello") (kbd :#the-id.klass.other-klass {:onClick f} "hello")

kebab-case-attrs clj

key-escape-lookup clj

keygen clj

(keygen & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (keygen "hello") (keygen nil "hello")

These two are made equivalent at compile time (keygen {:onClick f} "hello") (keygen #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (keygen :#the-id.klass.other-klass "hello") (keygen :#the-id.klass.other-klass {:onClick f} "hello")

label clj

(label & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (label "hello") (label nil "hello")

These two are made equivalent at compile time (label {:onClick f} "hello") (label #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (label :#the-id.klass.other-klass "hello") (label :#the-id.klass.other-klass {:onClick f} "hello")

legend clj

(legend & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (legend "hello") (legend nil "hello")

These two are made equivalent at compile time (legend {:onClick f} "hello") (legend #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (legend :#the-id.klass.other-klass "hello") (legend :#the-id.klass.other-klass {:onClick f} "hello")

li clj

(li & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (li "hello") (li nil "hello")

These two are made equivalent at compile time (li {:onClick f} "hello") (li #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (li :#the-id.klass.other-klass "hello") (li :#the-id.klass.other-klass {:onClick f} "hello")

line clj

(line & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (line "hello") (line nil "hello")

These two are made equivalent at compile time (line {:onClick f} "hello") (line #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (line :#the-id.klass.other-klass "hello") (line :#the-id.klass.other-klass {:onClick f} "hello")

linearGradient clj

(linearGradient & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (linearGradient "hello") (linearGradient nil "hello")

These two are made equivalent at compile time (linearGradient {:onClick f} "hello") (linearGradient #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (linearGradient :#the-id.klass.other-klass "hello") (linearGradient :#the-id.klass.other-klass {:onClick f} "hello")

link clj

(link & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (link "hello") (link nil "hello")

These two are made equivalent at compile time (link {:onClick f} "hello") (link #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (link :#the-id.klass.other-klass "hello") (link :#the-id.klass.other-klass {:onClick f} "hello")

lower-case-attrs clj

main clj

(main & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (main "hello") (main nil "hello")

These two are made equivalent at compile time (main {:onClick f} "hello") (main #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (main :#the-id.klass.other-klass "hello") (main :#the-id.klass.other-klass {:onClick f} "hello")

map clj

(map & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (map "hello") (map nil "hello")

These two are made equivalent at compile time (map {:onClick f} "hello") (map #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (map :#the-id.klass.other-klass "hello") (map :#the-id.klass.other-klass {:onClick f} "hello")

mark clj

(mark & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (mark "hello") (mark nil "hello")

These two are made equivalent at compile time (mark {:onClick f} "hello") (mark #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (mark :#the-id.klass.other-klass "hello") (mark :#the-id.klass.other-klass {:onClick f} "hello")

marker clj

(marker & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (marker "hello") (marker nil "hello")

These two are made equivalent at compile time (marker {:onClick f} "hello") (marker #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (marker :#the-id.klass.other-klass "hello") (marker :#the-id.klass.other-klass {:onClick f} "hello")

mask clj

(mask & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (mask "hello") (mask nil "hello")

These two are made equivalent at compile time (mask {:onClick f} "hello") (mask #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (mask :#the-id.klass.other-klass "hello") (mask :#the-id.klass.other-klass {:onClick f} "hello")

menu clj

(menu & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (menu "hello") (menu nil "hello")

These two are made equivalent at compile time (menu {:onClick f} "hello") (menu #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (menu :#the-id.klass.other-klass "hello") (menu :#the-id.klass.other-klass {:onClick f} "hello")

menuitem clj

(menuitem & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (menuitem "hello") (menuitem nil "hello")

These two are made equivalent at compile time (menuitem {:onClick f} "hello") (menuitem #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (menuitem :#the-id.klass.other-klass "hello") (menuitem :#the-id.klass.other-klass {:onClick f} "hello")

mesh clj

(mesh & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (mesh "hello") (mesh nil "hello")

These two are made equivalent at compile time (mesh {:onClick f} "hello") (mesh #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (mesh :#the-id.klass.other-klass "hello") (mesh :#the-id.klass.other-klass {:onClick f} "hello")

meshgradient clj

(meshgradient & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meshgradient "hello") (meshgradient nil "hello")

These two are made equivalent at compile time (meshgradient {:onClick f} "hello") (meshgradient #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meshgradient :#the-id.klass.other-klass "hello") (meshgradient :#the-id.klass.other-klass {:onClick f} "hello")

meshpatch clj

(meshpatch & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meshpatch "hello") (meshpatch nil "hello")

These two are made equivalent at compile time (meshpatch {:onClick f} "hello") (meshpatch #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meshpatch :#the-id.klass.other-klass "hello") (meshpatch :#the-id.klass.other-klass {:onClick f} "hello")

meshrow clj

(meshrow & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meshrow "hello") (meshrow nil "hello")

These two are made equivalent at compile time (meshrow {:onClick f} "hello") (meshrow #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meshrow :#the-id.klass.other-klass "hello") (meshrow :#the-id.klass.other-klass {:onClick f} "hello")

meta clj

(meta & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meta "hello") (meta nil "hello")

These two are made equivalent at compile time (meta {:onClick f} "hello") (meta #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meta :#the-id.klass.other-klass "hello") (meta :#the-id.klass.other-klass {:onClick f} "hello")

metadata clj

(metadata & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (metadata "hello") (metadata nil "hello")

These two are made equivalent at compile time (metadata {:onClick f} "hello") (metadata #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (metadata :#the-id.klass.other-klass "hello") (metadata :#the-id.klass.other-klass {:onClick f} "hello")

meter clj

(meter & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (meter "hello") (meter nil "hello")

These two are made equivalent at compile time (meter {:onClick f} "hello") (meter #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (meter :#the-id.klass.other-klass "hello") (meter :#the-id.klass.other-klass {:onClick f} "hello")

missing-glyph clj

(missing-glyph & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (missing-glyph "hello") (missing-glyph nil "hello")

These two are made equivalent at compile time (missing-glyph {:onClick f} "hello") (missing-glyph #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (missing-glyph :#the-id.klass.other-klass "hello") (missing-glyph :#the-id.klass.other-klass {:onClick f} "hello")

MOD clj

mpath clj

(mpath & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (mpath "hello") (mpath nil "hello")

These two are made equivalent at compile time (mpath {:onClick f} "hello") (mpath #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (mpath :#the-id.klass.other-klass "hello") (mpath :#the-id.klass.other-klass {:onClick f} "hello")

nav clj

(nav & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (nav "hello") (nav nil "hello")

These two are made equivalent at compile time (nav {:onClick f} "hello") (nav #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (nav :#the-id.klass.other-klass "hello") (nav :#the-id.klass.other-klass {:onClick f} "hello")

no-suffix clj

node clj

(node component)

(node component name)

Returns the dom node associated with a component's React ref.

This is a NO-OP function for completion, and is not supported for SSR

normalize-styles! clj

(normalize-styles! sb styles)

noscript clj

(noscript & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (noscript "hello") (noscript nil "hello")

These two are made equivalent at compile time (noscript {:onClick f} "hello") (noscript #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (noscript :#the-id.klass.other-klass "hello") (noscript :#the-id.klass.other-klass {:onClick f} "hello")

object clj

(object & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (object "hello") (object nil "hello")

These two are made equivalent at compile time (object {:onClick f} "hello") (object #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (object :#the-id.klass.other-klass "hello") (object :#the-id.klass.other-klass {:onClick f} "hello")

ol clj

(ol & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ol "hello") (ol nil "hello")

These two are made equivalent at compile time (ol {:onClick f} "hello") (ol #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ol :#the-id.klass.other-klass "hello") (ol :#the-id.klass.other-klass {:onClick f} "hello")

optgroup clj

(optgroup & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (optgroup "hello") (optgroup nil "hello")

These two are made equivalent at compile time (optgroup {:onClick f} "hello") (optgroup #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (optgroup :#the-id.klass.other-klass "hello") (optgroup :#the-id.klass.other-klass {:onClick f} "hello")

option clj

(option & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (option "hello") (option nil "hello")

These two are made equivalent at compile time (option {:onClick f} "hello") (option #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (option :#the-id.klass.other-klass "hello") (option :#the-id.klass.other-klass {:onClick f} "hello")

output clj

(output & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (output "hello") (output nil "hello")

These two are made equivalent at compile time (output {:onClick f} "hello") (output #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (output :#the-id.klass.other-klass "hello") (output :#the-id.klass.other-klass {:onClick f} "hello")

p clj

(p & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (p "hello") (p nil "hello")

These two are made equivalent at compile time (p {:onClick f} "hello") (p #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (p :#the-id.klass.other-klass "hello") (p :#the-id.klass.other-klass {:onClick f} "hello")

param clj

(param & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (param "hello") (param nil "hello")

These two are made equivalent at compile time (param {:onClick f} "hello") (param #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (param :#the-id.klass.other-klass "hello") (param :#the-id.klass.other-klass {:onClick f} "hello")

path clj

(path & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (path "hello") (path nil "hello")

These two are made equivalent at compile time (path {:onClick f} "hello") (path #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (path :#the-id.klass.other-klass "hello") (path :#the-id.klass.other-klass {:onClick f} "hello")

pattern clj

(pattern & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (pattern "hello") (pattern nil "hello")

These two are made equivalent at compile time (pattern {:onClick f} "hello") (pattern #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (pattern :#the-id.klass.other-klass "hello") (pattern :#the-id.klass.other-klass {:onClick f} "hello")

picture clj

(picture & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (picture "hello") (picture nil "hello")

These two are made equivalent at compile time (picture {:onClick f} "hello") (picture #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (picture :#the-id.klass.other-klass "hello") (picture :#the-id.klass.other-klass {:onClick f} "hello")

polygon clj

(polygon & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (polygon "hello") (polygon nil "hello")

These two are made equivalent at compile time (polygon {:onClick f} "hello") (polygon #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (polygon :#the-id.klass.other-klass "hello") (polygon :#the-id.klass.other-klass {:onClick f} "hello")

polyline clj

(polyline & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (polyline "hello") (polyline nil "hello")

These two are made equivalent at compile time (polyline {:onClick f} "hello") (polyline #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (polyline :#the-id.klass.other-klass "hello") (polyline :#the-id.klass.other-klass {:onClick f} "hello")

pre clj

(pre & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (pre "hello") (pre nil "hello")

These two are made equivalent at compile time (pre {:onClick f} "hello") (pre #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (pre :#the-id.klass.other-klass "hello") (pre :#the-id.klass.other-klass {:onClick f} "hello")

progress clj

(progress & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (progress "hello") (progress nil "hello")

These two are made equivalent at compile time (progress {:onClick f} "hello") (progress #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (progress :#the-id.klass.other-klass "hello") (progress :#the-id.klass.other-klass {:onClick f} "hello")

q clj

(q & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (q "hello") (q nil "hello")

These two are made equivalent at compile time (q {:onClick f} "hello") (q #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (q :#the-id.klass.other-klass "hello") (q :#the-id.klass.other-klass {:onClick f} "hello")

radialGradient clj

(radialGradient & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (radialGradient "hello") (radialGradient nil "hello")

These two are made equivalent at compile time (radialGradient {:onClick f} "hello") (radialGradient #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (radialGradient :#the-id.klass.other-klass "hello") (radialGradient :#the-id.klass.other-klass {:onClick f} "hello")

react-fragment-node clj

(react-fragment-node elements)

react-text-node clj

(react-text-node s)

HTML text node

rect clj

(rect & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (rect "hello") (rect nil "hello")

These two are made equivalent at compile time (rect {:onClick f} "hello") (rect #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (rect :#the-id.klass.other-klass "hello") (rect :#the-id.klass.other-klass {:onClick f} "hello")

render-attr-map! clj

(render-attr-map! sb tag attrs)

render-attribute! clj

(render-attribute! sb [key value])

render-element! clj

(render-element! {:keys [tag attrs children]} react-id sb)

Render a tag vector as a HTML element string.

render-styles! clj

(render-styles! sb styles)

render-to-str clj macro

(render-to-str x)

render-unescaped-html! clj

(render-unescaped-html! sb m)

render-xml-attribute! clj

(render-xml-attribute! sb name value)

rp clj

(rp & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (rp "hello") (rp nil "hello")

These two are made equivalent at compile time (rp {:onClick f} "hello") (rp #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (rp :#the-id.klass.other-klass "hello") (rp :#the-id.klass.other-klass {:onClick f} "hello")

rt clj

(rt & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (rt "hello") (rt nil "hello")

These two are made equivalent at compile time (rt {:onClick f} "hello") (rt #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (rt :#the-id.klass.other-klass "hello") (rt :#the-id.klass.other-klass {:onClick f} "hello")

ruby clj

(ruby & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ruby "hello") (ruby nil "hello")

These two are made equivalent at compile time (ruby {:onClick f} "hello") (ruby #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ruby :#the-id.klass.other-klass "hello") (ruby :#the-id.klass.other-klass {:onClick f} "hello")

s clj

(s & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (s "hello") (s nil "hello")

These two are made equivalent at compile time (s {:onClick f} "hello") (s #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (s :#the-id.klass.other-klass "hello") (s :#the-id.klass.other-klass {:onClick f} "hello")

samp clj

(samp & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (samp "hello") (samp nil "hello")

These two are made equivalent at compile time (samp {:onClick f} "hello") (samp #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (samp :#the-id.klass.other-klass "hello") (samp :#the-id.klass.other-klass {:onClick f} "hello")

script clj

(script & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (script "hello") (script nil "hello")

These two are made equivalent at compile time (script {:onClick f} "hello") (script #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (script :#the-id.klass.other-klass "hello") (script :#the-id.klass.other-klass {:onClick f} "hello")

section clj

(section & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (section "hello") (section nil "hello")

These two are made equivalent at compile time (section {:onClick f} "hello") (section #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (section :#the-id.klass.other-klass "hello") (section :#the-id.klass.other-klass {:onClick f} "hello")

select clj

(select & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (select "hello") (select nil "hello")

These two are made equivalent at compile time (select {:onClick f} "hello") (select #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (select :#the-id.klass.other-klass "hello") (select :#the-id.klass.other-klass {:onClick f} "hello")

set clj

(set & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (set "hello") (set nil "hello")

These two are made equivalent at compile time (set {:onClick f} "hello") (set #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (set :#the-id.klass.other-klass "hello") (set :#the-id.klass.other-klass {:onClick f} "hello")

small clj

(small & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (small "hello") (small nil "hello")

These two are made equivalent at compile time (small {:onClick f} "hello") (small #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (small :#the-id.klass.other-klass "hello") (small :#the-id.klass.other-klass {:onClick f} "hello")

solidcolor clj

(solidcolor & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (solidcolor "hello") (solidcolor nil "hello")

These two are made equivalent at compile time (solidcolor {:onClick f} "hello") (solidcolor #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (solidcolor :#the-id.klass.other-klass "hello") (solidcolor :#the-id.klass.other-klass {:onClick f} "hello")

source clj

(source & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (source "hello") (source nil "hello")

These two are made equivalent at compile time (source {:onClick f} "hello") (source #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (source :#the-id.klass.other-klass "hello") (source :#the-id.klass.other-klass {:onClick f} "hello")

span clj

(span & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (span "hello") (span nil "hello")

These two are made equivalent at compile time (span {:onClick f} "hello") (span #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (span :#the-id.klass.other-klass "hello") (span :#the-id.klass.other-klass {:onClick f} "hello")

stop clj

(stop & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (stop "hello") (stop nil "hello")

These two are made equivalent at compile time (stop {:onClick f} "hello") (stop #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (stop :#the-id.klass.other-klass "hello") (stop :#the-id.klass.other-klass {:onClick f} "hello")

strong clj

(strong & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (strong "hello") (strong nil "hello")

These two are made equivalent at compile time (strong {:onClick f} "hello") (strong #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (strong :#the-id.klass.other-klass "hello") (strong :#the-id.klass.other-klass {:onClick f} "hello")

style clj

(style & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (style "hello") (style nil "hello")

These two are made equivalent at compile time (style {:onClick f} "hello") (style #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (style :#the-id.klass.other-klass "hello") (style :#the-id.klass.other-klass {:onClick f} "hello")

sub clj

(sub & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (sub "hello") (sub nil "hello")

These two are made equivalent at compile time (sub {:onClick f} "hello") (sub #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (sub :#the-id.klass.other-klass "hello") (sub :#the-id.klass.other-klass {:onClick f} "hello")

summary clj

(summary & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (summary "hello") (summary nil "hello")

These two are made equivalent at compile time (summary {:onClick f} "hello") (summary #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (summary :#the-id.klass.other-klass "hello") (summary :#the-id.klass.other-klass {:onClick f} "hello")

sup clj

(sup & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (sup "hello") (sup nil "hello")

These two are made equivalent at compile time (sup {:onClick f} "hello") (sup #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (sup :#the-id.klass.other-klass "hello") (sup :#the-id.klass.other-klass {:onClick f} "hello")

svg clj

(svg & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (svg "hello") (svg nil "hello")

These two are made equivalent at compile time (svg {:onClick f} "hello") (svg #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (svg :#the-id.klass.other-klass "hello") (svg :#the-id.klass.other-klass {:onClick f} "hello")

switch clj

(switch & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (switch "hello") (switch nil "hello")

These two are made equivalent at compile time (switch {:onClick f} "hello") (switch #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (switch :#the-id.klass.other-klass "hello") (switch :#the-id.klass.other-klass {:onClick f} "hello")

symbol clj

(symbol & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (symbol "hello") (symbol nil "hello")

These two are made equivalent at compile time (symbol {:onClick f} "hello") (symbol #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (symbol :#the-id.klass.other-klass "hello") (symbol :#the-id.klass.other-klass {:onClick f} "hello")

table clj

(table & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (table "hello") (table nil "hello")

These two are made equivalent at compile time (table {:onClick f} "hello") (table #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (table :#the-id.klass.other-klass "hello") (table :#the-id.klass.other-klass {:onClick f} "hello")

tbody clj

(tbody & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tbody "hello") (tbody nil "hello")

These two are made equivalent at compile time (tbody {:onClick f} "hello") (tbody #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tbody :#the-id.klass.other-klass "hello") (tbody :#the-id.klass.other-klass {:onClick f} "hello")

td clj

(td & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (td "hello") (td nil "hello")

These two are made equivalent at compile time (td {:onClick f} "hello") (td #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (td :#the-id.klass.other-klass "hello") (td :#the-id.klass.other-klass {:onClick f} "hello")

text clj

(text & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (text "hello") (text nil "hello")

These two are made equivalent at compile time (text {:onClick f} "hello") (text #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (text :#the-id.klass.other-klass "hello") (text :#the-id.klass.other-klass {:onClick f} "hello")

text-node clj

(text-node s)

HTML text node

textarea clj

(textarea & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (textarea "hello") (textarea nil "hello")

These two are made equivalent at compile time (textarea {:onClick f} "hello") (textarea #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (textarea :#the-id.klass.other-klass "hello") (textarea :#the-id.klass.other-klass {:onClick f} "hello")

textPath clj

(textPath & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (textPath "hello") (textPath nil "hello")

These two are made equivalent at compile time (textPath {:onClick f} "hello") (textPath #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (textPath :#the-id.klass.other-klass "hello") (textPath :#the-id.klass.other-klass {:onClick f} "hello")

tfoot clj

(tfoot & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tfoot "hello") (tfoot nil "hello")

These two are made equivalent at compile time (tfoot {:onClick f} "hello") (tfoot #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tfoot :#the-id.klass.other-klass "hello") (tfoot :#the-id.klass.other-klass {:onClick f} "hello")

th clj

(th & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (th "hello") (th nil "hello")

These two are made equivalent at compile time (th {:onClick f} "hello") (th #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (th :#the-id.klass.other-klass "hello") (th :#the-id.klass.other-klass {:onClick f} "hello")

thead clj

(thead & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (thead "hello") (thead nil "hello")

These two are made equivalent at compile time (thead {:onClick f} "hello") (thead #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (thead :#the-id.klass.other-klass "hello") (thead :#the-id.klass.other-klass {:onClick f} "hello")

time clj

(time & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (time "hello") (time nil "hello")

These two are made equivalent at compile time (time {:onClick f} "hello") (time #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (time :#the-id.klass.other-klass "hello") (time :#the-id.klass.other-klass {:onClick f} "hello")

title clj

(title & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (title "hello") (title nil "hello")

These two are made equivalent at compile time (title {:onClick f} "hello") (title #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (title :#the-id.klass.other-klass "hello") (title :#the-id.klass.other-klass {:onClick f} "hello")

tr clj

(tr & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tr "hello") (tr nil "hello")

These two are made equivalent at compile time (tr {:onClick f} "hello") (tr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tr :#the-id.klass.other-klass "hello") (tr :#the-id.klass.other-klass {:onClick f} "hello")

track clj

(track & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (track "hello") (track nil "hello")

These two are made equivalent at compile time (track {:onClick f} "hello") (track #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (track :#the-id.klass.other-klass "hello") (track :#the-id.klass.other-klass {:onClick f} "hello")

tref clj

(tref & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tref "hello") (tref nil "hello")

These two are made equivalent at compile time (tref {:onClick f} "hello") (tref #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tref :#the-id.klass.other-klass "hello") (tref :#the-id.klass.other-klass {:onClick f} "hello")

tspan clj

(tspan & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (tspan "hello") (tspan nil "hello")

These two are made equivalent at compile time (tspan {:onClick f} "hello") (tspan #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (tspan :#the-id.klass.other-klass "hello") (tspan :#the-id.klass.other-klass {:onClick f} "hello")

u clj

(u & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (u "hello") (u nil "hello")

These two are made equivalent at compile time (u {:onClick f} "hello") (u #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (u :#the-id.klass.other-klass "hello") (u :#the-id.klass.other-klass {:onClick f} "hello")

ul clj

(ul & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (ul "hello") (ul nil "hello")

These two are made equivalent at compile time (ul {:onClick f} "hello") (ul #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (ul :#the-id.klass.other-klass "hello") (ul :#the-id.klass.other-klass {:onClick f} "hello")

unknown clj

(unknown & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (unknown "hello") (unknown nil "hello")

These two are made equivalent at compile time (unknown {:onClick f} "hello") (unknown #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (unknown :#the-id.klass.other-klass "hello") (unknown :#the-id.klass.other-klass {:onClick f} "hello")

use clj

(use & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (use "hello") (use nil "hello")

These two are made equivalent at compile time (use {:onClick f} "hello") (use #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (use :#the-id.klass.other-klass "hello") (use :#the-id.klass.other-klass {:onClick f} "hello")

var clj

(var & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (var "hello") (var nil "hello")

These two are made equivalent at compile time (var {:onClick f} "hello") (var #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (var :#the-id.klass.other-klass "hello") (var :#the-id.klass.other-klass {:onClick f} "hello")

video clj

(video & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (video "hello") (video nil "hello")

These two are made equivalent at compile time (video {:onClick f} "hello") (video #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (video :#the-id.klass.other-klass "hello") (video :#the-id.klass.other-klass {:onClick f} "hello")

view clj

(view & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (view "hello") (view nil "hello")

These two are made equivalent at compile time (view {:onClick f} "hello") (view #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (view :#the-id.klass.other-klass "hello") (view :#the-id.klass.other-klass {:onClick f} "hello")

vkern clj

(vkern & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (vkern "hello") (vkern nil "hello")

These two are made equivalent at compile time (vkern {:onClick f} "hello") (vkern #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (vkern :#the-id.klass.other-klass "hello") (vkern :#the-id.klass.other-klass {:onClick f} "hello")

wbr clj

(wbr & args)

Returns a server side DOM element. Can be invoked in several ways

These two are made equivalent at compile time (wbr "hello") (wbr nil "hello")

These two are made equivalent at compile time (wbr {:onClick f} "hello") (wbr #js {:onClick f} "hello")

There is also a shorthand for CSS id and class names (wbr :#the-id.klass.other-klass "hello") (wbr :#the-id.klass.other-klass {:onClick f} "hello")