Liking cljdoc? Tell your friends :D
Clojure only.

fulcro.client.dom-server

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 [fulcro.client.dom-server :as dom] :cljs [fulcro.client.dom :as dom])))

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 [fulcro.client.dom-server :as dom] :cljs [fulcro.client.dom :as dom])))
raw docstring

aclj

(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")

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")
raw docstring

abbrclj

(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")

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")
raw docstring

addressclj

(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")

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")
raw docstring

altGlyphclj

(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")

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")
raw docstring

altGlyphDefclj

(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")

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")
raw docstring

altGlyphItemclj

(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")

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")
raw docstring

animateclj

(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")

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")
raw docstring

animateColorclj

(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")

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")
raw docstring

animateMotionclj

(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")

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")
raw docstring

animateTransformclj

(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")

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")
raw docstring

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)

areaclj

(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")

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")
raw docstring

articleclj

(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")

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")
raw docstring

asideclj

(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")

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")
raw docstring

audioclj

(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")

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")
raw docstring

bclj

(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")

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")
raw docstring

baseclj

(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")

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")
raw docstring

bdiclj

(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")

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")
raw docstring

bdoclj

(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")

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")
raw docstring

bigclj

(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")

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")
raw docstring

blockquoteclj

(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")

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")
raw docstring

bodyclj

(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")

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")
raw docstring

brclj

(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")

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")
raw docstring

buttonclj

(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")

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")
raw docstring

camel->colon-betweenclj


camel->kebab-caseclj


camel->other-caseclj

(camel->other-case sep)

canvasclj

(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")

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")
raw docstring

captionclj

(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")

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")
raw docstring

circleclj

(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")

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")
raw docstring

citeclj

(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")

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")
raw docstring

clipPathclj

(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")

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")
raw docstring

codeclj

(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")

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")
raw docstring

coerce-attr-keyclj

(coerce-attr-key k)

colclj

(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")

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")
raw docstring

colgroupclj

(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")

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")
raw docstring

colon-between-attrsclj


color-profileclj

(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")

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")
raw docstring

component?clj

(component? x)

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

Returns true if the given arg is a server-side react component.
raw docstring

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.

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.
raw docstring

create-elementclj

(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

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`
raw docstring

cursorclj

(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")

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")
raw docstring

dataclj

(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")

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")
raw docstring

datalistclj

(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")

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")
raw docstring

ddclj

(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")

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")
raw docstring

defsclj

(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")

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")
raw docstring

delclj

(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")

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")
raw docstring

descclj

(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")

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")
raw docstring

detailsclj

(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")

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")
raw docstring

dfnclj

(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")

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")
raw docstring

dialogclj

(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")

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")
raw docstring

discardclj

(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")

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")
raw docstring

divclj

(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")

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")
raw docstring

dlclj

(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")

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")
raw docstring

dtclj

(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")

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")
raw docstring

elementclj

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

Creates a dom node.

Creates a dom node.
raw docstring

element?clj

(element? x)

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

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

ellipseclj

(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")

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")
raw docstring

emclj

(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")

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")
raw docstring

embedclj

(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")

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")
raw docstring

escape-htmlclj

(escape-html s)

feBlendclj

(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")

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")
raw docstring

feColorMatrixclj

(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")

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")
raw docstring

feComponentTransferclj

(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")

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")
raw docstring

feCompositeclj

(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")

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")
raw docstring

feConvolveMatrixclj

(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")

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")
raw docstring

feDiffuseLightingclj

(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")

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")
raw docstring

feDisplacementMapclj

(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")

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")
raw docstring

feDistantLightclj

(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")

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")
raw docstring

feDropShadowclj

(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")

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")
raw docstring

feFloodclj

(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")

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")
raw docstring

feFuncAclj

(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")

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")
raw docstring

feFuncBclj

(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")

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")
raw docstring

feFuncGclj

(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")

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")
raw docstring

feFuncRclj

(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")

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")
raw docstring

feGaussianBlurclj

(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")

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")
raw docstring

feImageclj

(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")

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")
raw docstring

feMergeclj

(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")

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")
raw docstring

feMergeNodeclj

(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")

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")
raw docstring

feMorphologyclj

(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")

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")
raw docstring

feOffsetclj

(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")

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")
raw docstring

fePointLightclj

(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")

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")
raw docstring

feSpecularLightingclj

(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")

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")
raw docstring

feSpotLightclj

(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")

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")
raw docstring

feTileclj

(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")

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")
raw docstring

feTurbulenceclj

(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")

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")
raw docstring

fieldsetclj

(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")

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")
raw docstring

figcaptionclj

(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")

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")
raw docstring

figureclj

(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")

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")
raw docstring

filterclj

(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")

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")
raw docstring

fontclj

(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")

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")
raw docstring

font-faceclj

(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")

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")
raw docstring

font-face-formatclj

(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")

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")
raw docstring

font-face-nameclj

(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")

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")
raw docstring

font-face-srcclj

(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")

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")
raw docstring

font-face-uriclj

(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")

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")
raw docstring

(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")

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")
raw docstring

foreignObjectclj

(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")

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")
raw docstring

formclj

(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")

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")
raw docstring

gclj

(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")

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")
raw docstring

gen-all-tagscljmacro

(gen-all-tags)

gen-tag-fnclj

(gen-tag-fn tag)

glyphclj

(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")

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")
raw docstring

glyphRefclj

(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")

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")
raw docstring

h1clj

(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")

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")
raw docstring

h2clj

(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")

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")
raw docstring

h3clj

(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")

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")
raw docstring

h4clj

(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")

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")
raw docstring

h5clj

(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")

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")
raw docstring

h6clj

(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")

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")
raw docstring

hatchclj

(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")

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")
raw docstring

hatchpathclj

(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")

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")
raw docstring

(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")

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")
raw docstring

(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")

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")
raw docstring

hkernclj

(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")

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")
raw docstring

hrclj

(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")

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")
raw docstring

htmlclj

(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")

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")
raw docstring

iclj

(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")

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")
raw docstring

iframeclj

(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")

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")
raw docstring

imageclj

(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")

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")
raw docstring

imgclj

(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")

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")
raw docstring

inputclj

(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")

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")
raw docstring

insclj

(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")

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")
raw docstring

kbdclj

(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")

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")
raw docstring

kebab-case-attrsclj


key-escape-lookupclj


keygenclj

(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")

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")
raw docstring

labelclj

(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")

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")
raw docstring

legendclj

(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")

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")
raw docstring

liclj

(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")

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")
raw docstring

lineclj

(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")

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")
raw docstring

linearGradientclj

(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")

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")
raw docstring

(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")

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")
raw docstring

lower-case-attrsclj


mainclj

(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")

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")
raw docstring

mapclj

(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")

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")
raw docstring

markclj

(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")

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")
raw docstring

markerclj

(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")

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")
raw docstring

maskclj

(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")

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")
raw docstring

(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")

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")
raw docstring

(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")

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")
raw docstring

meshclj

(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")

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")
raw docstring

meshgradientclj

(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")

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")
raw docstring

meshpatchclj

(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")

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")
raw docstring

meshrowclj

(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")

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")
raw docstring

metaclj

(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")

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")
raw docstring

metadataclj

(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")

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")
raw docstring

meterclj

(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")

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")
raw docstring

missing-glyphclj

(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")

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")
raw docstring

mpathclj

(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")

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")
raw docstring

(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")

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")
raw docstring

no-suffixclj


nodeclj

(node component)
(node component name)

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

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

normalize-styles!clj

(normalize-styles! sb styles)

noscriptclj

(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")

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")
raw docstring

objectclj

(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")

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")
raw docstring

olclj

(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")

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")
raw docstring

optgroupclj

(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")

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")
raw docstring

optionclj

(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")

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")
raw docstring

outputclj

(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")

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")
raw docstring

pclj

(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")

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")
raw docstring

paramclj

(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")

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")
raw docstring

pathclj

(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")

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")
raw docstring

patternclj

(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")

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")
raw docstring

pictureclj

(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")

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")
raw docstring

polygonclj

(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")

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")
raw docstring

polylineclj

(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")

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")
raw docstring

preclj

(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")

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")
raw docstring

progressclj

(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")

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")
raw docstring

qclj

(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")

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")
raw docstring

radialGradientclj

(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")

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")
raw docstring

react-text-nodeclj

(react-text-node s)

HTML text node

HTML text node
raw docstring

rectclj

(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")

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")
raw docstring

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 a tag vector as a HTML element string.
raw docstring

render-styles!clj

(render-styles! sb styles)

render-to-strclj

(render-to-str x)

render-unescaped-html!clj

(render-unescaped-html! sb m)

render-xml-attribute!clj

(render-xml-attribute! sb name value)

rpclj

(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")

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")
raw docstring

rtclj

(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")

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")
raw docstring

rubyclj

(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")

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")
raw docstring

sclj

(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")

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")
raw docstring

sampclj

(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")

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")
raw docstring

scriptclj

(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")

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")
raw docstring

sectionclj

(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")

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")
raw docstring

selectclj

(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")

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")
raw docstring

setclj

(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")

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")
raw docstring

smallclj

(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")

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")
raw docstring

solidcolorclj

(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")

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")
raw docstring

sourceclj

(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")

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")
raw docstring

spanclj

(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")

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")
raw docstring

stopclj

(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")

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")
raw docstring

strongclj

(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")

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")
raw docstring

styleclj

(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")

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")
raw docstring

subclj

(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")

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")
raw docstring

summaryclj

(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")

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")
raw docstring

supclj

(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")

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")
raw docstring

svgclj

(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")

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")
raw docstring

switchclj

(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")

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")
raw docstring

symbolclj

(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")

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")
raw docstring

tableclj

(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")

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")
raw docstring

tbodyclj

(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")

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")
raw docstring

tdclj

(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")

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")
raw docstring

textclj

(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")

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")
raw docstring

text-nodeclj

(text-node s)

HTML text node

HTML text node
raw docstring

textareaclj

(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")

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")
raw docstring

textPathclj

(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")

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")
raw docstring

tfootclj

(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")

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")
raw docstring

thclj

(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")

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")
raw docstring

theadclj

(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")

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")
raw docstring

timeclj

(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")

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")
raw docstring

titleclj

(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")

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")
raw docstring

trclj

(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")

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")
raw docstring

trackclj

(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")

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")
raw docstring

trefclj

(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")

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")
raw docstring

tspanclj

(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")

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")
raw docstring

uclj

(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")

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")
raw docstring

ulclj

(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")

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")
raw docstring

unknownclj

(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")

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")
raw docstring

useclj

(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")

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")
raw docstring

varclj

(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")

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")
raw docstring

videoclj

(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")

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")
raw docstring

viewclj

(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")

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")
raw docstring

vkernclj

(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")

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")
raw docstring

wbrclj

(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")

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")
raw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close