From af3c977ff8b254d0f119f6d4025fa3b6e5c55ab1 Mon Sep 17 00:00:00 2001
From: Will Acton <will@amperity.com>
Date: Tue, 17 Oct 2023 09:11:17 -0700
Subject: [PATCH] Style indent (#148)

* write DOM macros out explicitly

* not working atm

* move style/indent to front of args vector

defnc
fnc
defhook

* switch placement of metadata for $

* add defnc- style/indent :defn

* update DOM macros to have sytle meta in right place and be :defn

* indentation with cider-nrepl 0.40.0
---
 dev/workshop/core.cljs | 328 +++++++++++++---------
 src/helix/core.clj     |  10 +
 src/helix/core.cljs    |   1 +
 src/helix/dom.cljc     | 608 +++++++++++++++++++++++++++++++++++++++--
 4 files changed, 798 insertions(+), 149 deletions(-)

diff --git a/dev/workshop/core.cljs b/dev/workshop/core.cljs
index 0708e2d..4f12c42 100644
--- a/dev/workshop/core.cljs
+++ b/dev/workshop/core.cljs
@@ -11,14 +11,14 @@
 (defnc props-test
   [props]
   (d/div
-   (d/div "props test")
-   (for [[k v] props]
-     (d/div
-      {:key k}
+    (d/div "props test")
+    (for [[k v] props]
       (d/div
-       {:style {:color "red"}}
-       "key: " (str k))
-      (d/div "val: " (pr-str v))))))
+        {:key k}
+        (d/div
+          {:style {:color "red"}}
+          "key: " (str k))
+        (d/div "val: " (pr-str v))))))
 
 
 (dc/defcard props ($ props-test {:class :class
@@ -33,8 +33,8 @@
   [{:keys [foo bar]}]
   (let [count (hooks/use-ref 0)]
     (hooks/use-layout-effect
-     :always
-     (swap! count inc))
+      :always
+      (swap! count inc))
     (pr-str foo bar @count)))
 
 (defnc memoized-key
@@ -42,8 +42,8 @@
   [{:keys [foo bar]}]
   (let [count (hooks/use-ref 0)]
     (hooks/use-layout-effect
-     :always
-     (swap! count inc))
+      :always
+      (swap! count inc))
     (pr-str foo bar @count)))
 
 
@@ -51,18 +51,18 @@
   []
   (let [[render-count force-render] (hooks/use-state 0)]
     (<>
-     (d/div
-      (d/div "Top Render Count:" render-count)
-      (d/button {:on-click #(force-render inc)} "Render"))
-     (d/div
       (d/div
-       "memoized "
-       ($ memoized
-          {:foo (str "foo" (quot render-count 5)) :bar "bar"}))
+        (d/div "Top Render Count:" render-count)
+        (d/button {:on-click #(force-render inc)} "Render"))
       (d/div
-       "memoized-key "
-       ($ memoized-key
-          {:foo (str "foo" (quot render-count 5)) :bar "bar"}))))))
+        (d/div
+          "memoized "
+          ($ memoized
+             {:foo (str "foo" (quot render-count 5)) :bar "bar"}))
+        (d/div
+          "memoized-key "
+          ($ memoized-key
+             {:foo (str "foo" (quot render-count 5)) :bar "bar"}))))))
 
 
 (dc/defcard memoized-props
@@ -78,9 +78,9 @@
   []
   (let [[{:keys [name]} set-state] (hooks/use-state {:name "asdf"})]
     (d/div
-     (d/input {:value name
-               :on-change #(set-state assoc :name (.. % -target -value))})
-     ($ subcomponent {:name name}))))
+      (d/input {:value name
+                :on-change #(set-state assoc :name (.. % -target -value))})
+      ($ subcomponent {:name name}))))
 
 
 (dc/defcard use-state
@@ -105,31 +105,31 @@
                                                   :every-third/auto 0})
         threes (quot count 3)]
     (hooks/use-effect
-     :always
-     (swap! renders inc))
+      :always
+      (swap! renders inc))
     (hooks/use-effect
-     [count]
-     (set-fx-state assoc :every count))
+      [count]
+      (set-fx-state assoc :every count))
     (hooks/use-effect
-     [threes]
-     (set-fx-state assoc :every-third threes))
+      [threes]
+      (set-fx-state assoc :every-third threes))
     (hooks/use-effect
-     :auto-deps
-     (set-fx-state assoc :every/auto count))
+      :auto-deps
+      (set-fx-state assoc :every/auto count))
     (hooks/use-effect
-     :auto-deps
-     (set-fx-state assoc :every-third/auto threes))
+      :auto-deps
+      (set-fx-state assoc :every-third/auto threes))
 
     (d/div
-     (d/div "Count: " count)
-     (d/button {:on-click #(set-count inc)} "inc")
-     (d/div
-      (d/div "renders:")
-      ($ display-range {:end @renders :color "red"}))
-     (for [[k v] fx-state]
-       (d/div {:key (str k)}
-        (d/div (str k))
-        ($ display-range {:end v}))))))
+      (d/div "Count: " count)
+      (d/button {:on-click #(set-count inc)} "inc")
+      (d/div
+        (d/div "renders:")
+        ($ display-range {:end @renders :color "red"}))
+      (for [[k v] fx-state]
+        (d/div {:key (str k)}
+          (d/div (str k))
+          ($ display-range {:end v}))))))
 
 
 (helix/defcomponent error-boundary
@@ -155,11 +155,11 @@
   [{:keys [begin end]
     :or {begin 0}}]
   (<>
-   (d/div (str "numbers " (or begin 0) "-" (dec end) ":"))
-   (d/ul
-    (for [n (range begin end)]
-      (d/li {:key n} n)))
-   (d/div "ur welcome")))
+    (d/div (str "numbers " (or begin 0) "-" (dec end) ":"))
+    (d/ul
+      (for [n (range begin end)]
+        (d/li {:key n} n)))
+    (d/div "ur welcome")))
 
 
 (dc/defcard lazy
@@ -182,7 +182,7 @@
   [{:keys [children] :as props}]
   (d/div {:style {:display "flex"
                   :justify-content "space-between"}}
-   children))
+    children))
 
 (dc/defcard children
   ($ children-test (d/div "foo") (d/div "bar")))
@@ -217,10 +217,10 @@
         first-foobar (hooks/use-ref foobar)
         [count set-count] (hooks/use-state 0)]
     (d/div
-     (str (identical? foobar @first-foobar))
-     (d/br)
-     count
-     (d/button {:on-click #(set-count inc)} "render"))))
+      (str (identical? foobar @first-foobar))
+      (d/br)
+      count
+      (d/button {:on-click #(set-count inc)} "render"))))
 
 
 (dc/defcard use-memo-metadata-card
@@ -242,8 +242,8 @@
     (.focus @(.-myRef this)))
   (render [^js this props state]
     (d/div
-     (d/input {:type "text" :ref (.-myRef this)})
-     (d/input {:type "button" :value "Focus" :onClick (.-focusInput this)}))))
+      (d/input {:type "text" :ref (.-myRef this)})
+      (d/input {:type "button" :value "Focus" :onClick (.-focusInput this)}))))
 
 (dc/defcard ref ($ RefTest))
 
@@ -263,7 +263,7 @@
           (reset! mounted? true)))
     (prn :render)
     (d/div "deps: " (when state
-                     (pr-str state)))))
+                      (pr-str state)))))
 
 (dc/defcard custom-effect-test-card
   (<> ($ custom-effect-test {:deps :always})))
@@ -304,15 +304,15 @@
                                        :subscribe subscribe-atom})
         [changes set-changes] (hooks/use-state 0)]
     (hooks/use-effect
-     [value]
-     (set-changes inc))
+      [value]
+      (set-changes inc))
     (d/div
-     "Value: " (:foo value) " "
-     (d/button {:on-click #(do
-                             (swap! sub-atom update :foo inc)
-                             (swap! sub-atom into {}))} "+")
-     (d/div
-      "Changes: " changes))))
+      "Value: " (:foo value) " "
+      (d/button {:on-click #(do
+                              (swap! sub-atom update :foo inc)
+                              (swap! sub-atom into {}))} "+")
+      (d/div
+        "Changes: " changes))))
 
 
 (dc/defcard use-subscription
@@ -326,15 +326,15 @@
 (defnc helix-children-benchmark
   [{:keys [children] :as props}]
   (d/div {:style {:display "flex"
-                   :justify-content "space-between"}}
-          children))
+                  :justify-content "space-between"}}
+    children))
 
 (defnc helix-children-interpret-props-benchmark
   [{:keys [children] :as props}]
   (let [props {:style {:display "flex"
                        :justify-content "space-between"}}]
-  (d/div {& props}
-         children)))
+    (d/div {& props}
+      children)))
 
 
 (defn react-children-benchmark
@@ -348,68 +348,134 @@
 
 
 #_(defnc simple-benchmark-component []
-  (let [[re-render set-state] (hooks/use-state 0)
-        force-render #(set-state inc)
-        [iterations set-iterations] (hooks/use-state 10000)
-
-        react-time (hooks/use-memo
-                    [re-render]
-                    (with-out-str
-                      (simple-benchmark
-                       []
-                       (rds/renderToString
-                        (helix/jsxs react-children-benchmark
-                                    #js {:foo "bar"
-                                         :children #js [(helix/jsx "div" #js {:style #js {:backgroundColor "green"}
-                                                                              :children "foo"})
-                                                        (helix/jsx "div" #js {:children "bar"})]}))
-                       iterations)))
-
-        helix-time (hooks/use-memo
-                    [re-render]
-                    (with-out-str
-                      (simple-benchmark
-                       []
-                       (rds/renderToString
-                        ($ helix-children-benchmark
-                           {:foo "bar"}
-                           (d/div {:style {:background-color "green"}} "foo")
-                           (d/div "bar")))
-                       iterations)))
-
-        helix-interpret-props-time (hooks/use-memo
-                                    [re-render]
-                                    (with-out-str
-                                      (simple-benchmark
-                                       []
-                                       (rds/renderToString
-                                        ($ helix-children-interpret-props-benchmark
-                                           {:foo "bar"}
-                                           (d/div {:style {:background-color "green"}} "foo")
-                                           (d/div "bar")))
-                                       iterations)))]
-    (<>
-     (d/div
-      (d/input {:value iterations
-                :on-change #(set-iterations
-                             (-> %
-                                 .-target
-                                 .-value
-                                 (js/parseInt 10)))
-                :type "number"})
-      (d/button {:on-click force-render} "Re-run"))
-     (d/div
-      {:style {:padding "5px"}}
-      (d/code
-       react-time))
-     (d/div
-      {:style {:padding "5px"}}
-      (d/code
-       helix-time))
-     (d/div
-      {:style {:padding "5px"}}
-      (d/code
-       helix-interpret-props-time)))))
+    (let [[re-render set-state] (hooks/use-state 0)
+          force-render #(set-state inc)
+          [iterations set-iterations] (hooks/use-state 10000)
+
+          react-time (hooks/use-memo
+                       [re-render]
+                       (with-out-str
+                         (simple-benchmark
+                          []
+                          (rds/renderToString
+                           (helix/jsxs react-children-benchmark
+                                       #js {:foo "bar"
+                                            :children #js [(helix/jsx "div" #js {:style #js {:backgroundColor "green"}
+                                                                                 :children "foo"})
+                                                           (helix/jsx "div" #js {:children "bar"})]}))
+                          iterations)))
+
+          helix-time (hooks/use-memo
+                       [re-render]
+                       (with-out-str
+                         (simple-benchmark
+                          []
+                          (rds/renderToString
+                           ($ helix-children-benchmark
+                              {:foo "bar"}
+                              (d/div {:style {:background-color "green"}} "foo")
+                              (d/div "bar")))
+                          iterations)))
+
+          helix-interpret-props-time (hooks/use-memo
+                                       [re-render]
+                                       (with-out-str
+                                         (simple-benchmark
+                                          []
+                                          (rds/renderToString
+                                           ($ helix-children-interpret-props-benchmark
+                                              {:foo "bar"}
+                                              (d/div {:style {:background-color "green"}} "foo")
+                                              (d/div "bar")))
+                                          iterations)))]
+      (<>
+        (d/div
+          (d/input {:value iterations
+                    :on-change #(set-iterations
+                                 (-> %
+                                     .-target
+                                     .-value
+                                     (js/parseInt 10)))
+                    :type "number"})
+          (d/button {:on-click force-render} "Re-run"))
+        (d/div
+          {:style {:padding "5px"}}
+          (d/code
+            react-time))
+        (d/div
+          {:style {:padding "5px"}}
+          (d/code
+            helix-time))
+        (d/div
+          {:style {:padding "5px"}}
+          (d/code
+            helix-interpret-props-time)))))
 
 #_(dc/defcard simple-benchmark
-  ($ simple-benchmark-component))
+    ($ simple-benchmark-component))
+
+
+
+(helix/fnc []
+  "bar")
+
+;; desired:
+;;
+;; (helix/fnc []
+;;   "bar")
+
+
+(defnc foo []
+  "bar")
+
+;; desired:
+;;
+;; (defnc foo []
+;;   "bar")
+
+
+(helix/defhook use-foo []
+  "bar")
+
+;; desired:
+;;
+;; (helix/defhook foo []
+;;   "bar")
+
+
+($ "div"
+   ($ "div"))
+
+;; desired:
+;;
+;; ($ "div"
+;;    ($ "div"))
+
+
+($ "div" {}
+   ($ "div")
+   ($ "div"))
+
+;; desired:
+;;
+;; ($ "div" {}
+;;    ($ "div")
+;;    ($ "div"))
+
+
+(d/div
+  (d/div))
+
+;; desired:
+;;
+;; (d/div
+;;   (d/div))
+
+
+(d/div {}
+  (d/div))
+
+;; desired:
+;;
+;; (d/div {}
+;;   (d/div))
diff --git a/src/helix/core.clj b/src/helix/core.clj
index 974edb8..6acb74d 100644
--- a/src/helix/core.clj
+++ b/src/helix/core.clj
@@ -34,6 +34,7 @@
        {:static \"prop\"
         & dynamic-props}))
   "
+  {:style/indent 0}
   [type & args]
   (when (and (symbol? (first args))
              (= (hana/inferred-type &env (first args))
@@ -149,6 +150,7 @@
 
   Some feature flags only pertain to named components, i.e. Fast Refresh and
   factory functions, and thus can not be used with `fnc`."
+  {:style/indent :defn}
   [& body]
   (let [[display-name props-bindings body] (if (symbol? (first body))
                                              [(first body) (second body)
@@ -216,6 +218,7 @@
    - `:helix/features` - a map of feature flags to enable. See \"Experimental\" docs.
 
   `body` should return a React Element."
+  {:style/indent :defn}
   [display-name & form-body]
   (let [[docstring form-body] (if (string? (first form-body))
                                 [(first form-body) (rest form-body)]
@@ -300,6 +303,7 @@
 
 (defmacro defnc-
   "Same as defnc, yielding a non-public def"
+  {:style/indent :defn}
   [display-name & rest]
   (list* `defnc (vary-meta display-name assoc :private true) rest))
 
@@ -313,6 +317,7 @@
   "Defines a new custom hook function.
   Checks for invalid usage of other hooks in the body, and other helix
   features."
+  {:style/indent :defn}
   [sym & body]
   (let [[docstring params body] (if (string? (first body))
                                   [(first body) (second body) (drop 2 body)]
@@ -434,4 +439,9 @@
   ;;      "bar"
   ;;      (clojure.core/fn bar [this] asdf))
   ;;     (cljs.core/js-obj "greeting" "asdf" "baz" (clojure.core/fn baz [] 123)))
+
+  ($ "arst"
+     ($ "oieno")
+     ($ "fqfw")
+     ($ "123"))
   )
diff --git a/src/helix/core.cljs b/src/helix/core.cljs
index 07b7ade..a0d49cf 100644
--- a/src/helix/core.cljs
+++ b/src/helix/core.cljs
@@ -52,6 +52,7 @@
      {:style {:color \"green\"}}
      \"child2\" ))
   ```"
+  {:style/indent 0}
   [type & args]
   (let [?p (first args)
         ?c (rest args)
diff --git a/src/helix/dom.cljc b/src/helix/dom.cljc
index 0ace6b4..70a7277 100644
--- a/src/helix/dom.cljc
+++ b/src/helix/dom.cljc
@@ -6,18 +6,18 @@
    [helix.impl.props :as impl.props])
   #?(:cljs (:require-macros [helix.dom])))
 
-(declare
- input textarea option select a abbr address area article aside audio b base bdi
- bdo big blockquote body br button canvas caption cite code col colgroup data datalist
- dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form
- h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img ins kbd keygen label legend
- li link main map mark menu menuitem meta meter nav noscript object ol optgroup output
- p param picture pre progress q rp rt ruby s samp script section small source span 
- strong style sub summary sup table tbody td tfoot th thead time title tr track u ul var
- video wbr circle clipPath ellipse g line mask path pattern polyline rect svg text defs
- linearGradient polygon radialGradient stop tspan)
+;; (declare
+;;  input textarea option select a abbr address area article aside audio b base bdi
+;;  bdo big blockquote body br button canvas caption cite code col colgroup data datalist
+;;  dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form
+;;  h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img ins kbd keygen label legend
+;;  li link main map mark menu menuitem meta meter nav noscript object ol optgroup output
+;;  p param picture pre progress q rp rt ruby s samp script section small source span
+;;  strong style sub summary sup table tbody td tfoot th thead time title tr track u ul var
+;;  video wbr circle clipPath ellipse g line mask path pattern polyline rect svg text defs
+;;  linearGradient polygon radialGradient stop tspan)
 
-(def tags
+#_(def tags
   '[input textarea option select
 
     a
@@ -182,13 +182,585 @@
 
 #?(:clj (defn gen-tag
           [tag]
-          `(defmacro ~tag [& args#]
+          `(defmacro ~tag
+             {:style/indent :defn}
+             [& args#]
              `($d ~(str '~tag) ~@args#))))
 
-#?(:clj (defmacro gen-tags
-          []
-          `(do
-             ~@(for [tag tags]
-                 (gen-tag tag)))))
+;; #?(:clj (defmacro gen-tags
+;;           []
+;;           `(do
+;;              ~@(for [tag tags]
+;;                  (gen-tag tag)))))
 
-#?(:clj (gen-tags))
+;; #?(:clj (gen-tags))
+
+
+;;
+;; Autogenerated code below
+;;
+
+(defmacro input
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'input)) args)))
+(defmacro textarea
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'textarea)) args)))
+(defmacro option
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'option)) args)))
+(defmacro select
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'select)) args)))
+(defmacro a
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'a)) args)))
+(defmacro abbr
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'abbr)) args)))
+(defmacro address
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'address)) args)))
+(defmacro area
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'area)) args)))
+(defmacro article
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'article)) args)))
+(defmacro aside
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'aside)) args)))
+(defmacro audio
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'audio)) args)))
+(defmacro b
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'b)) args)))
+(defmacro base
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'base)) args)))
+(defmacro bdi
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'bdi)) args)))
+(defmacro bdo
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'bdo)) args)))
+(defmacro big
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'big)) args)))
+(defmacro blockquote
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat
+    (list `$d)
+    (list (str 'blockquote))
+    args)))
+(defmacro body
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'body)) args)))
+(defmacro br
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'br)) args)))
+(defmacro button
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'button)) args)))
+(defmacro canvas
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'canvas)) args)))
+(defmacro caption
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'caption)) args)))
+(defmacro cite
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'cite)) args)))
+(defmacro code
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'code)) args)))
+(defmacro col
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'col)) args)))
+(defmacro colgroup
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'colgroup)) args)))
+(defmacro data
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'data)) args)))
+(defmacro datalist
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'datalist)) args)))
+(defmacro dd
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'dd)) args)))
+(defmacro del
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'del)) args)))
+(defmacro details
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'details)) args)))
+(defmacro dfn
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'dfn)) args)))
+(defmacro dialog
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'dialog)) args)))
+(defmacro div
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'div)) args)))
+(defmacro dl
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'dl)) args)))
+(defmacro dt
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'dt)) args)))
+(defmacro em
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'em)) args)))
+(defmacro embed
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'embed)) args)))
+(defmacro fieldset
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'fieldset)) args)))
+(defmacro figcaption
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat
+    (list `$d)
+    (list (str 'figcaption))
+    args)))
+(defmacro figure
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'figure)) args)))
+(defmacro footer
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'footer)) args)))
+(defmacro form
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'form)) args)))
+(defmacro h1
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'h1)) args)))
+(defmacro h2
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'h2)) args)))
+(defmacro h3
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'h3)) args)))
+(defmacro h4
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'h4)) args)))
+(defmacro h5
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'h5)) args)))
+(defmacro h6
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'h6)) args)))
+(defmacro head
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'head)) args)))
+(defmacro header
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'header)) args)))
+(defmacro hgroup
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'hgroup)) args)))
+(defmacro hr
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'hr)) args)))
+(defmacro html
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'html)) args)))
+(defmacro i
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'i)) args)))
+(defmacro iframe
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'iframe)) args)))
+(defmacro img
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'img)) args)))
+(defmacro ins
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'ins)) args)))
+(defmacro kbd
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'kbd)) args)))
+(defmacro keygen
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'keygen)) args)))
+(defmacro label
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'label)) args)))
+(defmacro legend
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'legend)) args)))
+(defmacro li
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'li)) args)))
+(defmacro link
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'link)) args)))
+(defmacro main
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'main)) args)))
+(defmacro map
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'map)) args)))
+(defmacro mark
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'mark)) args)))
+(defmacro menu
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'menu)) args)))
+(defmacro menuitem
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'menuitem)) args)))
+(defmacro meta
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'meta)) args)))
+(defmacro meter
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'meter)) args)))
+(defmacro nav
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'nav)) args)))
+(defmacro noscript
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'noscript)) args)))
+(defmacro object
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'object)) args)))
+(defmacro ol
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'ol)) args)))
+(defmacro optgroup
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'optgroup)) args)))
+(defmacro output
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'output)) args)))
+(defmacro p
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'p)) args)))
+(defmacro param
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'param)) args)))
+(defmacro picture
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'picture)) args)))
+(defmacro pre
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'pre)) args)))
+(defmacro progress
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'progress)) args)))
+(defmacro q
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'q)) args)))
+(defmacro rp
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'rp)) args)))
+(defmacro rt
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'rt)) args)))
+(defmacro ruby
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'ruby)) args)))
+(defmacro s
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 's)) args)))
+(defmacro samp
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'samp)) args)))
+(defmacro script
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'script)) args)))
+(defmacro section
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'section)) args)))
+(defmacro small
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'small)) args)))
+(defmacro source
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'source)) args)))
+(defmacro span
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'span)) args)))
+(defmacro strong
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'strong)) args)))
+(defmacro style
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'style)) args)))
+(defmacro sub
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'sub)) args)))
+(defmacro summary
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'summary)) args)))
+(defmacro sup
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'sup)) args)))
+(defmacro table
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'table)) args)))
+(defmacro tbody
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'tbody)) args)))
+(defmacro td
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'td)) args)))
+(defmacro tfoot
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'tfoot)) args)))
+(defmacro th
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'th)) args)))
+(defmacro thead
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'thead)) args)))
+(defmacro time
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'time)) args)))
+(defmacro title
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'title)) args)))
+(defmacro tr
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'tr)) args)))
+(defmacro track
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'track)) args)))
+(defmacro u
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'u)) args)))
+(defmacro ul
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'ul)) args)))
+(defmacro var
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'var)) args)))
+(defmacro video
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'video)) args)))
+(defmacro wbr
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'wbr)) args)))
+(defmacro circle
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'circle)) args)))
+(defmacro clipPath
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'clipPath)) args)))
+(defmacro ellipse
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'ellipse)) args)))
+(defmacro g
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'g)) args)))
+(defmacro line
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'line)) args)))
+(defmacro marker
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'marker)) args)))
+(defmacro mask
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'mask)) args)))
+(defmacro path
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'path)) args)))
+(defmacro pattern
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'pattern)) args)))
+(defmacro polyline
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'polyline)) args)))
+(defmacro rect
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'rect)) args)))
+(defmacro svg
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'svg)) args)))
+(defmacro text
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'text)) args)))
+(defmacro defs
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'defs)) args)))
+(defmacro linearGradient
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat
+    (list `$d)
+    (list (str 'linearGradient))
+    args)))
+(defmacro polygon
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat (list `$d) (list (str 'polygon)) args)))
+(defmacro radialGradient
+  #:style{:indent :defn}
+  [& args]
+  (seq
+   (concat
+    (list `$d)
+    (list (str 'radialGradient))
+    args)))
+(defmacro stop
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'stop)) args)))
+(defmacro tspan
+  #:style{:indent :defn}
+  [& args]
+  (seq (concat (list `$d) (list (str 'tspan)) args)))