Liking cljdoc? Tell your friends :D
Clojure only.

com.fulcrologic.fulcro.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 [com.fulcrologic.fulcro.dom-server :as dom] :cljs [com.fulcrologic.fulcro.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 [com.fulcrologic.fulcro.dom-server :as dom] :cljs [com.fulcrologic.fulcro.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")
sourceraw 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")
sourceraw 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")
sourceraw docstring

adler32clj

(adler32 sb)
source

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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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)
source

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

assign-react-checksumclj

(assign-react-checksum sb)
source

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

camel->colon-betweenclj

source

camel->kebab-caseclj

source

camel->other-caseclj

(camel->other-case sep)
source

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

coerce-attr-keyclj

(coerce-attr-key k)
source

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

colon-between-attrsclj

source

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")
sourceraw 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.
sourceraw 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`
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw docstring

elementclj

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

Creates a dom node.

Creates a dom node.
sourceraw 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.
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw docstring

escape-htmlclj

(escape-html s)
source

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

gen-all-tagscljmacro

(gen-all-tags)
source

gen-tag-fnclj

(gen-tag-fn tag)
source

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

kebab-case-attrsclj

source

key-escape-lookupclj

source

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

lower-case-attrsclj

source

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

MODclj

source

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

no-suffixclj

source

nodeclj

(node component)
(node component name)

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

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

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

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

normalize-styles!clj

(normalize-styles! sb styles)
source

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

react-text-nodeclj

(react-text-node s)

HTML text node

HTML text node
sourceraw 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")
sourceraw docstring

render-attr-map!clj

(render-attr-map! sb tag attrs)
source

render-attribute!clj

(render-attribute! sb [key value])
source

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

render-styles!clj

(render-styles! sb styles)
source

render-to-strclj

(render-to-str x)
source

render-unescaped-html!clj

(render-unescaped-html! sb m)
source

render-xml-attribute!clj

(render-xml-attribute! sb name value)
source

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

text-nodeclj

(text-node s)

HTML text node

HTML text node
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw 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")
sourceraw docstring

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

× close