CrossClj

2.5.12 docs

SourceDocs



RECENT
    VARS
    ->Element
    ->ReactEmpty
    ->ReactText
    ->Text
    a
    abbr
    address
    append!
    area
    article
    aside
    audio
    b
    base
    bdi
    bdo
    big
    blockquote
    body
    br
    button
    camel->colon-between
    camel->kebab-case
    camel->other-case
    canvas
    caption
    circle
    cite
    clipPath
    code
    coerce-attr-key
    col
    colgroup
    colon-between-attrs
    component?
    container-tag?
    create-element
    data
    datalist
    dd
    defs
    del
    details
    dfn
    dialog
    div
    dl
    dt
    element
    element?
    ellipse
    em
    embed
    escape-html
    fieldset
    figcaption
    figure
    footer
    form
    g
    gen-all-tags
    gen-tag-fn
    h1
    h2
    h3
    h4
    h5
    h6
    head
    header
    hr
    html
    i
    iframe
    img
    input
    ins
    kbd
    kebab-case-attrs
    key-escape-lookup
    keygen
    label
    legend
    li
    line
    linearGradient
    link
    lower-case-attrs
    main
    map
    map->Element
    map->ReactEmpty
    map->ReactText
    map->Text
    mark
    mask
    menu
    menuitem
    meta
    meter
    nav
    no-suffix
    node
    normalize-styles!
    noscript
    object
    ol
    optgroup
    option
    output
    p
    param
    path
    pattern
    picture
    polygon
    polyline
    pre
    progress
    q
    radialGradient
    react-empty-node
    react-text-node
    rect
    render-attr-map!
    render-attribute!
    render-component
    render-element!
    render-styles!
    render-to-str
    render-to-str*
    render-unescaped-html!
    render-xml-attribute!
    rp
    rt
    ruby
    s
    samp
    script
    section
    select
    small
    source
    span
    stop
    strong
    style
    sub
    summary
    sup
    svg
    table
    tbody
    td
    text
    text-node
    textarea
    tfoot
    th
    thead
    time
    title
    tr
    track
    tspan
    u
    ul
    use
    var
    video
    void-tags
    wbr

    « Index of all namespaces of this project

    Support for rendering DOM from CLJ. Must be separate to enable same-named macros in CLJS for performance.
    
    Usage: Create your UI in CLJC files, and require with conditional reader tags:
    
    (ns app.ui
      (:require
        #?(:clj [fulcro.client.dom-server :as dom] :cljs [fulcro.client.dom :as dom])))
    (->Element tag attrs react-key children)
    Positional factory function for class fulcro.client.dom_server.Element.
    
    (->ReactEmpty)
    Positional factory function for class fulcro.client.dom_server.ReactEmpty.
    
    (->ReactText text)
    Positional factory function for class fulcro.client.dom_server.ReactText.
    
    (->Text s)
    Positional factory function for class fulcro.client.dom_server.Text.
    
    (a & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (a "hello")
    (a nil "hello")
    
    These two are made equivalent at compile time
    (a {:onClick f} "hello")
    (a #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (a :#the-id.klass.other-klass "hello")
    (a :#the-id.klass.other-klass {:onClick f} "hello")
    (abbr & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (abbr "hello")
    (abbr nil "hello")
    
    These two are made equivalent at compile time
    (abbr {:onClick f} "hello")
    (abbr #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (abbr :#the-id.klass.other-klass "hello")
    (abbr :#the-id.klass.other-klass {:onClick f} "hello")
    (address & 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")
    (append! sb s0)(append! sb s0 s1)(append! sb s0 s1 s2)(append! sb s0 s1 s2 s3)(append! sb s0 s1 s2 s3 s4)(append! sb s0 s1 s2 s3 s4 & rest)
    (area & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (area "hello")
    (area nil "hello")
    
    These two are made equivalent at compile time
    (area {:onClick f} "hello")
    (area #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (area :#the-id.klass.other-klass "hello")
    (area :#the-id.klass.other-klass {:onClick f} "hello")
    (article & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (article "hello")
    (article nil "hello")
    
    These two are made equivalent at compile time
    (article {:onClick f} "hello")
    (article #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (article :#the-id.klass.other-klass "hello")
    (article :#the-id.klass.other-klass {:onClick f} "hello")
    (aside & 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")
    (audio & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (audio "hello")
    (audio nil "hello")
    
    These two are made equivalent at compile time
    (audio {:onClick f} "hello")
    (audio #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (audio :#the-id.klass.other-klass "hello")
    (audio :#the-id.klass.other-klass {:onClick f} "hello")
    (b & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (b "hello")
    (b nil "hello")
    
    These two are made equivalent at compile time
    (b {:onClick f} "hello")
    (b #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (b :#the-id.klass.other-klass "hello")
    (b :#the-id.klass.other-klass {:onClick f} "hello")
    (base & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (base "hello")
    (base nil "hello")
    
    These two are made equivalent at compile time
    (base {:onClick f} "hello")
    (base #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (base :#the-id.klass.other-klass "hello")
    (base :#the-id.klass.other-klass {:onClick f} "hello")
    (bdi & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (bdi "hello")
    (bdi nil "hello")
    
    These two are made equivalent at compile time
    (bdi {:onClick f} "hello")
    (bdi #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (bdi :#the-id.klass.other-klass "hello")
    (bdi :#the-id.klass.other-klass {:onClick f} "hello")
    (bdo & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (bdo "hello")
    (bdo nil "hello")
    
    These two are made equivalent at compile time
    (bdo {:onClick f} "hello")
    (bdo #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (bdo :#the-id.klass.other-klass "hello")
    (bdo :#the-id.klass.other-klass {:onClick f} "hello")
    (big & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (big "hello")
    (big nil "hello")
    
    These two are made equivalent at compile time
    (big {:onClick f} "hello")
    (big #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (big :#the-id.klass.other-klass "hello")
    (big :#the-id.klass.other-klass {:onClick f} "hello")
    (blockquote & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (blockquote "hello")
    (blockquote nil "hello")
    
    These two are made equivalent at compile time
    (blockquote {:onClick f} "hello")
    (blockquote #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (blockquote :#the-id.klass.other-klass "hello")
    (blockquote :#the-id.klass.other-klass {:onClick f} "hello")
    (body & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (body "hello")
    (body nil "hello")
    
    These two are made equivalent at compile time
    (body {:onClick f} "hello")
    (body #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (body :#the-id.klass.other-klass "hello")
    (body :#the-id.klass.other-klass {:onClick f} "hello")
    (br & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (br "hello")
    (br nil "hello")
    
    These two are made equivalent at compile time
    (br {:onClick f} "hello")
    (br #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (br :#the-id.klass.other-klass "hello")
    (br :#the-id.klass.other-klass {:onClick f} "hello")
    (button & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (button "hello")
    (button nil "hello")
    
    These two are made equivalent at compile time
    (button {:onClick f} "hello")
    (button #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (button :#the-id.klass.other-klass "hello")
    (button :#the-id.klass.other-klass {:onClick f} "hello")
    (camel->other-case sep)
    (canvas & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (canvas "hello")
    (canvas nil "hello")
    
    These two are made equivalent at compile time
    (canvas {:onClick f} "hello")
    (canvas #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (canvas :#the-id.klass.other-klass "hello")
    (canvas :#the-id.klass.other-klass {:onClick f} "hello")
    (caption & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (caption "hello")
    (caption nil "hello")
    
    These two are made equivalent at compile time
    (caption {:onClick f} "hello")
    (caption #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (caption :#the-id.klass.other-klass "hello")
    (caption :#the-id.klass.other-klass {:onClick f} "hello")
    (circle & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (circle "hello")
    (circle nil "hello")
    
    These two are made equivalent at compile time
    (circle {:onClick f} "hello")
    (circle #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (circle :#the-id.klass.other-klass "hello")
    (circle :#the-id.klass.other-klass {:onClick f} "hello")
    (cite & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (cite "hello")
    (cite nil "hello")
    
    These two are made equivalent at compile time
    (cite {:onClick f} "hello")
    (cite #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (cite :#the-id.klass.other-klass "hello")
    (cite :#the-id.klass.other-klass {:onClick f} "hello")
    (clipPath & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (clipPath "hello")
    (clipPath nil "hello")
    
    These two are made equivalent at compile time
    (clipPath {:onClick f} "hello")
    (clipPath #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (clipPath :#the-id.klass.other-klass "hello")
    (clipPath :#the-id.klass.other-klass {:onClick f} "hello")
    (code & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (code "hello")
    (code nil "hello")
    
    These two are made equivalent at compile time
    (code {:onClick f} "hello")
    (code #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (code :#the-id.klass.other-klass "hello")
    (code :#the-id.klass.other-klass {:onClick f} "hello")
    (coerce-attr-key k)
    (col & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (col "hello")
    (col nil "hello")
    
    These two are made equivalent at compile time
    (col {:onClick f} "hello")
    (col #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (col :#the-id.klass.other-klass "hello")
    (col :#the-id.klass.other-klass {:onClick f} "hello")
    (colgroup & 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")
    (component? x)
    Returns true if the given arg is a server-side react component.
    
    (container-tag? tag content)
    Returns true if the tag has content or is not a void tag. In non-HTML modes,
    all contentless tags are assumed to be void tags.
    (create-element 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
    (data & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (data "hello")
    (data nil "hello")
    
    These two are made equivalent at compile time
    (data {:onClick f} "hello")
    (data #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (data :#the-id.klass.other-klass "hello")
    (data :#the-id.klass.other-klass {:onClick f} "hello")
    (datalist & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (datalist "hello")
    (datalist nil "hello")
    
    These two are made equivalent at compile time
    (datalist {:onClick f} "hello")
    (datalist #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (datalist :#the-id.klass.other-klass "hello")
    (datalist :#the-id.klass.other-klass {:onClick f} "hello")
    (dd & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (dd "hello")
    (dd nil "hello")
    
    These two are made equivalent at compile time
    (dd {:onClick f} "hello")
    (dd #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (dd :#the-id.klass.other-klass "hello")
    (dd :#the-id.klass.other-klass {:onClick f} "hello")
    (defs & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (defs "hello")
    (defs nil "hello")
    
    These two are made equivalent at compile time
    (defs {:onClick f} "hello")
    (defs #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (defs :#the-id.klass.other-klass "hello")
    (defs :#the-id.klass.other-klass {:onClick f} "hello")
    (del & 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")
    (details & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (details "hello")
    (details nil "hello")
    
    These two are made equivalent at compile time
    (details {:onClick f} "hello")
    (details #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (details :#the-id.klass.other-klass "hello")
    (details :#the-id.klass.other-klass {:onClick f} "hello")
    (dfn & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (dfn "hello")
    (dfn nil "hello")
    
    These two are made equivalent at compile time
    (dfn {:onClick f} "hello")
    (dfn #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (dfn :#the-id.klass.other-klass "hello")
    (dfn :#the-id.klass.other-klass {:onClick f} "hello")
    (dialog & 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")
    (div & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (div "hello")
    (div nil "hello")
    
    These two are made equivalent at compile time
    (div {:onClick f} "hello")
    (div #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (div :#the-id.klass.other-klass "hello")
    (div :#the-id.klass.other-klass {:onClick f} "hello")
    (dl & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (dl "hello")
    (dl nil "hello")
    
    These two are made equivalent at compile time
    (dl {:onClick f} "hello")
    (dl #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (dl :#the-id.klass.other-klass "hello")
    (dl :#the-id.klass.other-klass {:onClick f} "hello")
    (dt & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (dt "hello")
    (dt nil "hello")
    
    These two are made equivalent at compile time
    (dt {:onClick f} "hello")
    (dt #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (dt :#the-id.klass.other-klass "hello")
    (dt :#the-id.klass.other-klass {:onClick f} "hello")
    (element {:keys [tag attrs react-key children], :as elem})
    Creates a dom node.
    
    (element? x)
    Returns true if the given arg is a server-side react element.
    
    (ellipse & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (ellipse "hello")
    (ellipse nil "hello")
    
    These two are made equivalent at compile time
    (ellipse {:onClick f} "hello")
    (ellipse #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (ellipse :#the-id.klass.other-klass "hello")
    (ellipse :#the-id.klass.other-klass {:onClick f} "hello")
    (em & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (em "hello")
    (em nil "hello")
    
    These two are made equivalent at compile time
    (em {:onClick f} "hello")
    (em #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (em :#the-id.klass.other-klass "hello")
    (em :#the-id.klass.other-klass {:onClick f} "hello")
    (embed & 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")
    (fieldset & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (fieldset "hello")
    (fieldset nil "hello")
    
    These two are made equivalent at compile time
    (fieldset {:onClick f} "hello")
    (fieldset #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (fieldset :#the-id.klass.other-klass "hello")
    (fieldset :#the-id.klass.other-klass {:onClick f} "hello")
    (figcaption & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (figcaption "hello")
    (figcaption nil "hello")
    
    These two are made equivalent at compile time
    (figcaption {:onClick f} "hello")
    (figcaption #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (figcaption :#the-id.klass.other-klass "hello")
    (figcaption :#the-id.klass.other-klass {:onClick f} "hello")
    (figure & 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")
    (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")
    (form & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (form "hello")
    (form nil "hello")
    
    These two are made equivalent at compile time
    (form {:onClick f} "hello")
    (form #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (form :#the-id.klass.other-klass "hello")
    (form :#the-id.klass.other-klass {:onClick f} "hello")
    (g & 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")
    macro
    (gen-all-tags)
    (gen-tag-fn tag)
    (h1 & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (h1 "hello")
    (h1 nil "hello")
    
    These two are made equivalent at compile time
    (h1 {:onClick f} "hello")
    (h1 #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (h1 :#the-id.klass.other-klass "hello")
    (h1 :#the-id.klass.other-klass {:onClick f} "hello")
    (h2 & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (h2 "hello")
    (h2 nil "hello")
    
    These two are made equivalent at compile time
    (h2 {:onClick f} "hello")
    (h2 #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (h2 :#the-id.klass.other-klass "hello")
    (h2 :#the-id.klass.other-klass {:onClick f} "hello")
    (h3 & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (h3 "hello")
    (h3 nil "hello")
    
    These two are made equivalent at compile time
    (h3 {:onClick f} "hello")
    (h3 #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (h3 :#the-id.klass.other-klass "hello")
    (h3 :#the-id.klass.other-klass {:onClick f} "hello")
    (h4 & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (h4 "hello")
    (h4 nil "hello")
    
    These two are made equivalent at compile time
    (h4 {:onClick f} "hello")
    (h4 #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (h4 :#the-id.klass.other-klass "hello")
    (h4 :#the-id.klass.other-klass {:onClick f} "hello")
    (h5 & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (h5 "hello")
    (h5 nil "hello")
    
    These two are made equivalent at compile time
    (h5 {:onClick f} "hello")
    (h5 #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (h5 :#the-id.klass.other-klass "hello")
    (h5 :#the-id.klass.other-klass {:onClick f} "hello")
    (h6 & 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")
    (head & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (head "hello")
    (head nil "hello")
    
    These two are made equivalent at compile time
    (head {:onClick f} "hello")
    (head #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (head :#the-id.klass.other-klass "hello")
    (head :#the-id.klass.other-klass {:onClick f} "hello")
    (header & 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")
    (hr & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (hr "hello")
    (hr nil "hello")
    
    These two are made equivalent at compile time
    (hr {:onClick f} "hello")
    (hr #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (hr :#the-id.klass.other-klass "hello")
    (hr :#the-id.klass.other-klass {:onClick f} "hello")
    (html & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (html "hello")
    (html nil "hello")
    
    These two are made equivalent at compile time
    (html {:onClick f} "hello")
    (html #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (html :#the-id.klass.other-klass "hello")
    (html :#the-id.klass.other-klass {:onClick f} "hello")
    (i & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (i "hello")
    (i nil "hello")
    
    These two are made equivalent at compile time
    (i {:onClick f} "hello")
    (i #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (i :#the-id.klass.other-klass "hello")
    (i :#the-id.klass.other-klass {:onClick f} "hello")
    (iframe & 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")
    (img & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (img "hello")
    (img nil "hello")
    
    These two are made equivalent at compile time
    (img {:onClick f} "hello")
    (img #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (img :#the-id.klass.other-klass "hello")
    (img :#the-id.klass.other-klass {:onClick f} "hello")
    (input & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (input "hello")
    (input nil "hello")
    
    These two are made equivalent at compile time
    (input {:onClick f} "hello")
    (input #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (input :#the-id.klass.other-klass "hello")
    (input :#the-id.klass.other-klass {:onClick f} "hello")
    (ins & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (ins "hello")
    (ins nil "hello")
    
    These two are made equivalent at compile time
    (ins {:onClick f} "hello")
    (ins #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (ins :#the-id.klass.other-klass "hello")
    (ins :#the-id.klass.other-klass {:onClick f} "hello")
    (kbd & 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")
    (keygen & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (keygen "hello")
    (keygen nil "hello")
    
    These two are made equivalent at compile time
    (keygen {:onClick f} "hello")
    (keygen #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (keygen :#the-id.klass.other-klass "hello")
    (keygen :#the-id.klass.other-klass {:onClick f} "hello")
    (label & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (label "hello")
    (label nil "hello")
    
    These two are made equivalent at compile time
    (label {:onClick f} "hello")
    (label #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (label :#the-id.klass.other-klass "hello")
    (label :#the-id.klass.other-klass {:onClick f} "hello")
    (legend & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (legend "hello")
    (legend nil "hello")
    
    These two are made equivalent at compile time
    (legend {:onClick f} "hello")
    (legend #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (legend :#the-id.klass.other-klass "hello")
    (legend :#the-id.klass.other-klass {:onClick f} "hello")
    (li & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (li "hello")
    (li nil "hello")
    
    These two are made equivalent at compile time
    (li {:onClick f} "hello")
    (li #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (li :#the-id.klass.other-klass "hello")
    (li :#the-id.klass.other-klass {:onClick f} "hello")
    (line & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (line "hello")
    (line nil "hello")
    
    These two are made equivalent at compile time
    (line {:onClick f} "hello")
    (line #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (line :#the-id.klass.other-klass "hello")
    (line :#the-id.klass.other-klass {:onClick f} "hello")
    (linearGradient & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (linearGradient "hello")
    (linearGradient nil "hello")
    
    These two are made equivalent at compile time
    (linearGradient {:onClick f} "hello")
    (linearGradient #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (linearGradient :#the-id.klass.other-klass "hello")
    (linearGradient :#the-id.klass.other-klass {:onClick f} "hello")
    (link & 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")
    (main & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (main "hello")
    (main nil "hello")
    
    These two are made equivalent at compile time
    (main {:onClick f} "hello")
    (main #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (main :#the-id.klass.other-klass "hello")
    (main :#the-id.klass.other-klass {:onClick f} "hello")
    (map & 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")
    (map->Element m__7585__auto__)
    Factory function for class fulcro.client.dom_server.Element, taking a map of keywords to field values.
    
    (map->ReactEmpty m__7585__auto__)
    Factory function for class fulcro.client.dom_server.ReactEmpty, taking a map of keywords to field values.
    
    (map->ReactText m__7585__auto__)
    Factory function for class fulcro.client.dom_server.ReactText, taking a map of keywords to field values.
    
    (map->Text m__7585__auto__)
    Factory function for class fulcro.client.dom_server.Text, taking a map of keywords to field values.
    
    (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")
    (mask & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (mask "hello")
    (mask nil "hello")
    
    These two are made equivalent at compile time
    (mask {:onClick f} "hello")
    (mask #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (mask :#the-id.klass.other-klass "hello")
    (mask :#the-id.klass.other-klass {:onClick f} "hello")
    (menu & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (menu "hello")
    (menu nil "hello")
    
    These two are made equivalent at compile time
    (menu {:onClick f} "hello")
    (menu #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (menu :#the-id.klass.other-klass "hello")
    (menu :#the-id.klass.other-klass {:onClick f} "hello")
    (menuitem & 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")
    (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")
    (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")
    (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")
    (node component)(node component name)
    Returns the dom node associated with a component's React ref.
    
    (normalize-styles! sb styles)
    (noscript & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (noscript "hello")
    (noscript nil "hello")
    
    These two are made equivalent at compile time
    (noscript {:onClick f} "hello")
    (noscript #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (noscript :#the-id.klass.other-klass "hello")
    (noscript :#the-id.klass.other-klass {:onClick f} "hello")
    (object & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (object "hello")
    (object nil "hello")
    
    These two are made equivalent at compile time
    (object {:onClick f} "hello")
    (object #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (object :#the-id.klass.other-klass "hello")
    (object :#the-id.klass.other-klass {:onClick f} "hello")
    (ol & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (ol "hello")
    (ol nil "hello")
    
    These two are made equivalent at compile time
    (ol {:onClick f} "hello")
    (ol #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (ol :#the-id.klass.other-klass "hello")
    (ol :#the-id.klass.other-klass {:onClick f} "hello")
    (optgroup & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (optgroup "hello")
    (optgroup nil "hello")
    
    These two are made equivalent at compile time
    (optgroup {:onClick f} "hello")
    (optgroup #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (optgroup :#the-id.klass.other-klass "hello")
    (optgroup :#the-id.klass.other-klass {:onClick f} "hello")
    (option & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (option "hello")
    (option nil "hello")
    
    These two are made equivalent at compile time
    (option {:onClick f} "hello")
    (option #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (option :#the-id.klass.other-klass "hello")
    (option :#the-id.klass.other-klass {:onClick f} "hello")
    (output & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (output "hello")
    (output nil "hello")
    
    These two are made equivalent at compile time
    (output {:onClick f} "hello")
    (output #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (output :#the-id.klass.other-klass "hello")
    (output :#the-id.klass.other-klass {:onClick f} "hello")
    (p & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (p "hello")
    (p nil "hello")
    
    These two are made equivalent at compile time
    (p {:onClick f} "hello")
    (p #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (p :#the-id.klass.other-klass "hello")
    (p :#the-id.klass.other-klass {:onClick f} "hello")
    (param & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (param "hello")
    (param nil "hello")
    
    These two are made equivalent at compile time
    (param {:onClick f} "hello")
    (param #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (param :#the-id.klass.other-klass "hello")
    (param :#the-id.klass.other-klass {:onClick f} "hello")
    (path & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (path "hello")
    (path nil "hello")
    
    These two are made equivalent at compile time
    (path {:onClick f} "hello")
    (path #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (path :#the-id.klass.other-klass "hello")
    (path :#the-id.klass.other-klass {:onClick f} "hello")
    (pattern & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (pattern "hello")
    (pattern nil "hello")
    
    These two are made equivalent at compile time
    (pattern {:onClick f} "hello")
    (pattern #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (pattern :#the-id.klass.other-klass "hello")
    (pattern :#the-id.klass.other-klass {:onClick f} "hello")
    (picture & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (picture "hello")
    (picture nil "hello")
    
    These two are made equivalent at compile time
    (picture {:onClick f} "hello")
    (picture #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (picture :#the-id.klass.other-klass "hello")
    (picture :#the-id.klass.other-klass {:onClick f} "hello")
    (polygon & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (polygon "hello")
    (polygon nil "hello")
    
    These two are made equivalent at compile time
    (polygon {:onClick f} "hello")
    (polygon #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (polygon :#the-id.klass.other-klass "hello")
    (polygon :#the-id.klass.other-klass {:onClick f} "hello")
    (polyline & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (polyline "hello")
    (polyline nil "hello")
    
    These two are made equivalent at compile time
    (polyline {:onClick f} "hello")
    (polyline #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (polyline :#the-id.klass.other-klass "hello")
    (polyline :#the-id.klass.other-klass {:onClick f} "hello")
    (pre & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (pre "hello")
    (pre nil "hello")
    
    These two are made equivalent at compile time
    (pre {:onClick f} "hello")
    (pre #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (pre :#the-id.klass.other-klass "hello")
    (pre :#the-id.klass.other-klass {:onClick f} "hello")
    (progress & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (progress "hello")
    (progress nil "hello")
    
    These two are made equivalent at compile time
    (progress {:onClick f} "hello")
    (progress #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (progress :#the-id.klass.other-klass "hello")
    (progress :#the-id.klass.other-klass {:onClick f} "hello")
    (q & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (q "hello")
    (q nil "hello")
    
    These two are made equivalent at compile time
    (q {:onClick f} "hello")
    (q #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (q :#the-id.klass.other-klass "hello")
    (q :#the-id.klass.other-klass {:onClick f} "hello")
    (radialGradient & 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")
    Private
    (react-empty-node)
    (react-text-node s)
    HTML text node
    
    (rect & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (rect "hello")
    (rect nil "hello")
    
    These two are made equivalent at compile time
    (rect {:onClick f} "hello")
    (rect #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (rect :#the-id.klass.other-klass "hello")
    (rect :#the-id.klass.other-klass {:onClick f} "hello")
    (render-attr-map! sb tag attrs)
    (render-attribute! sb [key value])
    Private
    (render-component c)
    (render-element! {:keys [tag attrs children]} react-id sb)
    Render a tag vector as a HTML element string.
    
    (render-styles! sb styles)
    (render-to-str x)
    Private
    (render-to-str* x)
    (render-unescaped-html! sb m)
    (render-xml-attribute! sb name value)
    (rp & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (rp "hello")
    (rp nil "hello")
    
    These two are made equivalent at compile time
    (rp {:onClick f} "hello")
    (rp #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (rp :#the-id.klass.other-klass "hello")
    (rp :#the-id.klass.other-klass {:onClick f} "hello")
    (rt & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (rt "hello")
    (rt nil "hello")
    
    These two are made equivalent at compile time
    (rt {:onClick f} "hello")
    (rt #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (rt :#the-id.klass.other-klass "hello")
    (rt :#the-id.klass.other-klass {:onClick f} "hello")
    (ruby & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (ruby "hello")
    (ruby nil "hello")
    
    These two are made equivalent at compile time
    (ruby {:onClick f} "hello")
    (ruby #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (ruby :#the-id.klass.other-klass "hello")
    (ruby :#the-id.klass.other-klass {:onClick f} "hello")
    (s & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (s "hello")
    (s nil "hello")
    
    These two are made equivalent at compile time
    (s {:onClick f} "hello")
    (s #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (s :#the-id.klass.other-klass "hello")
    (s :#the-id.klass.other-klass {:onClick f} "hello")
    (samp & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (samp "hello")
    (samp nil "hello")
    
    These two are made equivalent at compile time
    (samp {:onClick f} "hello")
    (samp #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (samp :#the-id.klass.other-klass "hello")
    (samp :#the-id.klass.other-klass {:onClick f} "hello")
    (script & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (script "hello")
    (script nil "hello")
    
    These two are made equivalent at compile time
    (script {:onClick f} "hello")
    (script #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (script :#the-id.klass.other-klass "hello")
    (script :#the-id.klass.other-klass {:onClick f} "hello")
    (section & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (section "hello")
    (section nil "hello")
    
    These two are made equivalent at compile time
    (section {:onClick f} "hello")
    (section #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (section :#the-id.klass.other-klass "hello")
    (section :#the-id.klass.other-klass {:onClick f} "hello")
    (select & 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")
    (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")
    (source & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (source "hello")
    (source nil "hello")
    
    These two are made equivalent at compile time
    (source {:onClick f} "hello")
    (source #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (source :#the-id.klass.other-klass "hello")
    (source :#the-id.klass.other-klass {:onClick f} "hello")
    (span & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (span "hello")
    (span nil "hello")
    
    These two are made equivalent at compile time
    (span {:onClick f} "hello")
    (span #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (span :#the-id.klass.other-klass "hello")
    (span :#the-id.klass.other-klass {:onClick f} "hello")
    (stop & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (stop "hello")
    (stop nil "hello")
    
    These two are made equivalent at compile time
    (stop {:onClick f} "hello")
    (stop #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (stop :#the-id.klass.other-klass "hello")
    (stop :#the-id.klass.other-klass {:onClick f} "hello")
    (strong & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (strong "hello")
    (strong nil "hello")
    
    These two are made equivalent at compile time
    (strong {:onClick f} "hello")
    (strong #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (strong :#the-id.klass.other-klass "hello")
    (strong :#the-id.klass.other-klass {:onClick f} "hello")
    (style & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (style "hello")
    (style nil "hello")
    
    These two are made equivalent at compile time
    (style {:onClick f} "hello")
    (style #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (style :#the-id.klass.other-klass "hello")
    (style :#the-id.klass.other-klass {:onClick f} "hello")
    (sub & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (sub "hello")
    (sub nil "hello")
    
    These two are made equivalent at compile time
    (sub {:onClick f} "hello")
    (sub #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (sub :#the-id.klass.other-klass "hello")
    (sub :#the-id.klass.other-klass {:onClick f} "hello")
    (summary & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (summary "hello")
    (summary nil "hello")
    
    These two are made equivalent at compile time
    (summary {:onClick f} "hello")
    (summary #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (summary :#the-id.klass.other-klass "hello")
    (summary :#the-id.klass.other-klass {:onClick f} "hello")
    (sup & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (sup "hello")
    (sup nil "hello")
    
    These two are made equivalent at compile time
    (sup {:onClick f} "hello")
    (sup #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (sup :#the-id.klass.other-klass "hello")
    (sup :#the-id.klass.other-klass {:onClick f} "hello")
    (svg & 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")
    (table & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (table "hello")
    (table nil "hello")
    
    These two are made equivalent at compile time
    (table {:onClick f} "hello")
    (table #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (table :#the-id.klass.other-klass "hello")
    (table :#the-id.klass.other-klass {:onClick f} "hello")
    (tbody & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (tbody "hello")
    (tbody nil "hello")
    
    These two are made equivalent at compile time
    (tbody {:onClick f} "hello")
    (tbody #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (tbody :#the-id.klass.other-klass "hello")
    (tbody :#the-id.klass.other-klass {:onClick f} "hello")
    (td & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (td "hello")
    (td nil "hello")
    
    These two are made equivalent at compile time
    (td {:onClick f} "hello")
    (td #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (td :#the-id.klass.other-klass "hello")
    (td :#the-id.klass.other-klass {:onClick f} "hello")
    (text & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (text "hello")
    (text nil "hello")
    
    These two are made equivalent at compile time
    (text {:onClick f} "hello")
    (text #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (text :#the-id.klass.other-klass "hello")
    (text :#the-id.klass.other-klass {:onClick f} "hello")
    (text-node s)
    HTML text node
    
    (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")
    (tfoot & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (tfoot "hello")
    (tfoot nil "hello")
    
    These two are made equivalent at compile time
    (tfoot {:onClick f} "hello")
    (tfoot #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (tfoot :#the-id.klass.other-klass "hello")
    (tfoot :#the-id.klass.other-klass {:onClick f} "hello")
    (th & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (th "hello")
    (th nil "hello")
    
    These two are made equivalent at compile time
    (th {:onClick f} "hello")
    (th #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (th :#the-id.klass.other-klass "hello")
    (th :#the-id.klass.other-klass {:onClick f} "hello")
    (thead & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (thead "hello")
    (thead nil "hello")
    
    These two are made equivalent at compile time
    (thead {:onClick f} "hello")
    (thead #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (thead :#the-id.klass.other-klass "hello")
    (thead :#the-id.klass.other-klass {:onClick f} "hello")
    (time & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (time "hello")
    (time nil "hello")
    
    These two are made equivalent at compile time
    (time {:onClick f} "hello")
    (time #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (time :#the-id.klass.other-klass "hello")
    (time :#the-id.klass.other-klass {:onClick f} "hello")
    (title & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (title "hello")
    (title nil "hello")
    
    These two are made equivalent at compile time
    (title {:onClick f} "hello")
    (title #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (title :#the-id.klass.other-klass "hello")
    (title :#the-id.klass.other-klass {:onClick f} "hello")
    (tr & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (tr "hello")
    (tr nil "hello")
    
    These two are made equivalent at compile time
    (tr {:onClick f} "hello")
    (tr #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (tr :#the-id.klass.other-klass "hello")
    (tr :#the-id.klass.other-klass {:onClick f} "hello")
    (track & 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")
    (tspan & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (tspan "hello")
    (tspan nil "hello")
    
    These two are made equivalent at compile time
    (tspan {:onClick f} "hello")
    (tspan #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (tspan :#the-id.klass.other-klass "hello")
    (tspan :#the-id.klass.other-klass {:onClick f} "hello")
    (u & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (u "hello")
    (u nil "hello")
    
    These two are made equivalent at compile time
    (u {:onClick f} "hello")
    (u #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (u :#the-id.klass.other-klass "hello")
    (u :#the-id.klass.other-klass {:onClick f} "hello")
    (ul & 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")
    (use & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (use "hello")
    (use nil "hello")
    
    These two are made equivalent at compile time
    (use {:onClick f} "hello")
    (use #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (use :#the-id.klass.other-klass "hello")
    (use :#the-id.klass.other-klass {:onClick f} "hello")
    (var & args)
    Returns a server side DOM element. Can be invoked in several ways
    
    These two are made equivalent at compile time
    (var "hello")
    (var nil "hello")
    
    These two are made equivalent at compile time
    (var {:onClick f} "hello")
    (var #js {:onClick f} "hello")
    
    There is also a shorthand for CSS id and class names
    (var :#the-id.klass.other-klass "hello")
    (var :#the-id.klass.other-klass {:onClick f} "hello")
    (video & 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")
    Private
    A list of elements that must be rendered without a closing tag.
    
    (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")