My current Chlorine config file

README.md

To make this code above work, you'll have to add some dependencies on ~/.atom/chlorine - they are used mostly for the custom tags here:

In file ~/.atom/chlorine/nomno.js 
module.exports = require('nomnoml');

In file ~/.atom/chlorine/hpcc-js.js 
const hpcc = require('@hpcc-js/wasm')
hpcc.wasmFolder(__dirname + "/node_modules/@hpcc-js/wasm/dist")
module.exports = hpcc

In file ~/.atom/chlorine/nomno.js 
module.exports = require('nomnoml');

In file ~/.atom/chlorine/plant.js 
module.exports = require('plantuml');

In file ~/.atom/chlorine/viz.js 
module.exports = require('d3-graphviz').graphviz

Then add package-lock.json and run npm install

chlorine-config.cljs

(defn- wrap-in-tap [code]
  (str "(let [value " code
       "      rr      (try (resolve 'requiring-resolve) (catch Throwable _))]"
       "  (if-let [rs (try (rr 'cognitect.rebl/submit) (catch Throwable _))]"
       "    (rs '" code " value)"
       "    (tap> value))"
       "  value)"))

(defn tap-top-block []
  (p/let [block (editor/get-top-block)]
    (when (seq (:text block))
      (-> block
          (update :text wrap-in-tap)
          (editor/eval-and-render)))))

(defn tap-block []
  (p/let [block (editor/get-block)]
    (when (seq (:text block))
      (-> block
          (update :text wrap-in-tap)
          (editor/eval-and-render)))))

(defn tap-selection []
  (p/let [block (editor/get-selection)]
    (when (seq (:text block))
      (-> block
          (update :text wrap-in-tap)
          (editor/eval-and-render)))))

(defn tap-def-var []
  (p/let [block (editor/get-selection)]
    (when (seq (:text block))
      (-> block
          (update :text
                  #(str "(def " % ")"))
          (update :text wrap-in-tap)
          (editor/eval-and-render)))))

(defn tap-var []
  (p/let [block (editor/get-var)]
    (when (seq (:text block))
      (-> block
          (update :text #(str "#'" %))
          (update :text wrap-in-tap)
          (editor/eval-and-render)))))

(defn tap-ns []
  (p/let [block (editor/get-namespace)
          here  (editor/get-selection)]
    (when (seq (:text block))
      (-> block
          (update :text #(str "(find-ns '" % ")"))
          (update :text wrap-in-tap)
          (assoc :range (:range here))
          (editor/eval-and-render)))))

(defn tap-remove-ns []
  (p/let [block (editor/get-namespace)
          here  (editor/get-selection)]
    (when (seq (:text block))
      (editor/run-callback
       :notify
       {:type :info :title "Removing..." :message (:text block)})
      (-> block
          (update :text #(str "(remove-ns '" % ")"))
          (update :text wrap-in-tap)
          (assoc :range (:range here))
          (editor/eval-and-render)))))

(defn tap-reload-all-ns []
  (p/let [block (editor/get-namespace)
          here  (editor/get-selection)]
    (when (seq (:text block))
      (editor/run-callback
       :notify
       {:type :info :title "Reloading all..." :message (:text block)})
      (p/let [res (editor/eval-and-render
                    (-> block
                        (update :text #(str "(require '" % " :reload-all)"))
                        (update :text wrap-in-tap)
                        (assoc :range (:range here))))]
        (editor/run-callback
         :notify
         {:type (if (:error res) :warn :info)
          :title (if (:error res)
                   "Reload failed for..."
                   "Reload succeeded!")
          :message (:text block)})))))

(defn- format-test-result [{:keys [test pass fail error]}]
  (str "Ran " test " test"
       (when-not (= 1 test) "s")
       (when-not (zero? pass)
         (str ", " pass " assertion"
              (when-not (= 1 pass) "s")
              " passed"))
       (when-not (zero? fail)
         (str ", " fail " failed"))
       (when-not (zero? error)
         (str ", " error " errored"))
       "."))

(defn tap-run-side-tests []
  (p/let [block (editor/get-namespace)
          here  (editor/get-selection)]
    (when (seq (:text block))
      (p/let [res (editor/eval-and-render
                    (-> block
                        (update :text (fn [s] (str "
                          (some #(try
                                   (let [nt (symbol (str \"" s "\" \"-\" %))]
                                     (require nt)
                                     (clojure.test/run-tests nt))
                                  (catch Throwable _))
                                [\"test\" \"expectations\"])")))
                        (update :text wrap-in-tap)
                        (assoc :range (:range here))))]
        (editor/run-callback
         :notify
         {:type (if (:error res) :warn :info)
          :title (if (:error res)
                   "Failed to run tests for..."
                   "Tests completed!")
          :message (if (:error res) (:text block) (format-test-result (:result res)))})))))

(defn tap-doc-var []
  (p/let [block (editor/get-var)]
    (when (seq (:text block))
      (-> block
          (update :text
                  #(str
                    "(java.net.URL."
                    " (str \"http://clojuredocs.org/\""
                    " (-> (str (symbol #'" % "))"
                    ;; clean up ? ! &
                    "  (clojure.string/replace \"?\" \"%3f\")"
                    "  (clojure.string/replace \"!\" \"%21\")"
                    "  (clojure.string/replace \"&\" \"%26\")"
                    ")))"))
          (update :text wrap-in-tap)
          (editor/eval-and-render)))))

(defn tap-javadoc []
  (p/let [block (editor/get-selection)
          block (if (< 1 (count (:text block))) block (editor/get-var))]
      (when (seq (:text block))
        (-> block
            (update :text
                    #(str
                      "(let [c-o-o " %
                      " ^Class c (if (instance? Class c-o-o) c-o-o (class c-o-o))] "
                      " (java.net.URL. "
                      "  (clojure.string/replace"
                      "   ((requiring-resolve 'clojure.java.javadoc/javadoc-url)"
                      "    (.getName c))"
                      ;; strip inner class
                      "   #\"\\$[a-zA-Z0-9_]+\" \"\""
                      ")))"))
            (update :text wrap-in-tap)
            (editor/eval-and-render)))))

(defn explain-schema []
  (p/let [editor-data (editor/get-var)]
    (when editor-data
      (-> editor-data
          (update :text #(str "(if (satisfies? schema.core/Schema " % ") "
                                  "(schema.core/explain " % ")"
                                  "(or #?(:cljs nil :default (:schema (meta (ns-resolve *ns* '" % "))))"
                                       "\"Is not a schema\"))"))
          (editor/eval-and-render)))))

(defn fqn-of-var []
  (p/let [editor-data (editor/get-var)]
    (-> editor-data
        (update :text #(str "`" %))
        editor/eval-and-render)))

(defn notify []
  (p/let [res (editor/run-callback
               :prompt {:title "What do you want?"
                        :message (str "How do you want to evaluate "
                                      "your code?")
                        :arguments [{:key :top :value "Top Block"}
                                    {:key :block :value "Block"}
                                    {:key :var :value "Current Var"}]})
          {:keys [text]} (case res
                           :top (editor/get-top-block)
                           :block (editor/get-block)
                           :var (editor/get-var))]
    (editor/run-callback :notify {:type :info :title text})))

(defn example-notify []
  (let [res '(fn [_] (editor/run-callback
                      :notify {:type :info :title "LOL!"}))]
    (editor/eval-interactive {:range [[0 0] [0 0]]
                              :text (str "{:html [:a {:on-click '"
                                         res
                                         "} \"Something\"]}")})))

(defn dependencies-of-block []
  (p/let [{curr-ns :text} (editor/get-namespace)
          {curr-txt :text curr-range :range} (editor/get-top-block)
          code (str "(->> `" curr-txt
                     "      (tree-seq coll? seq)"
                     "      rest"
                     "      (filter #(not (coll? %)))"
                     "      (filter symbol?)"
                     "      (filter namespace)"
                     "      (remove #(#{" (pr-str curr-ns)
                     "                  \"clojure.core\""
                     "                  \"cljs.core\"}"
                     "                 (namespace %)))"
                     "      (remove #(clojure.string/starts-with? (str %) \".\"))"
                     "      (group-by namespace)"
                     "      (mapcat (fn [[ns names]] (map #(vector ns (str (name %))) names)))"
                     "      vec)")
          code (str "{:html [:div.pre [:p/diag (doto " code " prn)]]}")]
    (editor/eval-interactive {:text code :range curr-range})))

(defn- counter [c]
  (let [s (r/atom 0)
        f (fn []
            [:div "Clicked " [:button {:on-click (fn [_]
                                                   (swap! s inc))}
                              @s]
             " time(s) - " c])]
    [f]))
(render/register-reagent :p/counter counter)

(defn hello [ & args]
  (doto (render/create-tag "div")
        (render/set-text 10)))

(render/register-tag :p/hello hello)

(def ^:private nomno (render/js-require "./chlorine/nomno"))
(defn- parse-nomno [data-struct]
  (if (empty? data-struct)
    "[*]"
    (reduce (fn [acc [k v]]
              (str acc "[" k "]->[" v "]\n"))
            "#direction: right\n"
            data-struct)))

(defn- diag [txt]
  (doto (render/create-tag "div")
   (render/set-html ((aget nomno "renderSvg")
                     (cond-> txt (not (string? txt)) parse-nomno)))))
(render/register-tag :p/diag diag)

(defn as-diagram []
  (p/let [res (editor/get-top-block)]
    (editor/eval-interactive
     (update res :text #(str "{:html [:div [:p/diag "
                             %
                             "]]}")))))

(def ^:private plant-uml (render/js-require "chlorine/plant"))
(defn- plant [txt]
  (p/let [div (render/create-tag "div")
          svg (plant-uml txt)]
    (doto (render/create-tag "div")
          (render/set-html svg))))
(render/register-tag :plant/uml plant)

(declare parse-elem)
(defn- parse-list [prev acc [fst & r]]
  (case fst
    def (parse-elem prev acc (second r))
    fn* (parse-elem prev acc (cons 'do (->> r first rest)))
    if (let [after-conds (gensym)
             [c t f] r]
         (swap! acc assoc after-conds {:type :connector :next []})
         (let [if-sym (parse-elem prev acc c)
               true-sym (parse-elem if-sym acc t)
               false-sym (some->> f (parse-elem if-sym acc))]
           (swap! acc #(cond-> (update % true-sym assoc :connector "Y" :next [after-conds])

                               false-sym
                               (update false-sym assoc :connector "N" :next [after-conds])

                               (nil? false-sym)
                               (update-in [if-sym :next] conj after-conds)))
           (swap! acc update if-sym assoc :type :question)
           after-conds))
    do (let [actual (atom prev)]
         (doseq [elem r
                 :let [sym (parse-elem @actual acc elem)]]
           (reset! actual sym))
         @actual)
    (let [elem (cons fst r)
          sym (gensym)]
      (swap! acc assoc sym {:text (pr-str elem) :next []})
      (swap! acc update-in [prev :next] conj sym)
      sym)))

(defn- parse-elem [prev acc elem]
  ; (prn :PARSING (seq? elem) elem)
  (if (seq? elem)
    (parse-list prev acc elem)
    (let [sym (gensym)]
      (swap! acc assoc sym {:text (pr-str elem) :next []})
      (swap! acc update-in [prev :next] conj sym)
      sym)))

(defn- normalize-tags [tags]
  (let [elem-name (fn [{:keys [type text connector]}]
                    (str "["
                         (case type
                           :connector "<conn> '"
                           :start "<st> s"
                           :end "<ed> e"
                           :question "<question> "
                           "")
                         text
                         "]"))
        seed (str "#.question: visual=rhomb\n"
                  "#.conn: visual=none\n"
                  "#.st: visual=start\n"
                  "#.ed: visual=end\n\n")]
    (reduce (fn [sofar elem]
              (->> (:next elem)
                   (reduce (fn [sofar next-key]
                             (let [next-elem (get tags next-key)]
                               (str sofar "\n"
                                    (elem-name elem)
                                    "->" (:connector next-elem)
                                    (elem-name next-elem))))
                           sofar)))
      seed (vals tags))))

(defn shadow-runtimes []
  (p/let [data (editor/get-selection)
          {:keys [result]} (editor/eval {:text (pr-str {:op :request-clients,
                                                        :query [:eq :type :runtime]})
                                         :shadow-command true
                                         :filename "eval_user.cljs"
                                         :range (:range data)})
          clients (->> (:clients result)
                       (map :client-info)
                       (mapv #(select-keys % [:user-agent :desc :build-id])))]

    (editor/eval-interactive
     {:text (pr-str {:html [:div.rows
                            [:div.title "Shadow Runtimes"]
                            [:<>
                             ''(for [{:keys [desc build-id user-agent]} ?state]
                                 [:ul
                                  [:li
                                   (or desc user-agent)] " " (pr-str build-id)])]]
                     :state clients})
      :range (:range data)})))

(def last-command (atom {:text ""
                         :namespace ""}))

(defn eval-and-save []
  (p/let [txt (editor/get-block)
          namespace (editor/get-namespace)]
    (reset! last-command {:text (:text txt)
                          :namespace (:text namespace)})
    (editor/eval-and-render txt)))

(defn repeat-last-eval []
  (p/let [{:keys [range]} (editor/get-selection)]
    (editor/eval-and-render {:range range
                             :text (:text @last-command)
                             :namespace (:namespace @last-command)})))

(def old-fail-blob
  '(defmethod clojure.test/report :fail [m]
     (clojure.test/with-test-out
       (clojure.test/inc-report-counter :fail)
       (println "\nFAIL in" (clojure.test/testing-vars-str m))
       (when (seq clojure.test/*testing-contexts*) (println (clojure.test/testing-contexts-str)))
       (when-let [message (:message m)] (println message))
       (println "expected:" (pr-str (:expected m)))
       (println "  actual:" (pr-str (:actual m))))))

(def old-error-blob
  '(defmethod clojure.test/report :error [m]
     (clojure.test/with-test-out
      (clojure.test/inc-report-counter :error)
      (println "\nERROR in" (clojure.test/testing-vars-str m))
      (when (seq clojure.test/*testing-contexts*) (println (clojure.test/testing-contexts-str)))
      (when-let [message (:message m)] (println message))
      (println "expected:" (pr-str (:expected m)))
      (print "  actual: ")
      (let [actual (:actual m)]
        (if (instance? Throwable actual)
         (clojure.stacktrace/print-cause-trace actual clojure.test/*stack-trace-depth*)
         (prn actual))))))

(def html-for-tests
  '{:html '(if (empty? ?state)
             [:div.title "All tests passed"]
             [:div.rows
              [:div.title.error "Test(s) failed!"]
              [:<>
               (map (fn [error idx]
                      [:div.rows {:key idx}
                       [:div.space]
                       [:div.title
                        (-> error :type name str/upper-case) " at: "
                        [:a {:href "#"
                             :on-click (fn [_] (editor/run-callback :open-editor
                                                                    {:file-name (:file error)
                                                                     :line (dec (:line error))}))}
                         (:file error) ":" (:line error)]]

                       (if (-> error :type (= :error))
                         (do
                           (log (pr-str (:actual error)))
                           [:div/clj (:actual error)])
                         [:div/ansi (:actual error)])])
                       ; [:a {:href "#" :on-click (fn [_]
                       ;                            (editor/eval-interactive "__PLACE_HOLDER_HERE__"))}
                        ; "Re-run test")])
                    ?state (range))]])
    :state @s})

(defn eval-block-as-test []
  (p/let [txt-code (editor/get-block)
          code (str "(let [s (atom [])] "
                    "   (defmethod clojure.test/report :error [m]"
                    "     (swap! s conj m))"
                    "   (defmethod clojure.test/report :fail [m]"
                    "     (swap! s conj (update m :actual pr-str))) "
                    (:text txt-code) " "
                    (pr-str old-fail-blob) " "
                    (pr-str old-error-blob) " "
                    html-for-tests " )")
          obj {:range (:range txt-code)
               :text (str code)}]
    (editor/eval-interactive obj)))


;;; DOT
(def ^:private wasm (render/js-require "./chlorine/hpcc-js"))
(def ^:private viz (render/js-require "./chlorine/viz"))
(defn render-viz
  ([txt] (render-viz {} txt))
  ([opts txt]
   (prn :OPTS? opts)
   (let [tag (render/create-tag "div")]
     (render/set-text tag "RENDERING...")
     (-> (p/let [res (.. wasm
                         -graphviz
                         (layout txt "svg" "dot"))]
           (render/set-html tag res)
           (doseq [n (.querySelectorAll tag "g.node.foo")]
             (aset n "onclick" (fn [a]
                                 (prn :A a)))))
            ; (prn :N n)))

         (p/catch (fn [ & args]
                    (render/set-text tag "Failed to render"))))
     tag)))

(defn pprint-block []
  (p/let [res (editor/get-block)
          res (update res :text #(str "(clojure.pprint/pprint " % ")"))
          result (editor/eval res)]
    (println (:result result))))

(defn pprint-block-in-new-txt []
  (p/let [res (editor/get-block)
          res (update res :text #(str "(with-out-str (clojure.pprint/pprint " % "))"))
          result (editor/eval (assoc res :aux true))]
    (editor/run-callback :open-editor
                         {:file-name (str (gensym "eval-result-") ".clj")
                          :line 0
                          :contents (str (:result result))})))

(render/register-tag :p/viz render-viz)

(def table-html
  '(if (map? (:edn ?state))
     [:div.rows
      [:div.title "Key/Vals"]
      [:div.space]
      [:table
       [:tr {:style {:border-bottom "4px double gray"}}
        [:th {:style {:border-right "1px solid gray"}}
         [:a {:href "#" :on-click (?sort true)} "Keys"]]
        [:th {:style {:padding-left "1em"}}
         [:a {:href "#" :on-click (?sort false)} "Vals"]]]
       [:<>
        (map (fn [i [k v]]
               [:tr {:key i}
                [:td {:style {:border-bottom "1px solid gray"
                              :border-right "1px solid gray"}
                      :width 1}
                 [:div/clj k]]
                [:td {:style {:border-bottom "1px solid gray"
                              :padding-left "1em"}}
                 [:div/clj v]]])
             (take (:show-first ?state) (range))
             (cond->> (:edn ?state)
                      (some? (:sort-by ?state))
                      (sort-by (if (:sort-by ?state) first second))))]]
      [:a {:href "#"} "..."]]
     [:div/clj (:edn ?state)]))

(defn run-as-table []
  (p/let [res (editor/get-block)
          res (update res
                      :text
                      #(str "{:html '" (pr-str table-html)
                            " :state {:edn " % " :show-first 10}"
                            " :fns {:sort '(fn [_ state k?]"
                            "                (assoc state :sort-by k?))}}"))]
    (editor/eval-interactive res)))

(defn eval-and-trace []
  (p/let [res (editor/get-block)
          res (update res :text #(str "(flow-storm.api/trace" % ")"))]
    (editor/eval-and-render res)))

(def html-for-chess
 '(let [pieces {:black/pawn "\u265F"
                :black/rook "\u265C"
                :black/knight "\u265E"
                :black/bishop "\u265D"
                :black/queen "\u265B"
                :black/king "\u265A"
                :white/rook "\u2656"
                :white/knight "\u2658"
                :white/bishop "\u2657"
                :white/queen "\u2655"
                :white/king "\u2654"
                :white/pawn "\u2659"}
        w-style {:width "35pt" :height "35pt"
                 :background-color "gray"
                 :font-size "20pt"
                 :text-align "center"
                 :color "black"}
        b-style (assoc w-style :background-color "lightgray")
        tds (cycle [[:td {:style w-style}] [:td {:style b-style}]])
        light-tds (take 8 (rest tds))
        black-tds (take 8 tds)
        make-row (fn [col html-col]
                   (conj html-col (str (pieces col))))
        board (map (fn [row html-row] (map make-row row html-row))
                   ?state (cycle [light-tds black-tds]))
        html-board (map (fn [tds] [:tr [:<> tds]]) board)]
    [:div
     [:table
      [:tbody [:<> html-board]]]]))

(defn eval-chess-board []
  (p/let [block (editor/get-block)
          res (update block :text #(str "{:html '" (pr-str html-for-chess)
                                        ":state " % "}"))]
    (editor/eval-interactive res)))

(editor/run-callback :notify {:type :info :title "Config reloaded"})

package-lock.json

{
  "requires": true,
  "lockfileVersion": 1,
  "dependencies": {
    "@hpcc-js/wasm": {
      "version": "0.3.13",
      "resolved": "https://registry.npmjs.org/@hpcc-js/wasm/-/wasm-0.3.13.tgz",
      "integrity": "sha512-cnhBOjxa2RCb/0phDmjy9u1+GEMyDKFtf1uXbtYFlm9XcyLZEDKFOzYjeb9iXM4mF0dDhS0P3iRmy4U9orIasA=="
    },
    "ansi_up": {
      "version": "4.0.4",
      "resolved": "https://registry.npmjs.org/ansi_up/-/ansi_up-4.0.4.tgz",
      "integrity": "sha512-vRxC8q6QY918MbehO869biJW4tiunJdjOhi5fpY6NLOliBQlZhOkKgABJKJqH+JZfb/WfjvjN1chLWI6tODerw=="
    },
    "cross-spawn": {
      "version": "7.0.3",
      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
      "requires": {
        "path-key": "^3.1.0",
        "shebang-command": "^2.0.0",
        "which": "^2.0.1"
      }
    },
    "d3-color": {
      "version": "1.4.1",
      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-1.4.1.tgz",
      "integrity": "sha512-p2sTHSLCJI2QKunbGb7ocOh7DgTAn8IrLx21QRc/BSnodXM4sv6aLQlnfpvehFMLZEfBc6g9pH9SWQccFYfJ9Q=="
    },
    "d3-dispatch": {
      "version": "1.0.6",
      "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-1.0.6.tgz",
      "integrity": "sha512-fVjoElzjhCEy+Hbn8KygnmMS7Or0a9sI2UzGwoB7cCtvI1XpVN9GpoYlnb3xt2YV66oXYb1fLJ8GMvP4hdU1RA=="
    },
    "d3-drag": {
      "version": "1.2.5",
      "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-1.2.5.tgz",
      "integrity": "sha512-rD1ohlkKQwMZYkQlYVCrSFxsWPzI97+W+PaEIBNTMxRuxz9RF0Hi5nJWHGVJ3Om9d2fRTe1yOBINJyy/ahV95w==",
      "requires": {
        "d3-dispatch": "1",
        "d3-selection": "1"
      }
    },
    "d3-ease": {
      "version": "1.0.7",
      "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-1.0.7.tgz",
      "integrity": "sha512-lx14ZPYkhNx0s/2HX5sLFUI3mbasHjSSpwO/KaaNACweVwxUruKyWVcb293wMv1RqTPZyZ8kSZ2NogUZNcLOFQ=="
    },
    "d3-format": {
      "version": "1.4.5",
      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-1.4.5.tgz",
      "integrity": "sha512-J0piedu6Z8iB6TbIGfZgDzfXxUFN3qQRMofy2oPdXzQibYGqPB/9iMcxr/TGalU+2RsyDO+U4f33id8tbnSRMQ=="
    },
    "d3-graphviz": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/d3-graphviz/-/d3-graphviz-3.1.0.tgz",
      "integrity": "sha512-OcVBBvpj2QR1waw+rhQitZshUrS4I/zScsm+LWXowg96hGccsjWF6YGaU3p9pnZQu45yxpji2Zt9y2Zne4wE9Q==",
      "requires": {
        "@hpcc-js/wasm": "0.3.13",
        "d3-dispatch": "^1.0.6",
        "d3-format": "^1.4.3",
        "d3-interpolate": "^1.4.0",
        "d3-path": "^1.0.9",
        "d3-selection": "^1.4.1",
        "d3-timer": "^1.0.10",
        "d3-transition": "^1.3.2",
        "d3-zoom": "1.7.3"
      }
    },
    "d3-interpolate": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-1.4.0.tgz",
      "integrity": "sha512-V9znK0zc3jOPV4VD2zZn0sDhZU3WAE2bmlxdIwwQPPzPjvyLkd8B3JUVdS1IDUFDkWZ72c9qnv1GK2ZagTZ8EA==",
      "requires": {
        "d3-color": "1"
      }
    },
    "d3-path": {
      "version": "1.0.9",
      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz",
      "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="
    },
    "d3-selection": {
      "version": "1.4.2",
      "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-1.4.2.tgz",
      "integrity": "sha512-SJ0BqYihzOjDnnlfyeHT0e30k0K1+5sR3d5fNueCNeuhZTnGw4M4o8mqJchSwgKMXCNFo+e2VTChiSJ0vYtXkg=="
    },
    "d3-timer": {
      "version": "1.0.10",
      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-1.0.10.tgz",
      "integrity": "sha512-B1JDm0XDaQC+uvo4DT79H0XmBskgS3l6Ve+1SBCfxgmtIb1AVrPIoqd+nPSv+loMX8szQ0sVUhGngL7D5QPiXw=="
    },
    "d3-transition": {
      "version": "1.3.2",
      "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-1.3.2.tgz",
      "integrity": "sha512-sc0gRU4PFqZ47lPVHloMn9tlPcv8jxgOQg+0zjhfZXMQuvppjG6YuwdMBE0TuqCZjeJkLecku/l9R0JPcRhaDA==",
      "requires": {
        "d3-color": "1",
        "d3-dispatch": "1",
        "d3-ease": "1",
        "d3-interpolate": "1",
        "d3-selection": "^1.1.0",
        "d3-timer": "1"
      }
    },
    "d3-zoom": {
      "version": "1.7.3",
      "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-1.7.3.tgz",
      "integrity": "sha512-xEBSwFx5Z9T3/VrwDkMt+mr0HCzv7XjpGURJ8lWmIC8wxe32L39eWHIasEe/e7Ox8MPU4p1hvH8PKN2olLzIBg==",
      "requires": {
        "d3-dispatch": "1",
        "d3-drag": "1",
        "d3-interpolate": "1",
        "d3-selection": "1",
        "d3-transition": "1"
      }
    },
    "dagre": {
      "version": "0.8.5",
      "resolved": "https://registry.npmjs.org/dagre/-/dagre-0.8.5.tgz",
      "integrity": "sha512-/aTqmnRta7x7MCCpExk7HQL2O4owCT2h8NT//9I1OQ9vt29Pa0BzSAkR5lwFUcQ7491yVi/3CXU9jQ5o0Mn2Sw==",
      "requires": {
        "graphlib": "^2.1.8",
        "lodash": "^4.17.15"
      }
    },
    "end-of-stream": {
      "version": "1.4.4",
      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
      "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
      "requires": {
        "once": "^1.4.0"
      }
    },
    "execa": {
      "version": "4.0.2",
      "resolved": "https://registry.npmjs.org/execa/-/execa-4.0.2.tgz",
      "integrity": "sha512-QI2zLa6CjGWdiQsmSkZoGtDx2N+cQIGb3yNolGTdjSQzydzLgYYf8LRuagp7S7fPimjcrzUDSUFd/MgzELMi4Q==",
      "requires": {
        "cross-spawn": "^7.0.0",
        "get-stream": "^5.0.0",
        "human-signals": "^1.1.1",
        "is-stream": "^2.0.0",
        "merge-stream": "^2.0.0",
        "npm-run-path": "^4.0.0",
        "onetime": "^5.1.0",
        "signal-exit": "^3.0.2",
        "strip-final-newline": "^2.0.0"
      }
    },
    "get-stream": {
      "version": "5.1.0",
      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.1.0.tgz",
      "integrity": "sha512-EXr1FOzrzTfGeL0gQdeFEvOMm2mzMOglyiOXSTpPC+iAjAKftbr3jpCMWynogwYnM+eSj9sHGc6wjIcDvYiygw==",
      "requires": {
        "pump": "^3.0.0"
      }
    },
    "graphlib": {
      "version": "2.1.8",
      "resolved": "https://registry.npmjs.org/graphlib/-/graphlib-2.1.8.tgz",
      "integrity": "sha512-jcLLfkpoVGmH7/InMC/1hIvOPSUh38oJtGhvrOFGzioE1DZ+0YW16RgmOJhHiuWTvGiJQ9Z1Ik43JvkRPRvE+A==",
      "requires": {
        "lodash": "^4.17.15"
      }
    },
    "human-signals": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-1.1.1.tgz",
      "integrity": "sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw=="
    },
    "is-stream": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.0.tgz",
      "integrity": "sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw=="
    },
    "isexe": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
      "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA="
    },
    "lodash": {
      "version": "4.17.15",
      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz",
      "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A=="
    },
    "merge-stream": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="
    },
    "mimic-fn": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="
    },
    "nomnoml": {
      "version": "0.7.2",
      "resolved": "https://registry.npmjs.org/nomnoml/-/nomnoml-0.7.2.tgz",
      "integrity": "sha512-3Tp/GJbQQcvq2ckCzQnIbMnIZDOQHFdVkFvGLXIXegR2X7kw7mEIAasgz3TgfPLeoBrozUcjkGHJckZTvhfupA==",
      "requires": {
        "dagre": "0.8.5"
      }
    },
    "npm-run-path": {
      "version": "4.0.1",
      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz",
      "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==",
      "requires": {
        "path-key": "^3.0.0"
      }
    },
    "once": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
      "requires": {
        "wrappy": "1"
      }
    },
    "onetime": {
      "version": "5.1.0",
      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.0.tgz",
      "integrity": "sha512-5NcSkPHhwTVFIQN+TUqXoS5+dlElHXdpAWu9I0HP20YOtIi+aZ0Ct82jdlILDxjLEAWwvm+qj1m6aEtsDVmm6Q==",
      "requires": {
        "mimic-fn": "^2.1.0"
      }
    },
    "path-key": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="
    },
    "plantuml": {
      "version": "0.0.1",
      "resolved": "https://registry.npmjs.org/plantuml/-/plantuml-0.0.1.tgz",
      "integrity": "sha512-uey4aw73CwywLm0wr0mDqPGYZUmZ/OtsWyneJwOvIDJsj1r1+9PPFNYBuCmvS39dXxnuNw9rGsgdQqNGRr4dAw==",
      "requires": {
        "execa": "^4.0.0",
        "get-stream": "^5.1.0"
      }
    },
    "pump": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz",
      "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==",
      "requires": {
        "end-of-stream": "^1.1.0",
        "once": "^1.3.1"
      }
    },
    "shebang-command": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
      "requires": {
        "shebang-regex": "^3.0.0"
      }
    },
    "shebang-regex": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="
    },
    "signal-exit": {
      "version": "3.0.3",
      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz",
      "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA=="
    },
    "strip-final-newline": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz",
      "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA=="
    },
    "vis.js": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/vis.js/-/vis.js-1.1.0.tgz",
      "integrity": "sha512-xGTkJH4Es9orHRGeWo2OkFmX4mO0WayC0tdVTcZFwXFdRdFsWTjiF17Y8Zt530oxMTDUFyAciQcZuGBFoMdOTQ=="
    },
    "which": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
      "requires": {
        "isexe": "^2.0.0"
      }
    },
    "wrappy": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
    }
  }
}