 
   Behaves like a Reagent atom but focuses updates and derefs to
   the specified path within the wrapped Reagent atom. e.g.,
-    (let [c (cursor ra [:nested :content])]
-      ... @c ;; equivalent to (get-in @ra [:nested :content])
-      ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
-      ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
-      )
+
+  ```cljs
+  (let [c (cursor ra [:nested :content])]
+    ... @c ;; equivalent to (get-in @ra [:nested :content])
+    ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
+    ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
+    )
+  ```
 
   The first parameter can also be a function, that should look
   something like this:
 
-    (defn set-get
-      ([k] (get-in @state k))
-      ([k v] (swap! state assoc-in k v)))
+  ```cljs
+  (defn set-get
+    ([k] (get-in @state k))
+    ([k v] (swap! state assoc-in k v)))
+  ```
 
   The function will be called with one argument – the path passed to
   cursor – when the cursor is deref'ed, and two arguments (path and

  that any Reagent hiccup forms must be processed with as-element. For example
  like this:

    (r/create-element \"div\" #js{:className \"foo\"}
       \"Hi \" (r/as-element [:strong \"world!\"])

  which is equivalent to

    [:div.foo \"Hi\" [:strong \"world!\"]]"
  ([type]
   (create-element type nil))
  ([type props]

  Reagent atoms (or track, etc), the value will be updated whenever
  the atom changes.

  In other words, `@(track foo bar)` will produce the same result
  as `(foo bar)`, but foo will only be called again when the atoms it
  depends on changes, and will only trigger updates of components when
  its result changes.

