{:rename-macros {}, :renames {}, :externs {Error {}}, :use-macros {assert-js-object reagent.debug, assert-some reagent.debug, assert-new-state reagent.debug, dbg reagent.debug, $! reagent.interop, prn reagent.debug, assert-component reagent.debug, $ reagent.interop, assert-callable reagent.debug}, :excludes #{atom flush partial}, :name reagent.core, :imports nil, :requires {reagent.impl.util reagent.impl.util, dom reagent.dom, comp reagent.impl.component, reagent.interop reagent.interop, reagent.ratom reagent.ratom, reagent.impl.template reagent.impl.template, reagent.impl.batching reagent.impl.batching, reagent.impl.component reagent.impl.component, util reagent.impl.util, tmpl reagent.impl.template, ratom reagent.ratom, deb reagent.debug, batch reagent.impl.batching, reagent.debug reagent.debug, reagent.dom reagent.dom}, :cljs.spec/speced-vars [], :uses nil, :defs {after-render {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 331, :column 7, :end-line 331, :end-column 19, :arglists (quote ([f])), :doc "Run f using requestAnimationFrame or equivalent.\n\n  f will be called just after any queued renders in the next animation\n  frame (and even if no renders actually occur)."}, :name reagent.core/after-render, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 19, :method-params ([f]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 331, :end-line 331, :max-fixed-arity 1, :fn-var true, :arglists (quote ([f])), :doc "Run f using requestAnimationFrame or equivalent.\n\n  f will be called just after any queued renders in the next animation\n  frame (and even if no renders actually occur)."}, current-component {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 122, :column 7, :end-line 122, :end-column 24, :arglists (quote ([])), :doc "Returns the current React component (a.k.a this) in a component\n  function."}, :name reagent.core/current-component, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 24, :method-params ([]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 122, :end-line 122, :max-fixed-arity 0, :fn-var true, :arglists (quote ([])), :doc "Returns the current React component (a.k.a this) in a component\n  function."}, as-component {:name reagent.core/as-component, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :line 85, :column 1, :end-line 85, :end-column 18, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 85, :column 6, :end-line 85, :end-column 18}}, adapt-react-class {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 51, :column 7, :end-line 51, :end-column 24, :arglists (quote ([c])), :doc "Returns an adapter for a native React class, that may be used\n  just like a Reagent component function or class in Hiccup forms."}, :name reagent.core/adapt-react-class, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 24, :method-params ([c]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 51, :end-line 51, :max-fixed-arity 1, :fn-var true, :arglists (quote ([c])), :doc "Returns an adapter for a native React class, that may be used\n  just like a Reagent component function or class in Hiccup forms."}, atom {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 210, :column 7, :end-line 210, :end-column 11, :arglists (quote ([x] [x & rest])), :doc "Like clojure.core/atom, except that it keeps track of derefs.\n  Reagent components that derefs one of these are automatically\n  re-rendered.", :top-fn {:variadic true, :max-fixed-arity 1, :method-params ([x]), :arglists ([x] [x & rest]), :arglists-meta (nil nil)}}, :name reagent.core/atom, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 11, :top-fn {:variadic true, :max-fixed-arity 1, :method-params ([x]), :arglists ([x] [x & rest]), :arglists-meta (nil nil)}, :method-params ([x]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 210, :end-line 210, :max-fixed-arity 1, :fn-var true, :arglists ([x] [x & rest]), :doc "Like clojure.core/atom, except that it keeps track of derefs.\n  Reagent components that derefs one of these are automatically\n  re-rendered."}, merge-props {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 192, :column 7, :end-line 192, :end-column 18, :arglists (quote ([defaults props])), :doc "Utility function that merges two maps, handling :class and :style\n  specially, like React's transferPropsTo."}, :name reagent.core/merge-props, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 18, :method-params ([defaults props]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 192, :end-line 192, :max-fixed-arity 2, :fn-var true, :arglists (quote ([defaults props])), :doc "Utility function that merges two maps, handling :class and :style\n  specially, like React's transferPropsTo."}, force-update-all {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 88, :column 16, :end-line 88, :end-column 32, :export true, :arglists (quote ([])), :doc "Force re-rendering of all mounted Reagent components. This is\n  probably only useful in a development environment, when you want to\n  update components in response to some dynamic changes to code.\n\n  Note that force-update-all may not update root components. This\n  happens if a component 'foo' is mounted with `(render [foo])` (since\n  functions are passed by value, and not by reference, in\n  ClojureScript). To get around this you'll have to introduce a layer\n  of indirection, for example by using `(render [#'foo])` instead."}, :name reagent.core/force-update-all, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 32, :method-params ([]), :protocol-impl nil, :export true, :arglists-meta (nil nil), :column 1, :line 88, :end-line 88, :max-fixed-arity 0, :fn-var true, :arglists (quote ([])), :doc "Force re-rendering of all mounted Reagent components. This is\n  probably only useful in a development environment, when you want to\n  update components in response to some dynamic changes to code.\n\n  Note that force-update-all may not update root components. This\n  happens if a component 'foo' is mounted with `(render [foo])` (since\n  functions are passed by value, and not by reference, in\n  ClojureScript). To get around this you'll have to introduce a layer\n  of indirection, for example by using `(render [#'foo])` instead."}, as-element {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 45, :column 7, :end-line 45, :end-column 17, :arglists (quote ([form])), :doc "Turns a vector of Hiccup syntax into a React element. Returns form\n  unchanged if it is not a vector."}, :name reagent.core/as-element, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 17, :method-params ([form]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 45, :end-line 45, :max-fixed-arity 1, :fn-var true, :arglists (quote ([form])), :doc "Turns a vector of Hiccup syntax into a React element. Returns form\n  unchanged if it is not a vector."}, rswap! {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 303, :column 7, :end-line 303, :end-column 13, :arglists (quote ([a f & args])), :doc "Swaps the value of a to be (apply f current-value-of-atom args).\n\n  rswap! works like swap!, except that recursive calls to rswap! on\n  the same atom are allowed – and it always returns nil.", :top-fn {:variadic true, :max-fixed-arity 2, :method-params [(a f args)], :arglists ([a f & args]), :arglists-meta (nil)}}, :name reagent.core/rswap!, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 13, :top-fn {:variadic true, :max-fixed-arity 2, :method-params [(a f args)], :arglists ([a f & args]), :arglists-meta (nil)}, :method-params [(a f args)], :protocol-impl nil, :arglists-meta (nil), :column 1, :line 303, :end-line 303, :max-fixed-arity 2, :fn-var true, :arglists ([a f & args]), :doc "Swaps the value of a to be (apply f current-value-of-atom args).\n\n  rswap! works like swap!, except that recursive calls to rswap! on\n  the same atom are allowed – and it always returns nil."}, next-tick {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 324, :column 7, :end-line 324, :end-column 16, :arglists (quote ([f])), :doc "Run f using requestAnimationFrame or equivalent.\n\n  f will be called just before components are rendered."}, :name reagent.core/next-tick, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 16, :method-params ([f]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 324, :end-line 324, :max-fixed-arity 1, :fn-var true, :arglists (quote ([f])), :doc "Run f using requestAnimationFrame or equivalent.\n\n  f will be called just before components are rendered."}, track {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 217, :column 7, :end-line 217, :end-column 12, :arglists (quote ([f & args])), :doc "Takes a function and optional arguments, and returns a derefable\n  containing the output of that function. If the function derefs\n  Reagent atoms (or track, etc), the value will be updated whenever\n  the atom changes.\n\n  In other words, @(track foo bar) will produce the same result\n  as (foo bar), but foo will only be called again when the atoms it\n  depends on changes, and will only trigger updates of components when\n  its result changes.\n\n  track is lazy, i.e the function is only evaluated on deref.", :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(f args)], :arglists ([f & args]), :arglists-meta (nil)}}, :name reagent.core/track, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 12, :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(f args)], :arglists ([f & args]), :arglists-meta (nil)}, :method-params [(f args)], :protocol-impl nil, :arglists-meta (nil), :column 1, :line 217, :end-line 217, :max-fixed-arity 1, :fn-var true, :arglists ([f & args]), :doc "Takes a function and optional arguments, and returns a derefable\n  containing the output of that function. If the function derefs\n  Reagent atoms (or track, etc), the value will be updated whenever\n  the atom changes.\n\n  In other words, @(track foo bar) will produce the same result\n  as (foo bar), but foo will only be called again when the atoms it\n  depends on changes, and will only trigger updates of components when\n  its result changes.\n\n  track is lazy, i.e the function is only evaluated on deref."}, props {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 169, :column 7, :end-line 169, :end-column 12, :arglists (quote ([this])), :doc "Returns the props passed to a component."}, :name reagent.core/props, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 12, :method-params ([this]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 169, :end-line 169, :max-fixed-arity 1, :fn-var true, :arglists (quote ([this])), :doc "Returns the props passed to a component."}, dispose! {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 241, :column 7, :end-line 241, :end-column 15, :arglists (quote ([x])), :doc "Stop the result of track! from updating."}, :name reagent.core/dispose!, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 15, :method-params ([x]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 241, :end-line 241, :max-fixed-arity 1, :fn-var true, :arglists (quote ([x])), :doc "Stop the result of track! from updating."}, state-atom {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 128, :column 7, :end-line 128, :end-column 17, :arglists (quote ([this])), :doc "Returns an atom containing a components state."}, :name reagent.core/state-atom, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 17, :method-params ([this]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 128, :end-line 128, :max-fixed-arity 1, :fn-var true, :arglists (quote ([this])), :doc "Returns an atom containing a components state."}, flush {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 198, :column 7, :end-line 198, :end-column 12, :arglists (quote ([])), :doc "Render dirty components immediately to the DOM.\n\n  Note that this may not work in event handlers, since React.js does\n  batching of updates there."}, :name reagent.core/flush, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 12, :method-params ([]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 198, :end-line 198, :max-fixed-arity 0, :fn-var true, :arglists (quote ([])), :doc "Render dirty components immediately to the DOM.\n\n  Note that this may not work in event handlers, since React.js does\n  batching of updates there."}, children {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 175, :column 7, :end-line 175, :end-column 15, :arglists (quote ([this])), :doc "Returns the children passed to a component."}, :name reagent.core/children, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 15, :method-params ([this]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 175, :end-line 175, :max-fixed-arity 1, :fn-var true, :arglists (quote ([this])), :doc "Returns the children passed to a component."}, react {:name reagent.core/react, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :line 18, :column 1, :end-line 18, :end-column 11, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 18, :column 6, :end-line 18, :end-column 11}, :tag js}, wrap {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 246, :column 7, :end-line 246, :end-column 11, :arglists (quote ([value reset-fn & args])), :doc "Provide a combination of value and callback, that looks like an atom.\n\n  The first argument can be any value, that will be returned when the\n  result is deref'ed.\n\n  The second argument should be a function, that is called with the\n  optional extra arguments provided to wrap, and the new value of the\n  resulting 'atom'.\n\n  Use for example like this:\n\n  (wrap (:foo @state)\n        swap! state assoc :foo)\n\n  Probably useful only for passing to child components.", :top-fn {:variadic true, :max-fixed-arity 2, :method-params [(value reset-fn args)], :arglists ([value reset-fn & args]), :arglists-meta (nil)}}, :name reagent.core/wrap, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 11, :top-fn {:variadic true, :max-fixed-arity 2, :method-params [(value reset-fn args)], :arglists ([value reset-fn & args]), :arglists-meta (nil)}, :method-params [(value reset-fn args)], :protocol-impl nil, :arglists-meta (nil), :column 1, :line 246, :end-line 246, :max-fixed-arity 2, :fn-var true, :arglists ([value reset-fn & args]), :doc "Provide a combination of value and callback, that looks like an atom.\n\n  The first argument can be any value, that will be returned when the\n  result is deref'ed.\n\n  The second argument should be a function, that is called with the\n  optional extra arguments provided to wrap, and the new value of the\n  resulting 'atom'.\n\n  Use for example like this:\n\n  (wrap (:foo @state)\n        swap! state assoc :foo)\n\n  Probably useful only for passing to child components."}, reactify-component {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 58, :column 7, :end-line 58, :end-column 25, :arglists (quote ([c])), :doc "Returns an adapter for a Reagent component, that may be used from\n  React, for example in JSX. A single argument, props, is passed to\n  the component, converted to a map."}, :name reagent.core/reactify-component, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 25, :method-params ([c]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 58, :end-line 58, :max-fixed-arity 1, :fn-var true, :arglists (quote ([c])), :doc "Returns an adapter for a Reagent component, that may be used from\n  React, for example in JSX. A single argument, props, is passed to\n  the component, converted to a map."}, unmount-component-at-node {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 79, :column 7, :end-line 79, :end-column 32, :arglists (quote ([container])), :doc "Remove a component from the given DOM node."}, :name reagent.core/unmount-component-at-node, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 32, :method-params ([container]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 79, :end-line 79, :max-fixed-arity 1, :fn-var true, :arglists (quote ([container])), :doc "Remove a component from the given DOM node."}, render-component {:name reagent.core/render-component, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :line 86, :column 1, :end-line 86, :end-column 22, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 86, :column 6, :end-line 86, :end-column 22}}, component-path {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 344, :column 7, :end-line 344, :end-column 21, :arglists (quote ([c]))}, :name reagent.core/component-path, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 21, :method-params ([c]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 344, :end-line 344, :max-fixed-arity 1, :fn-var true, :arglists (quote ([c]))}, cursor {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 269, :column 7, :end-line 269, :end-column 13, :arglists (quote ([src path])), :doc "Provide a cursor into a Reagent atom.\n\n  Behaves like a Reagent atom but focuses updates and derefs to\n  the specified path within the wrapped Reagent atom. e.g.,\n    (let [c (cursor ra [:nested :content])]\n      ... @c ;; equivalent to (get-in @ra [:nested :content])\n      ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)\n      ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)\n      )\n\n  The first parameter can also be a function, that should look\n  something like this:\n\n    (defn set-get\n      ([k] (get-in @state k))\n      ([k v] (swap! state assoc-in k v)))\n\n  The function will be called with one argument – the path passed to\n  cursor – when the cursor is deref'ed, and two arguments (path and\n  new value) when the cursor is modified.\n\n  Given that set-get function, (and that state is a Reagent atom, or\n  another cursor) these cursors are equivalent:\n  (cursor state [:foo]) and (cursor set-get [:foo]).\n\n  Note that a cursor is lazy: its value will not change until it is\n  used. This may be noticed with add-watch."}, :name reagent.core/cursor, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 13, :method-params ([src path]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 269, :end-line 269, :max-fixed-arity 2, :fn-var true, :arglists (quote ([src path])), :doc "Provide a cursor into a Reagent atom.\n\n  Behaves like a Reagent atom but focuses updates and derefs to\n  the specified path within the wrapped Reagent atom. e.g.,\n    (let [c (cursor ra [:nested :content])]\n      ... @c ;; equivalent to (get-in @ra [:nested :content])\n      ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)\n      ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)\n      )\n\n  The first parameter can also be a function, that should look\n  something like this:\n\n    (defn set-get\n      ([k] (get-in @state k))\n      ([k v] (swap! state assoc-in k v)))\n\n  The function will be called with one argument – the path passed to\n  cursor – when the cursor is deref'ed, and two arguments (path and\n  new value) when the cursor is modified.\n\n  Given that set-get function, (and that state is a Reagent atom, or\n  another cursor) these cursors are equivalent:\n  (cursor state [:foo]) and (cursor set-get [:foo]).\n\n  Note that a cursor is lazy: its value will not change until it is\n  used. This may be noticed with add-watch."}, state {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 134, :column 7, :end-line 134, :end-column 12, :arglists (quote ([this])), :doc "Returns the state of a component, as set with replace-state or set-state.\n  Equivalent to (deref (r/state-atom this))"}, :name reagent.core/state, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 12, :method-params ([this]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 134, :end-line 134, :max-fixed-arity 1, :fn-var true, :arglists (quote ([this])), :doc "Returns the state of a component, as set with replace-state or set-state.\n  Equivalent to (deref (r/state-atom this))"}, dom-node {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 187, :column 7, :end-line 187, :end-column 15, :arglists (quote ([this])), :doc "Returns the root DOM node of a mounted component."}, :name reagent.core/dom-node, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 15, :method-params ([this]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 187, :end-line 187, :max-fixed-arity 1, :fn-var true, :arglists (quote ([this])), :doc "Returns the root DOM node of a mounted component."}, track! {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 233, :column 7, :end-line 233, :end-column 13, :arglists (quote ([f & args])), :doc "An eager version of track. The function passed is called\n  immediately, and continues to be called when needed, until stopped\n  with dispose!.", :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(f args)], :arglists ([f & args]), :arglists-meta (nil)}}, :name reagent.core/track!, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 13, :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(f args)], :arglists ([f & args]), :arglists-meta (nil)}, :method-params [(f args)], :protocol-impl nil, :arglists-meta (nil), :column 1, :line 233, :end-line 233, :max-fixed-arity 1, :fn-var true, :arglists ([f & args]), :doc "An eager version of track. The function passed is called\n  immediately, and continues to be called when needed, until stopped\n  with dispose!."}, is-client {:name reagent.core/is-client, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :line 16, :column 1, :end-line 16, :end-column 15, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 16, :column 6, :end-line 16, :end-column 15}, :tag boolean}, replace-state {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 141, :column 7, :end-line 141, :end-column 20, :arglists (quote ([this new-state])), :doc "Set state of a component.\n  Equivalent to (reset! (state-atom this) new-state)"}, :name reagent.core/replace-state, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 20, :method-params ([this new-state]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 141, :end-line 141, :max-fixed-arity 2, :fn-var true, :arglists (quote ([this new-state])), :doc "Set state of a component.\n  Equivalent to (reset! (state-atom this) new-state)"}, partial {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 339, :column 7, :end-line 339, :end-column 14, :arglists (quote ([f & args])), :doc "Works just like clojure.core/partial, but the result can be compared with =", :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(f args)], :arglists ([f & args]), :arglists-meta (nil)}}, :name reagent.core/partial, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 14, :top-fn {:variadic true, :max-fixed-arity 1, :method-params [(f args)], :arglists ([f & args]), :arglists-meta (nil)}, :method-params [(f args)], :protocol-impl nil, :arglists-meta (nil), :column 1, :line 339, :end-line 339, :max-fixed-arity 1, :fn-var true, :arglists ([f & args]), :doc "Works just like clojure.core/partial, but the result can be compared with ="}, set-state {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 149, :column 7, :end-line 149, :end-column 16, :arglists (quote ([this new-state])), :doc "Merge component state with new-state.\n  Equivalent to (swap! (state-atom this) merge new-state)"}, :name reagent.core/set-state, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 16, :method-params ([this new-state]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 149, :end-line 149, :max-fixed-arity 2, :fn-var true, :arglists (quote ([this new-state])), :doc "Merge component state with new-state.\n  Equivalent to (swap! (state-atom this) merge new-state)"}, argv {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 181, :column 7, :end-line 181, :end-column 11, :arglists (quote ([this])), :doc "Returns the entire Hiccup form passed to the component."}, :name reagent.core/argv, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 11, :method-params ([this]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 181, :end-line 181, :max-fixed-arity 1, :fn-var true, :arglists (quote ([this])), :doc "Returns the entire Hiccup form passed to the component."}, render {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 66, :column 7, :end-line 66, :end-column 13, :arglists (quote ([comp container] [comp container callback])), :doc "Render a Reagent component into the DOM. The first argument may be\n  either a vector (using Reagent's Hiccup syntax), or a React element.\n  The second argument should be a DOM node.\n\n  Optionally takes a callback that is called when the component is in place.\n\n  Returns the mounted component instance.", :top-fn {:variadic false, :max-fixed-arity 3, :method-params ([comp container] [comp container callback]), :arglists ([comp container] [comp container callback]), :arglists-meta (nil nil)}}, :name reagent.core/render, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 13, :top-fn {:variadic false, :max-fixed-arity 3, :method-params ([comp container] [comp container callback]), :arglists ([comp container] [comp container callback]), :arglists-meta (nil nil)}, :method-params ([comp container] [comp container callback]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 66, :end-line 66, :max-fixed-arity 3, :fn-var true, :arglists ([comp container] [comp container callback]), :doc "Render a Reagent component into the DOM. The first argument may be\n  either a vector (using Reagent's Hiccup syntax), or a React element.\n  The second argument should be a DOM node.\n\n  Optionally takes a callback that is called when the component is in place.\n\n  Returns the mounted component instance."}, force-update {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 157, :column 7, :end-line 157, :end-column 19, :arglists (quote ([this] [this deep])), :doc "Force a component to re-render immediately.\n\n  If the second argument is true, child components will also be\n  re-rendered, even is their arguments have not changed.", :top-fn {:variadic false, :max-fixed-arity 2, :method-params ([this] [this deep]), :arglists ([this] [this deep]), :arglists-meta (nil nil)}}, :name reagent.core/force-update, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 19, :top-fn {:variadic false, :max-fixed-arity 2, :method-params ([this] [this deep]), :arglists ([this] [this deep]), :arglists-meta (nil nil)}, :method-params ([this] [this deep]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 157, :end-line 157, :max-fixed-arity 2, :fn-var true, :arglists ([this] [this deep]), :doc "Force a component to re-render immediately.\n\n  If the second argument is true, child components will also be\n  re-rendered, even is their arguments have not changed."}, create-class {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 103, :column 7, :end-line 103, :end-column 19, :arglists (quote ([spec])), :doc "Create a component, React style. Should be called with a map,\n  looking like this:\n\n    {:get-initial-state (fn [this])\n     :component-will-receive-props (fn [this new-argv])\n     :should-component-update (fn [this old-argv new-argv])\n     :component-will-mount (fn [this])\n     :component-did-mount (fn [this])\n     :component-will-update (fn [this new-argv])\n     :component-did-update (fn [this old-argv])\n     :component-will-unmount (fn [this])\n     :reagent-render (fn [args....])}   ;; or :render (fn [this])\n\n  Everything is optional, except either :reagent-render or :render."}, :name reagent.core/create-class, :variadic false, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 19, :method-params ([spec]), :protocol-impl nil, :arglists-meta (nil nil), :column 1, :line 103, :end-line 103, :max-fixed-arity 1, :fn-var true, :arglists (quote ([spec])), :doc "Create a component, React style. Should be called with a map,\n  looking like this:\n\n    {:get-initial-state (fn [this])\n     :component-will-receive-props (fn [this new-argv])\n     :should-component-update (fn [this old-argv new-argv])\n     :component-will-mount (fn [this])\n     :component-did-mount (fn [this])\n     :component-will-update (fn [this new-argv])\n     :component-did-update (fn [this old-argv])\n     :component-will-unmount (fn [this])\n     :reagent-render (fn [args....])}   ;; or :render (fn [this])\n\n  Everything is optional, except either :reagent-render or :render."}, create-element {:protocol-inline nil, :meta {:file "/home/didier/clojupyter/website/target/cljsbuild/public/js/out/reagent/core.cljs", :line 20, :column 7, :end-line 20, :end-column 21, :arglists (quote ([type] [type props] [type props child] [type props child & children])), :doc "Create a native React element, by calling React.createElement directly.\n\n  That means the second argument must be a javascript object (or nil), and\n  that any Reagent hiccup forms must be processed with as-element. For example\n  like this:\n\n    (r/create-element \"div\" #js{:className \"foo\"}\n       \"Hi \" (r/as-element [:strong \"world!\"])\n\n  which is equivalent to\n\n    [:div.foo \"Hi\" [:strong \"world!\"]]", :top-fn {:variadic true, :max-fixed-arity 3, :method-params ([type] [type props] [type props child]), :arglists ([type] [type props] [type props child] [type props child & children]), :arglists-meta (nil nil nil nil)}}, :name reagent.core/create-element, :variadic true, :file "target/cljsbuild/public/js/out/reagent/core.cljs", :end-column 21, :top-fn {:variadic true, :max-fixed-arity 3, :method-params ([type] [type props] [type props child]), :arglists ([type] [type props] [type props child] [type props child & children]), :arglists-meta (nil nil nil nil)}, :method-params ([type] [type props] [type props child]), :protocol-impl nil, :arglists-meta (nil nil nil nil), :column 1, :line 20, :end-line 20, :max-fixed-arity 3, :fn-var true, :arglists ([type] [type props] [type props child] [type props child & children]), :doc "Create a native React element, by calling React.createElement directly.\n\n  That means the second argument must be a javascript object (or nil), and\n  that any Reagent hiccup forms must be processed with as-element. For example\n  like this:\n\n    (r/create-element \"div\" #js{:className \"foo\"}\n       \"Hi \" (r/as-element [:strong \"world!\"])\n\n  which is equivalent to\n\n    [:div.foo \"Hi\" [:strong \"world!\"]]"}}, :cljs.spec/registry-ref [], :require-macros {reagent.core reagent.core, ratom reagent.ratom, reagent.ratom reagent.ratom, deb reagent.debug, reagent.debug reagent.debug, reagent.interop reagent.interop}, :doc nil}