From f96055d99b0a6a6c50f5adafafabca1c8f3cdbde Mon Sep 17 00:00:00 2001 From: Julien Eluard Date: Fri, 29 Jun 2018 11:50:18 +0200 Subject: [PATCH] Deploy website Deploy website version based on c9caa54e2cfb6e55c9578e6132a1f0f0f40d8520 --- js/1E6A43F.js | 54 + js/CEA2105.js | 13 + js/cljs/core.cljs | 11539 +++++ js/cljs/core.cljs.cache.json | 1 + js/cljs/core.js | 37629 ++++++++++++++++ js/cljs/core/constants.js | 366 + js/cljs/nodejs.cljs | 27 + js/cljs/nodejscli.cljs | 22 + js/cljs/tools/reader.cljs | 944 + js/cljs/tools/reader.cljs.cache.json | 1 + js/cljs/tools/reader.js | 1782 + js/cljs/tools/reader/impl/commons.cljs | 131 + .../tools/reader/impl/commons.cljs.cache.json | 1 + js/cljs/tools/reader/impl/commons.js | 192 + js/cljs/tools/reader/impl/errors.cljs | 253 + .../tools/reader/impl/errors.cljs.cache.json | 1 + js/cljs/tools/reader/impl/errors.js | 422 + js/cljs/tools/reader/impl/inspect.cljs | 90 + .../tools/reader/impl/inspect.cljs.cache.json | 1 + js/cljs/tools/reader/impl/inspect.js | 155 + js/cljs/tools/reader/impl/utils.cljs | 97 + .../tools/reader/impl/utils.cljs.cache.json | 1 + js/cljs/tools/reader/impl/utils.js | 380 + js/cljs/tools/reader/reader_types.cljs | 283 + .../tools/reader/reader_types.cljs.cache.json | 1 + js/cljs/tools/reader/reader_types.js | 797 + js/cljsc_opts.edn | 1 + .../production/create-react-class.min.inc.js | 1298 + .../react-dom/production/react-dom.min.inc.js | 17098 +++++++ js/cljsjs/react/production/react.min.inc.js | 1740 + js/clojure/data.cljs | 162 + js/clojure/data.cljs.cache.json | 1 + js/clojure/data.js | 358 + js/clojure/set.cljs | 161 + js/clojure/set.cljs.cache.json | 1 + js/clojure/set.js | 394 + js/clojure/string.cljs | 289 + js/clojure/string.cljs.cache.json | 1 + js/clojure/string.js | 478 + js/clojure/walk.cljs | 97 + js/clojure/walk.cljs.cache.json | 1 + js/clojure/walk.js | 131 + js/goog/array/array.js | 1665 + js/goog/asserts/asserts.js | 369 + js/goog/async/nexttick.js | 265 + js/goog/base.js | 2921 ++ js/goog/bootstrap/nodejs.js | 137 + js/goog/debug/entrypointregistry.js | 159 + js/goog/debug/error.js | 63 + js/goog/dom/htmlelement.js | 29 + js/goog/dom/nodetype.js | 48 + js/goog/dom/tagname.js | 562 + js/goog/functions/functions.js | 483 + js/goog/iter/iter.js | 1284 + js/goog/labs/useragent/browser.js | 338 + js/goog/labs/useragent/engine.js | 156 + js/goog/labs/useragent/util.js | 147 + js/goog/math/integer.js | 808 + js/goog/math/long.js | 965 + js/goog/math/math.js | 448 + js/goog/object/object.js | 751 + js/goog/reflect/reflect.js | 138 + js/goog/string/string.js | 1641 + js/goog/string/stringbuffer.js | 103 + js/goog/structs/map.js | 458 + js/goog/structs/structs.js | 354 + js/goog/uri/uri.js | 1547 + js/goog/uri/utils.js | 1103 + js/pluto/reader.cljc.cache.json | 1 + js/pluto/reader.js | 226 + js/pluto/reader/blocks.cljc.cache.json | 1 + js/pluto/reader/blocks.js | 152 + js/pluto/reader/reference.cljc.cache.json | 1 + js/pluto/reader/reference.js | 46 + js/pluto/utils.cljc.cache.json | 1 + js/pluto/utils.js | 13 + js/re_frame/cofx.cljc | 114 + js/re_frame/cofx.cljc.cache.json | 1 + js/re_frame/cofx.js | 126 + js/re_frame/core.cljc | 237 + js/re_frame/core.cljc.cache.json | 1 + js/re_frame/core.js | 368 + js/re_frame/db.cljc | 11 + js/re_frame/db.cljc.cache.json | 1 + js/re_frame/db.js | 6 + js/re_frame/events.cljc | 68 + js/re_frame/events.cljc.cache.json | 1 + js/re_frame/events.js | 136 + js/re_frame/fx.cljc | 167 + js/re_frame/fx.cljc.cache.json | 1 + js/re_frame/fx.js | 444 + js/re_frame/interceptor.cljc | 201 + js/re_frame/interceptor.cljc.cache.json | 1 + js/re_frame/interceptor.js | 345 + js/re_frame/interop.cljs | 58 + js/re_frame/interop.cljs.cache.json | 1 + js/re_frame/interop.js | 96 + js/re_frame/loggers.cljc | 51 + js/re_frame/loggers.cljc.cache.json | 1 + js/re_frame/loggers.js | 73 + js/re_frame/registrar.cljc | 56 + js/re_frame/registrar.cljc.cache.json | 1 + js/re_frame/registrar.js | 120 + js/re_frame/router.cljc | 266 + js/re_frame/router.cljc.cache.json | 1 + js/re_frame/router.js | 731 + js/re_frame/std_interceptors.cljc | 358 + js/re_frame/std_interceptors.cljc.cache.json | 1 + js/re_frame/std_interceptors.js | 462 + js/re_frame/subs.cljc | 354 + js/re_frame/subs.cljc.cache.json | 1 + js/re_frame/subs.js | 901 + js/re_frame/trace.cljc | 125 + js/re_frame/trace.cljc.cache.json | 1 + js/re_frame/trace.js | 145 + js/re_frame/utils.cljc | 24 + js/re_frame/utils.cljc.cache.json | 1 + js/re_frame/utils.js | 43 + js/reagent/core.cljs | 348 + js/reagent/core.cljs.cache.json | 1 + js/reagent/core.js | 770 + js/reagent/debug.cljs | 27 + js/reagent/debug.cljs.cache.json | 1 + js/reagent/debug.js | 78 + js/reagent/dom.cljs | 70 + js/reagent/dom.cljs.cache.json | 1 + js/reagent/dom.js | 174 + js/reagent/impl/batching.cljs | 113 + js/reagent/impl/batching.cljs.cache.json | 1 + js/reagent/impl/batching.js | 248 + js/reagent/impl/component.cljs | 342 + js/reagent/impl/component.cljs.cache.json | 1 + js/reagent/impl/component.js | 681 + js/reagent/impl/template.cljs | 480 + js/reagent/impl/template.cljs.cache.json | 1 + js/reagent/impl/template.js | 729 + js/reagent/impl/util.cljs | 141 + js/reagent/impl/util.cljs.cache.json | 1 + js/reagent/impl/util.js | 552 + js/reagent/interop.cljs | 2 + js/reagent/interop.cljs.cache.json | 1 + js/reagent/interop.js | 4 + js/reagent/ratom.cljs | 595 + js/reagent/ratom.cljs.cache.json | 1 + js/reagent/ratom.js | 1637 + pluto.js | 716 + 146 files changed, 108593 insertions(+) create mode 100644 js/1E6A43F.js create mode 100644 js/CEA2105.js create mode 100644 js/cljs/core.cljs create mode 100644 js/cljs/core.cljs.cache.json create mode 100644 js/cljs/core.js create mode 100644 js/cljs/core/constants.js create mode 100644 js/cljs/nodejs.cljs create mode 100644 js/cljs/nodejscli.cljs create mode 100644 js/cljs/tools/reader.cljs create mode 100644 js/cljs/tools/reader.cljs.cache.json create mode 100644 js/cljs/tools/reader.js create mode 100644 js/cljs/tools/reader/impl/commons.cljs create mode 100644 js/cljs/tools/reader/impl/commons.cljs.cache.json create mode 100644 js/cljs/tools/reader/impl/commons.js create mode 100644 js/cljs/tools/reader/impl/errors.cljs create mode 100644 js/cljs/tools/reader/impl/errors.cljs.cache.json create mode 100644 js/cljs/tools/reader/impl/errors.js create mode 100644 js/cljs/tools/reader/impl/inspect.cljs create mode 100644 js/cljs/tools/reader/impl/inspect.cljs.cache.json create mode 100644 js/cljs/tools/reader/impl/inspect.js create mode 100644 js/cljs/tools/reader/impl/utils.cljs create mode 100644 js/cljs/tools/reader/impl/utils.cljs.cache.json create mode 100644 js/cljs/tools/reader/impl/utils.js create mode 100644 js/cljs/tools/reader/reader_types.cljs create mode 100644 js/cljs/tools/reader/reader_types.cljs.cache.json create mode 100644 js/cljs/tools/reader/reader_types.js create mode 100644 js/cljsc_opts.edn create mode 100644 js/cljsjs/create-react-class/production/create-react-class.min.inc.js create mode 100644 js/cljsjs/react-dom/production/react-dom.min.inc.js create mode 100644 js/cljsjs/react/production/react.min.inc.js create mode 100644 js/clojure/data.cljs create mode 100644 js/clojure/data.cljs.cache.json create mode 100644 js/clojure/data.js create mode 100644 js/clojure/set.cljs create mode 100644 js/clojure/set.cljs.cache.json create mode 100644 js/clojure/set.js create mode 100644 js/clojure/string.cljs create mode 100644 js/clojure/string.cljs.cache.json create mode 100644 js/clojure/string.js create mode 100644 js/clojure/walk.cljs create mode 100644 js/clojure/walk.cljs.cache.json create mode 100644 js/clojure/walk.js create mode 100644 js/goog/array/array.js create mode 100644 js/goog/asserts/asserts.js create mode 100644 js/goog/async/nexttick.js create mode 100644 js/goog/base.js create mode 100644 js/goog/bootstrap/nodejs.js create mode 100644 js/goog/debug/entrypointregistry.js create mode 100644 js/goog/debug/error.js create mode 100644 js/goog/dom/htmlelement.js create mode 100644 js/goog/dom/nodetype.js create mode 100644 js/goog/dom/tagname.js create mode 100644 js/goog/functions/functions.js create mode 100644 js/goog/iter/iter.js create mode 100644 js/goog/labs/useragent/browser.js create mode 100644 js/goog/labs/useragent/engine.js create mode 100644 js/goog/labs/useragent/util.js create mode 100644 js/goog/math/integer.js create mode 100644 js/goog/math/long.js create mode 100644 js/goog/math/math.js create mode 100644 js/goog/object/object.js create mode 100644 js/goog/reflect/reflect.js create mode 100644 js/goog/string/string.js create mode 100644 js/goog/string/stringbuffer.js create mode 100644 js/goog/structs/map.js create mode 100644 js/goog/structs/structs.js create mode 100644 js/goog/uri/uri.js create mode 100644 js/goog/uri/utils.js create mode 100644 js/pluto/reader.cljc.cache.json create mode 100644 js/pluto/reader.js create mode 100644 js/pluto/reader/blocks.cljc.cache.json create mode 100644 js/pluto/reader/blocks.js create mode 100644 js/pluto/reader/reference.cljc.cache.json create mode 100644 js/pluto/reader/reference.js create mode 100644 js/pluto/utils.cljc.cache.json create mode 100644 js/pluto/utils.js create mode 100644 js/re_frame/cofx.cljc create mode 100644 js/re_frame/cofx.cljc.cache.json create mode 100644 js/re_frame/cofx.js create mode 100644 js/re_frame/core.cljc create mode 100644 js/re_frame/core.cljc.cache.json create mode 100644 js/re_frame/core.js create mode 100644 js/re_frame/db.cljc create mode 100644 js/re_frame/db.cljc.cache.json create mode 100644 js/re_frame/db.js create mode 100644 js/re_frame/events.cljc create mode 100644 js/re_frame/events.cljc.cache.json create mode 100644 js/re_frame/events.js create mode 100644 js/re_frame/fx.cljc create mode 100644 js/re_frame/fx.cljc.cache.json create mode 100644 js/re_frame/fx.js create mode 100644 js/re_frame/interceptor.cljc create mode 100644 js/re_frame/interceptor.cljc.cache.json create mode 100644 js/re_frame/interceptor.js create mode 100644 js/re_frame/interop.cljs create mode 100644 js/re_frame/interop.cljs.cache.json create mode 100644 js/re_frame/interop.js create mode 100644 js/re_frame/loggers.cljc create mode 100644 js/re_frame/loggers.cljc.cache.json create mode 100644 js/re_frame/loggers.js create mode 100644 js/re_frame/registrar.cljc create mode 100644 js/re_frame/registrar.cljc.cache.json create mode 100644 js/re_frame/registrar.js create mode 100644 js/re_frame/router.cljc create mode 100644 js/re_frame/router.cljc.cache.json create mode 100644 js/re_frame/router.js create mode 100644 js/re_frame/std_interceptors.cljc create mode 100644 js/re_frame/std_interceptors.cljc.cache.json create mode 100644 js/re_frame/std_interceptors.js create mode 100644 js/re_frame/subs.cljc create mode 100644 js/re_frame/subs.cljc.cache.json create mode 100644 js/re_frame/subs.js create mode 100644 js/re_frame/trace.cljc create mode 100644 js/re_frame/trace.cljc.cache.json create mode 100644 js/re_frame/trace.js create mode 100644 js/re_frame/utils.cljc create mode 100644 js/re_frame/utils.cljc.cache.json create mode 100644 js/re_frame/utils.js create mode 100644 js/reagent/core.cljs create mode 100644 js/reagent/core.cljs.cache.json create mode 100644 js/reagent/core.js create mode 100644 js/reagent/debug.cljs create mode 100644 js/reagent/debug.cljs.cache.json create mode 100644 js/reagent/debug.js create mode 100644 js/reagent/dom.cljs create mode 100644 js/reagent/dom.cljs.cache.json create mode 100644 js/reagent/dom.js create mode 100644 js/reagent/impl/batching.cljs create mode 100644 js/reagent/impl/batching.cljs.cache.json create mode 100644 js/reagent/impl/batching.js create mode 100644 js/reagent/impl/component.cljs create mode 100644 js/reagent/impl/component.cljs.cache.json create mode 100644 js/reagent/impl/component.js create mode 100644 js/reagent/impl/template.cljs create mode 100644 js/reagent/impl/template.cljs.cache.json create mode 100644 js/reagent/impl/template.js create mode 100644 js/reagent/impl/util.cljs create mode 100644 js/reagent/impl/util.cljs.cache.json create mode 100644 js/reagent/impl/util.js create mode 100644 js/reagent/interop.cljs create mode 100644 js/reagent/interop.cljs.cache.json create mode 100644 js/reagent/interop.js create mode 100644 js/reagent/ratom.cljs create mode 100644 js/reagent/ratom.cljs.cache.json create mode 100644 js/reagent/ratom.js create mode 100644 pluto.js diff --git a/js/1E6A43F.js b/js/1E6A43F.js new file mode 100644 index 0000000..ce31e55 --- /dev/null +++ b/js/1E6A43F.js @@ -0,0 +1,54 @@ +goog.provide('cljs.nodejs'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +cljs.nodejs.require = require; +cljs.nodejs.process = process; +cljs.nodejs.enable_util_print_BANG_ = (function cljs$nodejs$enable_util_print_BANG_(){ +cljs.core._STAR_print_newline_STAR_ = false; + +cljs.core.set_print_fn_BANG_((function() { +var G__4061__delegate = function (args){ +return console.log.apply(console,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args)); +}; +var G__4061 = function (var_args){ +var args = null; +if (arguments.length > 0) { +var G__4062__i = 0, G__4062__a = new Array(arguments.length - 0); +while (G__4062__i < G__4062__a.length) {G__4062__a[G__4062__i] = arguments[G__4062__i + 0]; ++G__4062__i;} + args = new cljs.core.IndexedSeq(G__4062__a,0,null); +} +return G__4061__delegate.call(this,args);}; +G__4061.cljs$lang$maxFixedArity = 0; +G__4061.cljs$lang$applyTo = (function (arglist__4063){ +var args = cljs.core.seq(arglist__4063); +return G__4061__delegate(args); +}); +G__4061.cljs$core$IFn$_invoke$arity$variadic = G__4061__delegate; +return G__4061; +})() +); + +cljs.core.set_print_err_fn_BANG_((function() { +var G__4064__delegate = function (args){ +return console.error.apply(console,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args)); +}; +var G__4064 = function (var_args){ +var args = null; +if (arguments.length > 0) { +var G__4065__i = 0, G__4065__a = new Array(arguments.length - 0); +while (G__4065__i < G__4065__a.length) {G__4065__a[G__4065__i] = arguments[G__4065__i + 0]; ++G__4065__i;} + args = new cljs.core.IndexedSeq(G__4065__a,0,null); +} +return G__4064__delegate.call(this,args);}; +G__4064.cljs$lang$maxFixedArity = 0; +G__4064.cljs$lang$applyTo = (function (arglist__4066){ +var args = cljs.core.seq(arglist__4066); +return G__4064__delegate(args); +}); +G__4064.cljs$core$IFn$_invoke$arity$variadic = G__4064__delegate; +return G__4064; +})() +); + +return null; +}); diff --git a/js/CEA2105.js b/js/CEA2105.js new file mode 100644 index 0000000..9c2f5c7 --- /dev/null +++ b/js/CEA2105.js @@ -0,0 +1,13 @@ +goog.provide('cljs.nodejscli'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +goog.require('cljs.nodejs'); +goog.require('goog.object'); +if(COMPILED){ +goog.global = global; +} else { +} +if(cljs.core.fn_QMARK_(cljs.core._STAR_main_cli_fn_STAR_)){ +cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core._STAR_main_cli_fn_STAR_,cljs.core.drop.cljs$core$IFn$_invoke$arity$2((2),goog.object.get(process,"argv"))); +} else { +} diff --git a/js/cljs/core.cljs b/js/cljs/core.cljs new file mode 100644 index 0000000..6011f4e --- /dev/null +++ b/js/cljs/core.cljs @@ -0,0 +1,11539 @@ +; Copyright (c) Rich Hickey. All rights reserved. +; The use and distribution terms for this software are covered by the +; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +; which can be found in the file epl-v10.html at the root of this distribution. +; By using this software in any fashion, you are agreeing to be bound by +; the terms of this license. +; You must not remove this notice, or any other, from this software. + +(ns cljs.core + (:require goog.math.Long + goog.math.Integer + [goog.string :as gstring] + [goog.object :as gobject] + [goog.array :as garray] + [goog.Uri]) + (:import [goog.string StringBuffer])) + +;; next line is auto-generated by the build-script - Do not edit! +(def *clojurescript-version* "1.10.329") + +;; Setting of these Vars is in ClojureScript code is associated with intrinsics +;; that affect compilation state, but otherwise turn into no-ops in the emitted +;; JavaScript. + +;; The scope of *unchecked-if* is controlled by balanced pairs of set! calls. +(def *unchecked-if* false) +;; The scope of *unchecked-arrays* is file-scope: In JVM ClojureScript its side- +;; effect is to set same-named analyzer dynamic Var, which is unset via binding +;; scopes. In self-hosted it is cleared via cljs.js/post-file-side-effects. +(def *unchecked-arrays* false) +;; The scope of *warn-on-infer* is file-scope: Its side effect is to set the +;; cljs.analyzer/*cljs-warnings* dynamic Var, which is unset via binding scopes. +(def *warn-on-infer* false) + +(set! *unchecked-arrays* true) + +(defonce PROTOCOL_SENTINEL #js {}) + +(def MODULE_URIS nil) ;; set by compiler +(def MODULE_INFOS nil) ;; set by compiler + +(goog-define + ^{:dynamic true + :doc "Var bound to the name value of the compiler build :target option. + For example, if the compiler build :target is :nodejs, *target* will be bound + to \"nodejs\". *target* is a Google Closure define and can be set by compiler + :closure-defines option."} + *target* "default") + +(def + ^{:dynamic true + :doc "Var bound to the current namespace. Only used for bootstrapping." + :jsdoc ["@type {*}"]} + *ns* nil) + +(def + ^{:dynamic true + :jsdoc ["@type {*}"]} + *out* nil) + +(def + ^{:dynamic true} + *assert* true) + +(defonce + ^{:doc "Each runtime environment provides a different way to print output. + Whatever function *print-fn* is bound to will be passed any + Strings which should be printed." :dynamic true} + *print-fn* nil) + +(defn ^{:doc "Arranges to have tap functions executed via the supplied f, a + function of no arguments. Returns true if successful, false otherwise." :dynamic true} + *exec-tap-fn* + [f] + (and + (exists? js/setTimeout) + (js/setTimeout f 0) + true)) + +(defonce + ^{:doc "Each runtime environment provides a different way to print error output. + Whatever function *print-err-fn* is bound to will be passed any + Strings which should be printed." :dynamic true} + *print-err-fn* nil) + +(defn set-print-fn! + "Set *print-fn* to f." + [f] (set! *print-fn* f)) + +(defn set-print-err-fn! + "Set *print-err-fn* to f." + [f] (set! *print-err-fn* f)) + +(def + ^{:dynamic true + :doc "When set to true, output will be flushed whenever a newline is printed. + + Defaults to true."} + *flush-on-newline* true) + +(def + ^{:dynamic true + :doc "When set to logical false will drop newlines from printing calls. + This is to work around the implicit newlines emitted by standard JavaScript + console objects."} + *print-newline* true) + +(def + ^{:dynamic true + :doc "When set to logical false, strings and characters will be printed with + non-alphanumeric characters converted to the appropriate escape sequences. + + Defaults to true"} + *print-readably* true) + +(def + ^{:dynamic true + :doc "If set to logical true, when printing an object, its metadata will also + be printed in a form that can be read back by the reader. + + Defaults to false."} + *print-meta* false) + +(def + ^{:dynamic true + :doc "When set to logical true, objects will be printed in a way that preserves + their type when read in later. + + Defaults to false."} + *print-dup* false) + +(def + ^{:dynamic true + :doc "*print-namespace-maps* controls whether the printer will print + namespace map literal syntax. + + Defaults to false, but the REPL binds it to true."} + *print-namespace-maps* false) + +(def + ^{:dynamic true + :doc "*print-length* controls how many items of each collection the + printer will print. If it is bound to logical false, there is no + limit. Otherwise, it must be bound to an integer indicating the maximum + number of items of each collection to print. If a collection contains + more items, the printer will print items up to the limit followed by + '...' to represent the remaining items. The root binding is nil + indicating no limit." + :jsdoc ["@type {null|number}"]} + *print-length* nil) + +(def + ^{:dynamic true + :doc "*print-level* controls how many levels deep the printer will + print nested objects. If it is bound to logical false, there is no + limit. Otherwise, it must be bound to an integer indicating the maximum + level to print. Each argument to print is at level 0; if an argument is a + collection, its items are at level 1; and so on. If an object is a + collection and is at a level greater than or equal to the value bound to + *print-level*, the printer prints '#' to represent it. The root binding + is nil indicating no limit." + :jsdoc ["@type {null|number}"]} + *print-level* nil) + +(def + ^{:dynamic true + :doc "*print-fns-bodies* controls whether functions print their source or + only their names."} + *print-fn-bodies* false) + +(defonce + ^{:dynamic true + :jsdoc ["@type {*}"]} + *loaded-libs* nil) + +(defn- pr-opts [] + {:flush-on-newline *flush-on-newline* + :readably *print-readably* + :meta *print-meta* + :dup *print-dup* + :print-length *print-length*}) + +(declare into-array) + +(defn enable-console-print! + "Set *print-fn* to console.log" + [] + (set! *print-newline* false) + (set-print-fn! + (fn [] + (let [xs (js-arguments)] + (.apply (.-log js/console) js/console (garray/clone xs))))) + (set-print-err-fn! + (fn [] + (let [xs (js-arguments)] + (.apply (.-error js/console) js/console (garray/clone xs))))) + nil) + +(def + ^{:doc "bound in a repl thread to the most recent value printed"} + *1) + +(def + ^{:doc "bound in a repl thread to the second most recent value printed"} + *2) + +(def + ^{:doc "bound in a repl thread to the third most recent value printed"} + *3) + +(def + ^{:doc "bound in a repl thread to the most recent exception caught by the repl"} + *e) + +(defn truth_ + "Internal - do not use!" + [x] + (cljs.core/truth_ x)) + +(def not-native nil) + +(declare instance? Keyword) + +(defn ^boolean identical? + "Tests if 2 arguments are the same object" + [x y] + (cljs.core/identical? x y)) + +(defn ^boolean nil? + "Returns true if x is nil, false otherwise." + [x] + (coercive-= x nil)) + +(defn ^boolean array? + "Returns true if x is a JavaScript array." + [x] + (if (identical? *target* "nodejs") + (.isArray js/Array x) + (instance? js/Array x))) + +(defn ^boolean number? + "Returns true if x is a JavaScript number." + [x] + (cljs.core/number? x)) + +(defn ^boolean not + "Returns true if x is logical false, false otherwise." + [x] + (cond + (nil? x) true + (false? x) true + :else false)) + +(defn ^boolean some? + "Returns true if x is not nil, false otherwise." + [x] (not (nil? x))) + +(defn ^boolean object? + "Returns true if x's constructor is Object" + [x] + (if-not (nil? x) + (identical? (.-constructor x) js/Object) + false)) + +(defn ^boolean string? + "Returns true if x is a JavaScript string." + [x] + (goog/isString x)) + +(defn ^boolean char? + "Returns true if x is a JavaScript string of length one." + [x] + (and (string? x) (== 1 (.-length x)))) + +(defn ^boolean any? + "Returns true if given any argument." + [x] true) + +(set! *unchecked-if* true) +(defn ^boolean native-satisfies? + "Internal - do not use!" + [p x] + (let [x (if (nil? x) nil x)] + (cond + (unchecked-get p (goog/typeOf x)) true + (unchecked-get p "_") true + :else false))) +(set! *unchecked-if* false) + +(defn is_proto_ + [x] + (identical? (.-prototype (.-constructor x)) x)) + +(def + ^{:doc "When compiled for a command-line target, whatever function + *main-cli-fn* is set to will be called with the command-line + argv as arguments"} + *main-cli-fn* nil) + +(def + ^{:doc "A sequence of the supplied command line arguments, or nil if + none were supplied"} + *command-line-args* nil) + +(defn type + "Return x's constructor." + [x] + (when-not (nil? x) + (.-constructor x))) + +(defn missing-protocol [proto obj] + (let [ty (type obj) + ty (if (and ty (.-cljs$lang$type ty)) + (.-cljs$lang$ctorStr ty) + (goog/typeOf obj))] + (js/Error. + (.join (array "No protocol method " proto + " defined for type " ty ": " obj) "")))) + +(defn type->str [ty] + (if-let [s (.-cljs$lang$ctorStr ty)] + s + (str ty))) + +;; INTERNAL - do not use, only for Node.js +(defn load-file [file] + (when-not js/COMPILED + (cljs.core/load-file* file))) + +(if (and (exists? js/Symbol) + (identical? (goog/typeOf js/Symbol) "function")) + (def ITER_SYMBOL (.-iterator js/Symbol)) + (def ITER_SYMBOL "@@iterator")) + +(def ^{:jsdoc ["@enum {string}"]} + CHAR_MAP + #js {"-" "_" + ":" "_COLON_" + "+" "_PLUS_" + ">" "_GT_" + "<" "_LT_" + "=" "_EQ_" + "~" "_TILDE_" + "!" "_BANG_" + "@" "_CIRCA_" + "#" "_SHARP_" + "'" "_SINGLEQUOTE_" + "\\\"" "_DOUBLEQUOTE_" + "%" "_PERCENT_" + "^" "_CARET_" + "&" "_AMPERSAND_" + "*" "_STAR_" + "|" "_BAR_" + "{" "_LBRACE_" + "}" "_RBRACE_" + "[" "_LBRACK_" + "]" "_RBRACK_" + "/" "_SLASH_" + "\\\\" "_BSLASH_" + "?" "_QMARK_"}) + +(def ^{:jsdoc ["@enum {string}"]} + DEMUNGE_MAP + #js {"_" "-" + "_COLON_" ":" + "_PLUS_" "+" + "_GT_" ">" + "_LT_" "<" + "_EQ_" "=" + "_TILDE_" "~" + "_BANG_" "!" + "_CIRCA_" "@" + "_SHARP_" "#" + "_SINGLEQUOTE_" "'" + "_DOUBLEQUOTE_" "\\\"" + "_PERCENT_" "%" + "_CARET_" "^" + "_AMPERSAND_" "&" + "_STAR_" "*" + "_BAR_" "|" + "_LBRACE_" "{" + "_RBRACE_" "}" + "_LBRACK_" "[" + "_RBRACK_" "]" + "_SLASH_" "/" + "_BSLASH_" "\\\\" + "_QMARK_" "?"}) + +(def DEMUNGE_PATTERN nil) + +(defn system-time + "Returns highest resolution time offered by host in milliseconds." + [] + (cond + (and (exists? js/performance) + (not (nil? (. js/performance -now)))) + (.now js/performance) + + (and (exists? js/process) + (not (nil? (. js/process -hrtime)))) + (let [t (.hrtime js/process)] + (/ (+ (* (aget t 0) 1e9) (aget t 1)) 1e6)) + + :else (.getTime (js/Date.)))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; arrays ;;;;;;;;;;;;;;;; + +(declare apply) + +(defn ^array make-array + "Construct a JavaScript array of the specified dimensions. Accepts ignored + type argument for compatibility with Clojure. Note that there is no efficient + way to allocate multi-dimensional arrays in JavaScript; as such, this function + will run in polynomial time when called with 3 or more arguments." + ([size] + (js/Array. size)) + ([type size] + (make-array size)) + ([type size & more-sizes] + (let [dims more-sizes + dimarray (make-array size)] + (dotimes [i (alength dimarray)] + (aset dimarray i (apply make-array nil dims))) + dimarray))) + +(defn aclone + "Returns a javascript array, cloned from the passed in array" + [arr] + (let [len (alength arr) + new-arr (make-array len)] + (dotimes [i len] + (aset new-arr i (aget arr i))) + new-arr)) + +(defn ^array array + "Creates a new javascript array. +@param {...*} var_args" ;;array is a special case, don't emulate this doc string + [var-args] ;; [& items] + (let [a (js/Array. (alength (cljs.core/js-arguments)))] + (loop [i 0] + (if (< i (alength a)) + (do + (aset a i (aget (cljs.core/js-arguments) i)) + (recur (inc i))) + a)))) + +(defn- maybe-warn + [e] + (when *print-err-fn* + (*print-err-fn* e))) + +(defn- checked-aget + ([array idx] + (when-assert + (try + (assert (or (array? array) (goog/isArrayLike array))) + (assert (number? idx)) + (assert (not (neg? idx))) + (assert (< idx (alength array))) + (catch :default e + (maybe-warn e)))) + (unchecked-get array idx)) + ([array idx & idxs] + (apply checked-aget (checked-aget array idx) idxs))) + +(defn- checked-aset + ([array idx val] + (when-assert + (try + (assert (or (array? array) (goog/isArrayLike array))) + (assert (number? idx)) + (assert (not (neg? idx))) + (assert (< idx (alength array))) + (catch :default e + (maybe-warn e)))) + (unchecked-set array idx val)) + ([array idx idx2 & idxv] + (apply checked-aset (checked-aget array idx) idx2 idxv))) + +(defn- checked-aget' + ([array idx] + {:pre [(or (array? array) (goog/isArrayLike array)) + (number? idx) (not (neg? idx)) (< idx (alength array))]} + (unchecked-get array idx)) + ([array idx & idxs] + (apply checked-aget' (checked-aget' array idx) idxs))) + +(defn- checked-aset' + ([array idx val] + {:pre [(or (array? array) (goog/isArrayLike array)) + (number? idx) (not (neg? idx)) (< idx (alength array))]} + (unchecked-set array idx val)) + ([array idx idx2 & idxv] + (apply checked-aset' (checked-aget' array idx) idx2 idxv))) + +(defn aget + "Returns the value at the index/indices. Works on JavaScript arrays." + ([array idx] + (cljs.core/aget array idx)) + ([array idx & idxs] + (apply aget (aget array idx) idxs))) + +(defn aset + "Sets the value at the index/indices. Works on JavaScript arrays. + Returns val." + ([array idx val] + (cljs.core/aset array idx val)) + ([array idx idx2 & idxv] + (apply aset (aget array idx) idx2 idxv))) + +(defn ^number alength + "Returns the length of the array. Works on arrays of all types." + [array] + (cljs.core/alength array)) + +(declare reduce) + +(defn ^array into-array + "Returns an array with components set to the values in aseq. Optional type + argument accepted for compatibility with Clojure." + ([aseq] + (into-array nil aseq)) + ([type aseq] + (reduce (fn [a x] (.push a x) a) (array) aseq))) + +(defn js-invoke + "Invoke JavaScript object method via string. Needed when the + string is not a valid unquoted property name." + [obj s & args] + (.apply (unchecked-get obj s) obj (into-array args))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;; core protocols ;;;;;;;;;;;;; + +(defprotocol Fn + "Marker protocol") + +(defprotocol IFn + "Protocol for adding the ability to invoke an object as a function. + For example, a vector can also be used to look up a value: + ([1 2 3 4] 1) => 2" + (-invoke + [this] + [this a] + [this a b] + [this a b c] + [this a b c d] + [this a b c d e] + [this a b c d e f] + [this a b c d e f g] + [this a b c d e f g h] + [this a b c d e f g h i] + [this a b c d e f g h i j] + [this a b c d e f g h i j k] + [this a b c d e f g h i j k l] + [this a b c d e f g h i j k l m] + [this a b c d e f g h i j k l m n] + [this a b c d e f g h i j k l m n o] + [this a b c d e f g h i j k l m n o p] + [this a b c d e f g h i j k l m n o p q] + [this a b c d e f g h i j k l m n o p q r] + [this a b c d e f g h i j k l m n o p q r s] + [this a b c d e f g h i j k l m n o p q r s t] + [this a b c d e f g h i j k l m n o p q r s t rest])) + +(defprotocol ICloneable + "Protocol for cloning a value." + (^clj -clone [value] + "Creates a clone of value.")) + +(defprotocol ICounted + "Protocol for adding the ability to count a collection in constant time." + (^number -count [coll] + "Calculates the count of coll in constant time. Used by cljs.core/count.")) + +(defprotocol IEmptyableCollection + "Protocol for creating an empty collection." + (-empty [coll] + "Returns an empty collection of the same category as coll. Used + by cljs.core/empty.")) + +(defprotocol ICollection + "Protocol for adding to a collection." + (^clj -conj [coll o] + "Returns a new collection of coll with o added to it. The new item + should be added to the most efficient place, e.g. + (conj [1 2 3 4] 5) => [1 2 3 4 5] + (conj '(2 3 4 5) 1) => '(1 2 3 4 5)")) + +#_(defprotocol IOrdinal + (-index [coll])) + +(defprotocol IIndexed + "Protocol for collections to provide indexed-based access to their items." + (-nth [coll n] [coll n not-found] + "Returns the value at the index n in the collection coll. + Returns not-found if index n is out of bounds and not-found is supplied.")) + +(defprotocol ASeq + "Marker protocol indicating an array sequence.") + +(defprotocol ISeq + "Protocol for collections to provide access to their items as sequences." + (-first [coll] + "Returns the first item in the collection coll. Used by cljs.core/first.") + (^clj -rest [coll] + "Returns a new collection of coll without the first item. It should + always return a seq, e.g. + (rest []) => () + (rest nil) => ()")) + +(defprotocol INext + "Protocol for accessing the next items of a collection." + (^clj-or-nil -next [coll] + "Returns a new collection of coll without the first item. In contrast to + rest, it should return nil if there are no more items, e.g. + (next []) => nil + (next nil) => nil")) + +(defprotocol ILookup + "Protocol for looking up a value in a data structure." + (-lookup [o k] [o k not-found] + "Use k to look up a value in o. If not-found is supplied and k is not + a valid value that can be used for look up, not-found is returned.")) + +(defprotocol IAssociative + "Protocol for adding associativity to collections." + (^boolean -contains-key? [coll k] + "Returns true if k is a key in coll.") + #_(-entry-at [coll k]) + (^clj -assoc [coll k v] + "Returns a new collection of coll with a mapping from key k to + value v added to it.")) + +(defprotocol IFind + "Protocol for implementing entry finding in collections." + (-find [coll k] "Returns the map entry for key, or nil if key not present.")) + +(defprotocol IMap + "Protocol for adding mapping functionality to collections." + #_(-assoc-ex [coll k v]) + (^clj -dissoc [coll k] + "Returns a new collection of coll without the mapping for key k.")) + +(defprotocol IMapEntry + "Protocol for examining a map entry." + (-key [coll] + "Returns the key of the map entry.") + (-val [coll] + "Returns the value of the map entry.")) + +(defprotocol ISet + "Protocol for adding set functionality to a collection." + (^clj -disjoin [coll v] + "Returns a new collection of coll that does not contain v.")) + +(defprotocol IStack + "Protocol for collections to provide access to their items as stacks. The top + of the stack should be accessed in the most efficient way for the different + data structures." + (-peek [coll] + "Returns the item from the top of the stack. Is used by cljs.core/peek.") + (^clj -pop [coll] + "Returns a new stack without the item on top of the stack. Is used + by cljs.core/pop.")) + +(defprotocol IVector + "Protocol for adding vector functionality to collections." + (^clj -assoc-n [coll n val] + "Returns a new vector with value val added at position n.")) + +(defprotocol IDeref + "Protocol for adding dereference functionality to a reference." + (-deref [o] + "Returns the value of the reference o.")) + +(defprotocol IDerefWithTimeout + (-deref-with-timeout [o msec timeout-val])) + +(defprotocol IMeta + "Protocol for accessing the metadata of an object." + (^clj-or-nil -meta [o] + "Returns the metadata of object o.")) + +(defprotocol IWithMeta + "Protocol for adding metadata to an object." + (^clj -with-meta [o meta] + "Returns a new object with value of o and metadata meta added to it.")) + +(defprotocol IReduce + "Protocol for seq types that can reduce themselves. + Called by cljs.core/reduce." + (-reduce [coll f] [coll f start] + "f should be a function of 2 arguments. If start is not supplied, + returns the result of applying f to the first 2 items in coll, then + applying f to that result and the 3rd item, etc.")) + +(defprotocol IKVReduce + "Protocol for associative types that can reduce themselves + via a function of key and val. Called by cljs.core/reduce-kv." + (-kv-reduce [coll f init] + "Reduces an associative collection and returns the result. f should be + a function that takes three arguments.")) + +(defprotocol IEquiv + "Protocol for adding value comparison functionality to a type." + (^boolean -equiv [o other] + "Returns true if o and other are equal, false otherwise.")) + +(defprotocol IHash + "Protocol for adding hashing functionality to a type." + (-hash [o] + "Returns the hash code of o.")) + +(defprotocol ISeqable + "Protocol for adding the ability to a type to be transformed into a sequence." + (^clj-or-nil -seq [o] + "Returns a seq of o, or nil if o is empty.")) + +(defprotocol ISequential + "Marker interface indicating a persistent collection of sequential items") + +(defprotocol IList + "Marker interface indicating a persistent list") + +(defprotocol IRecord + "Marker interface indicating a record object") + +(defprotocol IReversible + "Protocol for reversing a seq." + (^clj -rseq [coll] + "Returns a seq of the items in coll in reversed order.")) + +(defprotocol ISorted + "Protocol for a collection which can represent their items + in a sorted manner. " + (^clj -sorted-seq [coll ascending?] + "Returns a sorted seq from coll in either ascending or descending order.") + (^clj -sorted-seq-from [coll k ascending?] + "Returns a sorted seq from coll in either ascending or descending order. + If ascending is true, the result should contain all items which are > or >= + than k. If ascending is false, the result should contain all items which + are < or <= than k, e.g. + (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 true) => (3 4 5) + (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 false) => (3 2 1)") + (-entry-key [coll entry] + "Returns the key for entry.") + (-comparator [coll] + "Returns the comparator for coll.")) + +(defprotocol IWriter + "Protocol for writing. Currently only implemented by StringBufferWriter." + (-write [writer s] + "Writes s with writer and returns the result.") + (-flush [writer] + "Flush writer.")) + +(defprotocol IPrintWithWriter + "The old IPrintable protocol's implementation consisted of building a giant + list of strings to concatenate. This involved lots of concat calls, + intermediate vectors, and lazy-seqs, and was very slow in some older JS + engines. IPrintWithWriter implements printing via the IWriter protocol, so it + be implemented efficiently in terms of e.g. a StringBuffer append." + (-pr-writer [o writer opts])) + +(defprotocol IPending + "Protocol for types which can have a deferred realization. Currently only + implemented by Delay and LazySeq." + (^boolean -realized? [x] + "Returns true if a value for x has been produced, false otherwise.")) + +(defprotocol IWatchable + "Protocol for types that can be watched. Currently only implemented by Atom." + (-notify-watches [this oldval newval] + "Calls all watchers with this, oldval and newval.") + (-add-watch [this key f] + "Adds a watcher function f to this. Keys must be unique per reference, + and can be used to remove the watch with -remove-watch.") + (-remove-watch [this key] + "Removes watcher that corresponds to key from this.")) + +(defprotocol IEditableCollection + "Protocol for collections which can transformed to transients." + (^clj -as-transient [coll] + "Returns a new, transient version of the collection, in constant time.")) + +(defprotocol ITransientCollection + "Protocol for adding basic functionality to transient collections." + (^clj -conj! [tcoll val] + "Adds value val to tcoll and returns tcoll.") + (^clj -persistent! [tcoll] + "Creates a persistent data structure from tcoll and returns it.")) + +(defprotocol ITransientAssociative + "Protocol for adding associativity to transient collections." + (^clj -assoc! [tcoll key val] + "Returns a new transient collection of tcoll with a mapping from key to + val added to it.")) + +(defprotocol ITransientMap + "Protocol for adding mapping functionality to transient collections." + (^clj -dissoc! [tcoll key] + "Returns a new transient collection of tcoll without the mapping for key.")) + +(defprotocol ITransientVector + "Protocol for adding vector functionality to transient collections." + (^clj -assoc-n! [tcoll n val] + "Returns tcoll with value val added at position n.") + (^clj -pop! [tcoll] + "Returns tcoll with the last item removed from it.")) + +(defprotocol ITransientSet + "Protocol for adding set functionality to a transient collection." + (^clj -disjoin! [tcoll v] + "Returns tcoll without v.")) + +(defprotocol IComparable + "Protocol for values that can be compared." + (^number -compare [x y] + "Returns a negative number, zero, or a positive number when x is logically + 'less than', 'equal to', or 'greater than' y.")) + +(defprotocol IChunk + "Protocol for accessing the items of a chunk." + (-drop-first [coll] + "Return a new chunk of coll with the first item removed.")) + +(defprotocol IChunkedSeq + "Protocol for accessing a collection as sequential chunks." + (-chunked-first [coll] + "Returns the first chunk in coll.") + (-chunked-rest [coll] + "Return a new collection of coll with the first chunk removed.")) + +(defprotocol IChunkedNext + "Protocol for accessing the chunks of a collection." + (-chunked-next [coll] + "Returns a new collection of coll without the first chunk.")) + +(defprotocol INamed + "Protocol for adding a name." + (^string -name [x] + "Returns the name String of x.") + (^string -namespace [x] + "Returns the namespace String of x.")) + +(defprotocol IAtom + "Marker protocol indicating an atom.") + +(defprotocol IReset + "Protocol for adding resetting functionality." + (-reset! [o new-value] + "Sets the value of o to new-value.")) + +(defprotocol ISwap + "Protocol for adding swapping functionality." + (-swap! [o f] [o f a] [o f a b] [o f a b xs] + "Swaps the value of o to be (apply f current-value-of-atom args).")) + +(defprotocol IVolatile + "Protocol for adding volatile functionality." + (-vreset! [o new-value] + "Sets the value of volatile o to new-value without regard for the + current value. Returns new-value.")) + +(defprotocol IIterable + "Protocol for iterating over a collection." + (-iterator [coll] + "Returns an iterator for coll.")) + +;; Printing support + +(deftype StringBufferWriter [sb] + IWriter + (-write [_ s] (.append sb s)) + (-flush [_] nil)) + +(defn pr-str* + "Support so that collections can implement toString without + loading all the printing machinery." + [^not-native obj] + (let [sb (StringBuffer.) + writer (StringBufferWriter. sb)] + (-pr-writer obj writer (pr-opts)) + (-flush writer) + (str sb))) + +;;;;;;;;;;;;;;;;;;; Murmur3 ;;;;;;;;;;;;;;; + +;;http://hg.openjdk.java.net/jdk7u/jdk7u6/jdk/file/8c2c5d63a17e/src/share/classes/java/lang/Integer.java +(defn ^number int-rotate-left [x n] + (bit-or + (bit-shift-left x n) + (unsigned-bit-shift-right x (- n)))) + +;; http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul +(if (and (exists? Math/imul) + (not (zero? (Math/imul 0xffffffff 5)))) + (defn ^number imul [a b] (Math/imul a b)) + (defn ^number imul [a b] + (let [ah (bit-and (unsigned-bit-shift-right a 16) 0xffff) + al (bit-and a 0xffff) + bh (bit-and (unsigned-bit-shift-right b 16) 0xffff) + bl (bit-and b 0xffff)] + (bit-or + (+ (* al bl) + (unsigned-bit-shift-right + (bit-shift-left (+ (* ah bl) (* al bh)) 16) 0)) 0)))) + +;; http://smhasher.googlecode.com/svn/trunk/MurmurHash3.cpp +(def m3-seed 0) +(def m3-C1 (int 0xcc9e2d51)) +(def m3-C2 (int 0x1b873593)) + +(defn ^number m3-mix-K1 [k1] + (-> (int k1) (imul m3-C1) (int-rotate-left 15) (imul m3-C2))) + +(defn ^number m3-mix-H1 [h1 k1] + (int (-> (int h1) (bit-xor (int k1)) (int-rotate-left 13) (imul 5) (+ (int 0xe6546b64))))) + +(defn ^number m3-fmix [h1 len] + (as-> (int h1) h1 + (bit-xor h1 len) + (bit-xor h1 (unsigned-bit-shift-right h1 16)) + (imul h1 (int 0x85ebca6b)) + (bit-xor h1 (unsigned-bit-shift-right h1 13)) + (imul h1 (int 0xc2b2ae35)) + (bit-xor h1 (unsigned-bit-shift-right h1 16)))) + +(defn ^number m3-hash-int [in] + (if (zero? in) + in + (let [k1 (m3-mix-K1 in) + h1 (m3-mix-H1 m3-seed k1)] + (m3-fmix h1 4)))) + +(defn ^number m3-hash-unencoded-chars [in] + (let [h1 (loop [i 1 h1 m3-seed] + (if (< i (.-length in)) + (recur (+ i 2) + (m3-mix-H1 h1 + (m3-mix-K1 + (bit-or (.charCodeAt in (dec i)) + (bit-shift-left (.charCodeAt in i) 16))))) + h1)) + h1 (if (== (bit-and (.-length in) 1) 1) + (bit-xor h1 (m3-mix-K1 (.charCodeAt in (dec (.-length in))))) + h1)] + (m3-fmix h1 (imul 2 (.-length in))))) + +;;;;;;;;;;;;;;;;;;; symbols ;;;;;;;;;;;;;;; + +(declare list Symbol = compare) + +;; Simple caching of string hashcode +(def string-hash-cache (js-obj)) +(def string-hash-cache-count 0) + +;;http://hg.openjdk.java.net/jdk7u/jdk7u6/jdk/file/8c2c5d63a17e/src/share/classes/java/lang/String.java +(defn hash-string* [s] + (if-not (nil? s) + (let [len (.-length s)] + (if (pos? len) + (loop [i 0 hash 0] + (if (< i len) + (recur (inc i) (+ (imul 31 hash) (.charCodeAt s i))) + hash)) + 0)) + 0)) + +(defn add-to-string-hash-cache [k] + (let [h (hash-string* k)] + (gobject/set string-hash-cache k h) + (set! string-hash-cache-count (inc string-hash-cache-count)) + h)) + +(defn hash-string [k] + (when (> string-hash-cache-count 255) + (set! string-hash-cache (js-obj)) + (set! string-hash-cache-count 0)) + (if (nil? k) + 0 + (let [h (unchecked-get string-hash-cache k)] + (if (number? h) + h + (add-to-string-hash-cache k))))) + +(defn hash + "Returns the hash code of its argument. Note this is the hash code + consistent with =." + [o] + (cond + (implements? IHash o) + (bit-xor (-hash ^not-native o) 0) + + (number? o) + (if (js/isFinite o) + (js-mod (Math/floor o) 2147483647) + (case o + ##Inf + 2146435072 + ##-Inf + -1048576 + 2146959360)) + + ;; note: mirrors Clojure's behavior on the JVM, where the hashCode is + ;; 1231 for true and 1237 for false + ;; http://docs.oracle.com/javase/7/docs/api/java/lang/Boolean.html#hashCode%28%29 + (true? o) 1231 + + (false? o) 1237 + + (string? o) + (m3-hash-int (hash-string o)) + + (instance? js/Date o) + (bit-xor (.valueOf o) 0) + + (nil? o) 0 + + :else + (bit-xor (-hash o) 0))) + +(defn hash-combine [seed hash] + ; a la boost + (bit-xor seed + (+ hash 0x9e3779b9 + (bit-shift-left seed 6) + (bit-shift-right seed 2)))) + +(defn ^boolean instance? + "Evaluates x and tests if it is an instance of the type + c. Returns true or false" + [c x] + (cljs.core/instance? c x)) + +(defn ^boolean symbol? + "Return true if x is a Symbol" + [x] + (instance? Symbol x)) + +(defn- hash-symbol [sym] + (hash-combine + (m3-hash-unencoded-chars (.-name sym)) + (hash-string (.-ns sym)))) + +(defn- compare-symbols [a b] + (cond + (identical? (.-str a) (.-str b)) 0 + (and (not (.-ns a)) (.-ns b)) -1 + (.-ns a) (if-not (.-ns b) + 1 + (let [nsc (garray/defaultCompare (.-ns a) (.-ns b))] + (if (== 0 nsc) + (garray/defaultCompare (.-name a) (.-name b)) + nsc))) + :default (garray/defaultCompare (.-name a) (.-name b)))) + +(declare get) + +(deftype Symbol [ns name str ^:mutable _hash _meta] + Object + (toString [_] str) + (equiv [this other] (-equiv this other)) + + IEquiv + (-equiv [_ other] + (if (instance? Symbol other) + (identical? str (.-str other)) + false)) + + IFn + (-invoke [sym coll] + (get coll sym)) + (-invoke [sym coll not-found] + (get coll sym not-found)) + + IMeta + (-meta [_] _meta) + + IWithMeta + (-with-meta [_ new-meta] (Symbol. ns name str _hash new-meta)) + + IHash + (-hash [sym] + (caching-hash sym hash-symbol _hash)) + + INamed + (-name [_] name) + (-namespace [_] ns) + + IPrintWithWriter + (-pr-writer [o writer _] (-write writer str))) + +(defn symbol + "Returns a Symbol with the given namespace and name." + ([name] + (if (symbol? name) + name + (let [idx (.indexOf name "/")] + (if (< idx 1) + (symbol nil name) + (symbol (.substring name 0 idx) + (.substring name (inc idx) (. name -length))))))) + ([ns name] + (let [sym-str (if-not (nil? ns) + (str ns "/" name) + name)] + (Symbol. ns name sym-str nil nil)))) + +(deftype Var [val sym _meta] + Object + (isMacro [_] + (. (val) -cljs$lang$macro)) + (toString [_] + (str "#'" sym)) + IDeref + (-deref [_] (val)) + IMeta + (-meta [_] _meta) + IWithMeta + (-with-meta [_ new-meta] + (Var. val sym new-meta)) + IEquiv + (-equiv [this other] + (if (instance? Var other) + (= (.-sym this) (.-sym other)) + false)) + IHash + (-hash [_] + (hash-symbol sym)) + Fn + IFn + (-invoke [_] + ((val))) + (-invoke [_ a] + ((val) a)) + (-invoke [_ a b] + ((val) a b)) + (-invoke [_ a b c] + ((val) a b c)) + (-invoke [_ a b c d] + ((val) a b c d)) + (-invoke [_ a b c d e] + ((val) a b c d e)) + (-invoke [_ a b c d e f] + ((val) a b c d e f)) + (-invoke [_ a b c d e f g] + ((val) a b c d e f g)) + (-invoke [_ a b c d e f g h] + ((val) a b c d e f g h)) + (-invoke [_ a b c d e f g h i] + ((val) a b c d e f g h i)) + (-invoke [_ a b c d e f g h i j] + ((val) a b c d e f g h i j)) + (-invoke [_ a b c d e f g h i j k] + ((val) a b c d e f g h i j k)) + (-invoke [_ a b c d e f g h i j k l] + ((val) a b c d e f g h i j k l)) + (-invoke [_ a b c d e f g h i j k l m] + ((val) a b c d e f g h i j k l m)) + (-invoke [_ a b c d e f g h i j k l m n] + ((val) a b c d e f g h i j k l m n)) + (-invoke [_ a b c d e f g h i j k l m n o] + ((val) a b c d e f g h i j k l m n o)) + (-invoke [_ a b c d e f g h i j k l m n o p] + ((val) a b c d e f g h i j k l m n o p)) + (-invoke [_ a b c d e f g h i j k l m n o p q] + ((val) a b c d e f g h i j k l m n o p q)) + (-invoke [_ a b c d e f g h i j k l m n o p q r] + ((val) a b c d e f g h i j k l m n o p q r)) + (-invoke [_ a b c d e f g h i j k l m n o p q r s] + ((val) a b c d e f g h i j k l m n o p q r s)) + (-invoke [_ a b c d e f g h i j k l m n o p q r s t] + ((val) a b c d e f g h i j k l m n o p q r s t)) + (-invoke [_ a b c d e f g h i j k l m n o p q r s t rest] + (apply (val) a b c d e f g h i j k l m n o p q r s t rest))) + +(defn ^boolean var? + "Returns true if v is of type cljs.core.Var" + [v] + (instance? cljs.core.Var v)) + +;;;;;;;;;;;;;;;;;;; fundamentals ;;;;;;;;;;;;;;; + +(declare array-seq prim-seq IndexedSeq) + +(defn ^boolean iterable? + "Return true if x implements IIterable protocol." + [x] + (satisfies? IIterable x)) + +(defn clone + "Clone the supplied value which must implement ICloneable." + [value] + (-clone value)) + +(defn ^boolean cloneable? + "Return true if x implements ICloneable protocol." + [value] + (satisfies? ICloneable value)) + +(defn ^seq seq + "Returns a seq on the collection. If the collection is + empty, returns nil. (seq nil) returns nil. seq also works on + Strings." + [coll] + (when-not (nil? coll) + (cond + (implements? ISeqable coll) + (-seq ^not-native coll) + + (array? coll) + (when-not (zero? (alength coll)) + (IndexedSeq. coll 0 nil)) + + (string? coll) + (when-not (zero? (alength coll)) + (IndexedSeq. coll 0 nil)) + + (native-satisfies? ISeqable coll) + (-seq coll) + + :else (throw (js/Error. (str coll " is not ISeqable")))))) + +(defn first + "Returns the first item in the collection. Calls seq on its + argument. If coll is nil, returns nil." + [coll] + (when-not (nil? coll) + (if (implements? ISeq coll) + (-first ^not-native coll) + (let [s (seq coll)] + (when-not (nil? s) + (-first s)))))) + +(defn ^seq rest + "Returns a possibly empty seq of the items after the first. Calls seq on its + argument." + [coll] + (if-not (nil? coll) + (if (implements? ISeq coll) + (-rest ^not-native coll) + (let [s (seq coll)] + (if s + (-rest ^not-native s) + ()))) + ())) + +(defn ^seq next + "Returns a seq of the items after the first. Calls seq on its + argument. If there are no more items, returns nil" + [coll] + (when-not (nil? coll) + (if (implements? INext coll) + (-next ^not-native coll) + (seq (rest coll))))) + +(defn ^boolean = + "Equality. Returns true if x equals y, false if not. Compares + numbers and collections in a type-independent manner. Clojure's immutable data + structures define -equiv (and thus =) as a value, not an identity, + comparison." + ([x] true) + ([x y] + (if (nil? x) + (nil? y) + (or (identical? x y) + ^boolean (-equiv x y)))) + ([x y & more] + (if (= x y) + (if (next more) + (recur y (first more) (next more)) + (= y (first more))) + false))) + +;; EXPERIMENTAL: subject to change +(deftype ES6Iterator [^:mutable s] + Object + (next [_] + (if-not (nil? s) + (let [x (first s)] + (set! s (next s)) + #js {:value x :done false}) + #js {:value nil :done true}))) + +(defn es6-iterator + "EXPERIMENTAL: Return a ES2015 compatible iterator for coll." + [coll] + (ES6Iterator. (seq coll))) + +(declare es6-iterator-seq) + +(deftype ES6IteratorSeq [value iter ^:mutable _rest] + ISeqable + (-seq [this] this) + ISeq + (-first [_] value) + (-rest [_] + (when (nil? _rest) + (set! _rest (es6-iterator-seq iter))) + _rest)) + +(defn es6-iterator-seq + "EXPERIMENTAL: Given an ES2015 compatible iterator return a seq." + [iter] + (let [v (.next iter)] + (if (.-done v) + () + (ES6IteratorSeq. (.-value v) iter nil)))) + +;;;;;;;;;;;;;;;;;;; Murmur3 Helpers ;;;;;;;;;;;;;;;; + +(defn ^number mix-collection-hash + "Mix final collection hash for ordered or unordered collections. + hash-basis is the combined collection hash, count is the number + of elements included in the basis. Note this is the hash code + consistent with =, different from .hashCode. + See http://clojure.org/data_structures#hash for full algorithms." + [hash-basis count] + (let [h1 m3-seed + k1 (m3-mix-K1 hash-basis) + h1 (m3-mix-H1 h1 k1)] + (m3-fmix h1 count))) + +(defn ^number hash-ordered-coll + "Returns the hash code, consistent with =, for an external ordered + collection implementing Iterable. + See http://clojure.org/data_structures#hash for full algorithms." + [coll] + (loop [n 0 hash-code 1 coll (seq coll)] + (if-not (nil? coll) + (recur (inc n) (bit-or (+ (imul 31 hash-code) (hash (first coll))) 0) + (next coll)) + (mix-collection-hash hash-code n)))) + +(def ^:private empty-ordered-hash + (mix-collection-hash 1 0)) + +(defn ^number hash-unordered-coll + "Returns the hash code, consistent with =, for an external unordered + collection implementing Iterable. For maps, the iterator should + return map entries whose hash is computed as + (hash-ordered-coll [k v]). + See http://clojure.org/data_structures#hash for full algorithms." + [coll] + (loop [n 0 hash-code 0 coll (seq coll)] + (if-not (nil? coll) + (recur (inc n) (bit-or (+ hash-code (hash (first coll))) 0) (next coll)) + (mix-collection-hash hash-code n)))) + +(def ^:private empty-unordered-hash + (mix-collection-hash 0 0)) + +;;;;;;;;;;;;;;;;;;; protocols on primitives ;;;;;;;; +(declare hash-map list equiv-sequential) + +(extend-type nil + ICounted + (-count [_] 0)) + +;; TODO: we should remove this and handle date equality checking +;; by some other means, probably by adding a new primitive type +;; case to the hash table lookup - David + +(extend-type js/Date + IEquiv + (-equiv [o other] + (and (instance? js/Date other) + (== (.valueOf o) (.valueOf other)))) + + IComparable + (-compare [this other] + (if (instance? js/Date other) + (garray/defaultCompare (.valueOf this) (.valueOf other)) + (throw (js/Error. (str "Cannot compare " this " to " other)))))) + +(defprotocol Inst + (inst-ms* [inst])) + +(extend-protocol Inst + js/Date + (inst-ms* [inst] (.getTime inst))) + +(defn inst-ms + "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT" + [inst] + (inst-ms* inst)) + +(defn ^boolean inst? + "Return true if x satisfies Inst" + [x] + (satisfies? Inst x)) + +(extend-type number + IEquiv + (-equiv [x o] (identical? x o))) + +(declare with-meta) + +(extend-type function + Fn + IMeta + (-meta [_] nil)) + +(extend-type default + IHash + (-hash [o] + (goog/getUid o))) + +;;this is primitive because & emits call to array-seq +(defn inc + "Returns a number one greater than num." + [x] (cljs.core/+ x 1)) + +(declare deref) + +(deftype Reduced [val] + IDeref + (-deref [o] val)) + +(defn reduced + "Wraps x in a way such that a reduce will terminate with the value x" + [x] + (Reduced. x)) + +(defn ^boolean reduced? + "Returns true if x is the result of a call to reduced" + [r] + (instance? Reduced r)) + +(defn ensure-reduced + "If x is already reduced?, returns it, else returns (reduced x)" + [x] + (if (reduced? x) x (reduced x))) + +(defn unreduced + "If x is reduced?, returns (deref x), else returns x" + [x] + (if (reduced? x) (deref x) x)) + +;; generic to all refs +;; (but currently hard-coded to atom!) +(defn deref + "Also reader macro: @var/@atom/@delay. Returns the + most-recently-committed value of ref. When applied to a var + or atom, returns its current state. When applied to a delay, forces + it if not already forced. See also - realized?." + [o] + (-deref o)) + +(defn- ci-reduce + "Accepts any collection which satisfies the ICount and IIndexed protocols and +reduces them without incurring seq initialization" + ([cicoll f] + (let [cnt (-count cicoll)] + (if (zero? cnt) + (f) + (loop [val (-nth cicoll 0), n 1] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + ([cicoll f val] + (let [cnt (-count cicoll)] + (loop [val val, n 0] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val)))) + ([cicoll f val idx] + (let [cnt (-count cicoll)] + (loop [val val, n idx] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + +(defn- array-reduce + ([arr f] + (let [cnt (alength arr)] + (if (zero? (alength arr)) + (f) + (loop [val (aget arr 0), n 1] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + ([arr f val] + (let [cnt (alength arr)] + (loop [val val, n 0] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val)))) + ([arr f val idx] + (let [cnt (alength arr)] + (loop [val val, n idx] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + +(declare hash-coll cons drop count nth RSeq List) + +(defn ^boolean counted? + "Returns true if coll implements count in constant time" + [x] (satisfies? ICounted x)) + +(defn ^boolean indexed? + "Returns true if coll implements nth in constant time" + [x] (satisfies? IIndexed x)) + +(defn- -indexOf + ([coll x] + (-indexOf coll x 0)) + ([coll x start] + (let [len (count coll)] + (if (>= start len) + -1 + (loop [idx (cond + (pos? start) start + (neg? start) (max 0 (+ start len)) + :else start)] + (if (< idx len) + (if (= (nth coll idx) x) + idx + (recur (inc idx))) + -1)))))) + +(defn- -lastIndexOf + ([coll x] + (-lastIndexOf coll x (count coll))) + ([coll x start] + (let [len (count coll)] + (if (zero? len) + -1 + (loop [idx (cond + (pos? start) (min (dec len) start) + (neg? start) (+ len start) + :else start)] + (if (>= idx 0) + (if (= (nth coll idx) x) + idx + (recur (dec idx))) + -1)))))) + +(deftype IndexedSeqIterator [arr ^:mutable i] + Object + (hasNext [_] + (< i (alength arr))) + (next [_] + (let [ret (aget arr i)] + (set! i (inc i)) + ret))) + +(deftype IndexedSeq [arr i meta] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ICloneable + (-clone [_] (IndexedSeq. arr i meta)) + + ISeqable + (-seq [this] + (when (< i (alength arr)) + this)) + + IMeta + (-meta [coll] meta) + IWithMeta + (-with-meta [coll new-meta] + (IndexedSeq. arr i new-meta)) + + ASeq + ISeq + (-first [_] (aget arr i)) + (-rest [_] (if (< (inc i) (alength arr)) + (IndexedSeq. arr (inc i) nil) + (list))) + + INext + (-next [_] (if (< (inc i) (alength arr)) + (IndexedSeq. arr (inc i) nil) + nil)) + + ICounted + (-count [_] + (max 0 (- (alength arr) i))) + + IIndexed + (-nth [coll n] + (let [i (+ n i)] + (if (and (<= 0 i) (< i (alength arr))) + (aget arr i) + (throw (js/Error. "Index out of bounds"))))) + (-nth [coll n not-found] + (let [i (+ n i)] + (if (and (<= 0 i) (< i (alength arr))) + (aget arr i) + not-found))) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IIterable + (-iterator [coll] + (IndexedSeqIterator. arr i)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (.-EMPTY List)) + + IReduce + (-reduce [coll f] + (array-reduce arr f (aget arr i) (inc i))) + (-reduce [coll f start] + (array-reduce arr f start i)) + + IHash + (-hash [coll] (hash-ordered-coll coll)) + + IReversible + (-rseq [coll] + (let [c (-count coll)] + (if (pos? c) + (RSeq. coll (dec c) nil))))) + +(es6-iterable IndexedSeq) + +(defn prim-seq + "Create seq from a primitive JavaScript Array-like." + ([prim] + (prim-seq prim 0)) + ([prim i] + (when (< i (alength prim)) + (IndexedSeq. prim i nil)))) + +(defn array-seq + "Create a seq from a JavaScript array." + ([array] + (prim-seq array 0)) + ([array i] + (prim-seq array i))) + +(declare with-meta seq-reduce) + +(deftype RSeq [ci i meta] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ICloneable + (-clone [_] (RSeq. ci i meta)) + + IMeta + (-meta [coll] meta) + IWithMeta + (-with-meta [coll new-meta] + (RSeq. ci i new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ISeq + (-first [coll] + (-nth ci i)) + (-rest [coll] + (if (pos? i) + (RSeq. ci (dec i) nil) + ())) + + INext + (-next [coll] + (when (pos? i) + (RSeq. ci (dec i) nil))) + + ICounted + (-count [coll] (inc i)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + IHash + (-hash [coll] (hash-ordered-coll coll)) + + IReduce + (-reduce [col f] (seq-reduce f col)) + (-reduce [col f start] (seq-reduce f start col))) + +(es6-iterable RSeq) + +(defn second + "Same as (first (next x))" + [coll] + (first (next coll))) + +(defn ffirst + "Same as (first (first x))" + [coll] + (first (first coll))) + +(defn nfirst + "Same as (next (first x))" + [coll] + (next (first coll))) + +(defn fnext + "Same as (first (next x))" + [coll] + (first (next coll))) + +(defn nnext + "Same as (next (next x))" + [coll] + (next (next coll))) + +(defn last + "Return the last item in coll, in linear time" + [s] + (let [sn (next s)] + (if-not (nil? sn) + (recur sn) + (first s)))) + +(extend-type default + IEquiv + (-equiv [x o] (identical? x o))) + +(defn conj + "conj[oin]. Returns a new collection with the xs + 'added'. (conj nil item) returns (item). The 'addition' may + happen at different 'places' depending on the concrete type." + ([] []) + ([coll] coll) + ([coll x] + (if-not (nil? coll) + (-conj coll x) + (list x))) + ([coll x & xs] + (if xs + (recur (conj coll x) (first xs) (next xs)) + (conj coll x)))) + +(defn empty + "Returns an empty collection of the same category as coll, or nil" + [coll] + (when-not (nil? coll) + (-empty coll))) + +(defn- accumulating-seq-count [coll] + (loop [s (seq coll) acc 0] + (if (counted? s) ; assumes nil is counted, which it currently is + (+ acc (-count s)) + (recur (next s) (inc acc))))) + +(defn count + "Returns the number of items in the collection. (count nil) returns + 0. Also works on strings, arrays, and Maps" + [coll] + (if-not (nil? coll) + (cond + (implements? ICounted coll) + (-count ^not-native coll) + + (array? coll) + (alength coll) + + (string? coll) + (.-length coll) + + (implements? ISeqable coll) + (accumulating-seq-count coll) + + :else (-count coll)) + 0)) + +(defn- linear-traversal-nth + ([coll n] + (cond + (nil? coll) (throw (js/Error. "Index out of bounds")) + (zero? n) (if (seq coll) + (first coll) + (throw (js/Error. "Index out of bounds"))) + (indexed? coll) (-nth coll n) + (seq coll) (recur (next coll) (dec n)) + :else (throw (js/Error. "Index out of bounds")))) + ([coll n not-found] + (cond + (nil? coll) not-found + (zero? n) (if (seq coll) + (first coll) + not-found) + (indexed? coll) (-nth coll n not-found) + (seq coll) (recur (next coll) (dec n) not-found) + :else not-found))) + +(defn nth + "Returns the value at the index. get returns nil if index out of + bounds, nth throws an exception unless not-found is supplied. nth + also works for strings, arrays, regex Matchers and Lists, and, + in O(n) time, for sequences." + ([coll n] + (cond + (not (number? n)) + (throw (js/Error. "Index argument to nth must be a number")) + + (nil? coll) + coll + + (implements? IIndexed coll) + (-nth ^not-native coll n) + + (array? coll) + (if (and (>= n 0) (< n (.-length coll))) + (aget coll n) + (throw (js/Error. "Index out of bounds"))) + + (string? coll) + (if (and (>= n 0) (< n (.-length coll))) + (.charAt coll n) + (throw (js/Error. "Index out of bounds"))) + + (or (implements? ISeq coll) + (implements? ISequential coll)) + (linear-traversal-nth coll n) + + (native-satisfies? IIndexed coll) + (-nth coll n) + + :else + (throw (js/Error. (str "nth not supported on this type " + (type->str (type coll))))))) + ([coll n not-found] + (cond + (not (number? n)) + (throw (js/Error. "Index argument to nth must be a number.")) + + (nil? coll) + not-found + + (implements? IIndexed coll) + (-nth ^not-native coll n not-found) + + (array? coll) + (if (and (>= n 0) (< n (.-length coll))) + (aget coll n) + not-found) + + (string? coll) + (if (and (>= n 0) (< n (.-length coll))) + (.charAt coll n) + not-found) + + (or (implements? ISeq coll) + (implements? ISequential coll)) + (linear-traversal-nth coll n not-found) + + (native-satisfies? IIndexed coll) + (-nth coll n not-found) + + :else + (throw (js/Error. (str "nth not supported on this type " + (type->str (type coll)))))))) + +(defn nthrest + "Returns the nth rest of coll, coll when n is 0." + [coll n] + (loop [n n xs coll] + (if-let [xs (and (pos? n) (seq xs))] + (recur (dec n) (rest xs)) + xs))) + +(defn get + "Returns the value mapped to key, not-found or nil if key not present." + ([o k] + (when-not (nil? o) + (cond + (implements? ILookup o) + (-lookup ^not-native o k) + + (array? o) + (when (and (some? k) (< k (.-length o))) + (aget o (int k))) + + (string? o) + (when (and (some? k) (< k (.-length o))) + (.charAt o (int k))) + + (native-satisfies? ILookup o) + (-lookup o k) + + :else nil))) + ([o k not-found] + (if-not (nil? o) + (cond + (implements? ILookup o) + (-lookup ^not-native o k not-found) + + (array? o) + (if (and (some? k) (>= k 0) (< k (.-length o))) + (aget o (int k)) + not-found) + + (string? o) + (if (and (some? k) (>= k 0) (< k (.-length o))) + (.charAt o (int k)) + not-found) + + (native-satisfies? ILookup o) + (-lookup o k not-found) + + :else not-found) + not-found))) + +(declare PersistentHashMap PersistentArrayMap MapEntry) + +(defn assoc + "assoc[iate]. When applied to a map, returns a new map of the + same (hashed/sorted) type, that contains the mapping of key(s) to + val(s). When applied to a vector, returns a new vector that + contains val at index." + ([coll k v] + (if-not (nil? coll) + (-assoc coll k v) + (array-map k v))) + ([coll k v & kvs] + (let [ret (assoc coll k v)] + (if kvs + (recur ret (first kvs) (second kvs) (nnext kvs)) + ret)))) + +(defn dissoc + "dissoc[iate]. Returns a new map of the same (hashed/sorted) type, + that does not contain a mapping for key(s)." + ([coll] coll) + ([coll k] + (when-not (nil? coll) + (-dissoc coll k))) + ([coll k & ks] + (when-not (nil? coll) + (let [ret (dissoc coll k)] + (if ks + (recur ret (first ks) (next ks)) + ret))))) + +(defn ^boolean fn? + "Return true if f is a JavaScript function or satisfies the Fn protocol." + [f] + (or ^boolean (goog/isFunction f) (satisfies? Fn f))) + +(deftype MetaFn [afn meta] + IMeta + (-meta [_] meta) + IWithMeta + (-with-meta [_ new-meta] + (MetaFn. afn new-meta)) + Fn + IFn + (-invoke [_] + (afn)) + (-invoke [_ a] + (afn a)) + (-invoke [_ a b] + (afn a b)) + (-invoke [_ a b c] + (afn a b c)) + (-invoke [_ a b c d] + (afn a b c d)) + (-invoke [_ a b c d e] + (afn a b c d e)) + (-invoke [_ a b c d e f] + (afn a b c d e f)) + (-invoke [_ a b c d e f g] + (afn a b c d e f g)) + (-invoke [_ a b c d e f g h] + (afn a b c d e f g h)) + (-invoke [_ a b c d e f g h i] + (afn a b c d e f g h i)) + (-invoke [_ a b c d e f g h i j] + (afn a b c d e f g h i j)) + (-invoke [_ a b c d e f g h i j k] + (afn a b c d e f g h i j k)) + (-invoke [_ a b c d e f g h i j k l] + (afn a b c d e f g h i j k l)) + (-invoke [_ a b c d e f g h i j k l m] + (afn a b c d e f g h i j k l m)) + (-invoke [_ a b c d e f g h i j k l m n] + (afn a b c d e f g h i j k l m n)) + (-invoke [_ a b c d e f g h i j k l m n o] + (afn a b c d e f g h i j k l m n o)) + (-invoke [_ a b c d e f g h i j k l m n o p] + (afn a b c d e f g h i j k l m n o p)) + (-invoke [_ a b c d e f g h i j k l m n o p q] + (afn a b c d e f g h i j k l m n o p q)) + (-invoke [_ a b c d e f g h i j k l m n o p q r] + (afn a b c d e f g h i j k l m n o p q r)) + (-invoke [_ a b c d e f g h i j k l m n o p q r s] + (afn a b c d e f g h i j k l m n o p q r s)) + (-invoke [_ a b c d e f g h i j k l m n o p q r s t] + (afn a b c d e f g h i j k l m n o p q r s t)) + (-invoke [_ a b c d e f g h i j k l m n o p q r s t rest] + (apply afn a b c d e f g h i j k l m n o p q r s t rest))) + +(defn with-meta + "Returns an object of the same type and value as obj, with + map m as its metadata." + [o meta] + (if ^boolean (goog/isFunction o) + (MetaFn. o meta) + (when-not (nil? o) + (-with-meta o meta)))) + +(defn meta + "Returns the metadata of obj, returns nil if there is no metadata." + [o] + (when (and (not (nil? o)) + (satisfies? IMeta o)) + (-meta o))) + +(defn peek + "For a list or queue, same as first, for a vector, same as, but much + more efficient than, last. If the collection is empty, returns nil." + [coll] + (when-not (nil? coll) + (-peek coll))) + +(defn pop + "For a list or queue, returns a new list/queue without the first + item, for a vector, returns a new vector without the last item. + Note - not the same as next/butlast." + [coll] + (when-not (nil? coll) + (-pop coll))) + +(defn disj + "disj[oin]. Returns a new set of the same (hashed/sorted) type, that + does not contain key(s)." + ([coll] coll) + ([coll k] + (when-not (nil? coll) + (-disjoin coll k))) + ([coll k & ks] + (when-not (nil? coll) + (let [ret (disj coll k)] + (if ks + (recur ret (first ks) (next ks)) + ret))))) + +(defn ^boolean empty? + "Returns true if coll has no items - same as (not (seq coll)). + Please use the idiom (seq x) rather than (not (empty? x))" + [coll] (or (nil? coll) + (not (seq coll)))) + +(defn ^boolean coll? + "Returns true if x satisfies ICollection" + [x] + (if (nil? x) + false + (satisfies? ICollection x))) + +(defn ^boolean set? + "Returns true if x satisfies ISet" + [x] + (if (nil? x) + false + (satisfies? ISet x))) + +(defn ^boolean associative? + "Returns true if coll implements IAssociative" + [x] (satisfies? IAssociative x)) + +(defn ^boolean ifind? + "Returns true if coll implements IFind" + [x] (satisfies? IFind x)) + +(defn ^boolean sequential? + "Returns true if coll satisfies ISequential" + [x] (satisfies? ISequential x)) + +(defn ^boolean sorted? + "Returns true if coll satisfies ISorted" + [x] (satisfies? ISorted x)) + +(defn ^boolean reduceable? + "Returns true if coll satisfies IReduce" + [x] (satisfies? IReduce x)) + +(defn ^boolean map? + "Return true if x satisfies IMap" + [x] + (if (nil? x) + false + (satisfies? IMap x))) + +(defn ^boolean record? + "Return true if x satisfies IRecord" + [x] + (satisfies? IRecord x)) + +(defn ^boolean vector? + "Return true if x satisfies IVector" + [x] (satisfies? IVector x)) + +(declare ChunkedCons ChunkedSeq) + +(defn ^boolean chunked-seq? + "Return true if x is satisfies IChunkedSeq." + [x] (implements? IChunkedSeq x)) + +;;;;;;;;;;;;;;;;;;;; js primitives ;;;;;;;;;;;; +(defn js-obj + "Create JavaSript object from an even number arguments representing + interleaved keys and values." + ([] + (cljs.core/js-obj)) + ([& keyvals] + (apply gobject/create keyvals))) + +(defn js-keys + "Return the JavaScript keys for an object." + [obj] + (gobject/getKeys obj)) + +(defn js-delete + "Delete a property from a JavaScript object. + Returns true upon success, false otherwise." + [obj key] + (cljs.core/js-delete obj key)) + +(defn- array-copy + ([from i to j len] + (loop [i i j j len len] + (if (zero? len) + to + (do (aset to j (aget from i)) + (recur (inc i) (inc j) (dec len))))))) + +(defn- array-copy-downward + ([from i to j len] + (loop [i (+ i (dec len)) j (+ j (dec len)) len len] + (if (zero? len) + to + (do (aset to j (aget from i)) + (recur (dec i) (dec j) (dec len))))))) + +;;;;;;;;;;;;;;;; preds ;;;;;;;;;;;;;;;;;; + +(def ^:private lookup-sentinel (js-obj)) + +(defn ^boolean false? + "Returns true if x is the value false, false otherwise." + [x] (cljs.core/false? x)) + +(defn ^boolean true? + "Returns true if x is the value true, false otherwise." + [x] (cljs.core/true? x)) + +(defn ^boolean boolean? + "Return true if x is a Boolean" + [x] (or (cljs.core/true? x) (cljs.core/false? x))) + +(defn ^boolean undefined? + "Returns true if x identical to the JavaScript undefined value." + [x] + (cljs.core/undefined? x)) + +(defn ^boolean seq? + "Return true if s satisfies ISeq" + [s] + (if (nil? s) + false + (satisfies? ISeq s))) + +(defn ^boolean seqable? + "Return true if the seq function is supported for s" + [s] + (or + (satisfies? ISeqable s) + (array? s) + (string? s))) + +(defn ^boolean boolean + "Coerce to boolean" + [x] + (cond + (nil? x) false + (false? x) false + :else true)) + +(defn ^boolean ifn? + "Returns true if f returns true for fn? or satisfies IFn." + [f] + (or (fn? f) (satisfies? IFn f))) + +(defn ^boolean integer? + "Returns true if n is a JavaScript number with no decimal part." + [n] + (and (number? n) + (not ^boolean (js/isNaN n)) + (not (identical? n js/Infinity)) + (== (js/parseFloat n) (js/parseInt n 10)))) + +(defn ^boolean int? + "Return true if x satisfies integer? or is an instance of goog.math.Integer + or goog.math.Long." + [x] + (or (integer? x) + (instance? goog.math.Integer x) + (instance? goog.math.Long x))) + +(defn ^boolean pos-int? + "Return true if x satisfies int? and is positive." + [x] + (cond + (integer? x) (pos? x) + + (instance? goog.math.Integer x) + (and (not (.isNegative x)) + (not (.isZero x))) + + (instance? goog.math.Long x) + (and (not (.isNegative x)) + (not (.isZero x))) + + :else false)) + +(defn ^boolean neg-int? + "Return true if x satisfies int? and is negative." + [x] + (cond + (integer? x) (neg? x) + + (instance? goog.math.Integer x) + (.isNegative x) + + (instance? goog.math.Long x) + (.isNegative x) + + :else false)) + +(defn ^boolean nat-int? + "Return true if x satisfies int? and is a natural integer value." + [x] + (cond + (integer? x) + (not (neg? x)) + + (instance? goog.math.Integer x) + (not (.isNegative x)) + + (instance? goog.math.Long x) + (not (.isNegative x)) + + :else false)) + +(defn ^boolean float? + "Returns true for JavaScript numbers, false otherwise." + [x] + (number? x)) + +(defn ^boolean double? + "Returns true for JavaScript numbers, false otherwise." + [x] + (number? x)) + +(defn ^boolean infinite? + "Returns true for Infinity and -Infinity values." + [x] + (or (identical? x js/Number.POSITIVE_INFINITY) + (identical? x js/Number.NEGATIVE_INFINITY))) + +(defn ^boolean contains? + "Returns true if key is present in the given collection, otherwise + returns false. Note that for numerically indexed collections like + vectors and arrays, this tests if the numeric key is within the + range of indexes. 'contains?' operates constant or logarithmic time; + it will not perform a linear search for a value. See also 'some'." + [coll v] + (if (identical? (get coll v lookup-sentinel) lookup-sentinel) + false + true)) + +(defn find + "Returns the map entry for key, or nil if key not present." + [coll k] + (if (ifind? coll) + (-find coll k) + (when (and (not (nil? coll)) + (associative? coll) + (contains? coll k)) + (MapEntry. k (get coll k) nil)))) + +(defn ^boolean distinct? + "Returns true if no two of the arguments are =" + ([x] true) + ([x y] (not (= x y))) + ([x y & more] + (if (not (= x y)) + (loop [s #{x y} xs more] + (let [x (first xs) + etc (next xs)] + (if xs + (if (contains? s x) + false + (recur (conj s x) etc)) + true))) + false))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Seq fns ;;;;;;;;;;;;;;;; + +(defn ^number compare + "Comparator. Returns a negative number, zero, or a positive number + when x is logically 'less than', 'equal to', or 'greater than' + y. Uses IComparable if available and google.array.defaultCompare for objects + of the same type and special-cases nil to be less than any other object." + [x y] + (cond + (identical? x y) 0 + + (nil? x) -1 + + (nil? y) 1 + + (number? x) (if (number? y) + (garray/defaultCompare x y) + (throw (js/Error. (str "Cannot compare " x " to " y)))) + + (satisfies? IComparable x) + (-compare x y) + + :else + (if (and (or (string? x) (array? x) (true? x) (false? x)) + (identical? (type x) (type y))) + (garray/defaultCompare x y) + (throw (js/Error. (str "Cannot compare " x " to " y)))))) + +(defn ^:private compare-indexed + "Compare indexed collection." + ([xs ys] + (let [xl (count xs) + yl (count ys)] + (cond + (< xl yl) -1 + (> xl yl) 1 + (== xl 0) 0 + :else (compare-indexed xs ys xl 0)))) + ([xs ys len n] + (let [d (compare (nth xs n) (nth ys n))] + (if (and (zero? d) (< (+ n 1) len)) + (recur xs ys len (inc n)) + d)))) + +(defn ^:private fn->comparator + "Given a fn that might be boolean valued or a comparator, + return a fn that is a comparator." + [f] + (if (= f compare) + compare + (fn [x y] + (let [r (f x y)] + (if (number? r) + r + (if r + -1 + (if (f y x) 1 0))))))) + +(declare to-array) + +(defn sort + "Returns a sorted sequence of the items in coll. Comp can be + boolean-valued comparison function, or a -/0/+ valued comparator. + Comp defaults to compare." + ([coll] + (sort compare coll)) + ([comp coll] + (if (seq coll) + (let [a (to-array coll)] + ;; matching Clojure's stable sort, though docs don't promise it + (garray/stableSort a (fn->comparator comp)) + (seq a)) + ()))) + +(defn sort-by + "Returns a sorted sequence of the items in coll, where the sort + order is determined by comparing (keyfn item). Comp can be + boolean-valued comparison function, or a -/0/+ valued comparator. + Comp defaults to compare." + ([keyfn coll] + (sort-by keyfn compare coll)) + ([keyfn comp coll] + (sort (fn [x y] ((fn->comparator comp) (keyfn x) (keyfn y))) coll))) + +; simple reduce based on seqs, used as default +(defn- seq-reduce + ([f coll] + (if-let [s (seq coll)] + (reduce f (first s) (next s)) + (f))) + ([f val coll] + (loop [val val, coll (seq coll)] + (if coll + (let [nval (f val (first coll))] + (if (reduced? nval) + @nval + (recur nval (next coll)))) + val)))) + +(declare vec) + +(defn shuffle + "Return a random permutation of coll" + [coll] + (let [a (to-array coll)] + (garray/shuffle a) + (vec a))) + +(defn- iter-reduce + ([coll f] + (let [iter (-iterator coll)] + (if (.hasNext iter) + (let [init (.next iter)] + (loop [acc init] + (if ^boolean (.hasNext iter) + (let [nacc (f acc (.next iter))] + (if (reduced? nacc) + @nacc + (recur nacc))) + acc))) + (f)))) + ([coll f init] + (let [iter (-iterator coll)] + (loop [acc init] + (if ^boolean (.hasNext iter) + (let [nacc (f acc (.next iter))] + (if (reduced? nacc) + @nacc + (recur nacc))) + acc))))) + +(defn reduce + "f should be a function of 2 arguments. If val is not supplied, + returns the result of applying f to the first 2 items in coll, then + applying f to that result and the 3rd item, etc. If coll contains no + items, f must accept no arguments as well, and reduce returns the + result of calling f with no arguments. If coll has only 1 item, it + is returned and f is not called. If val is supplied, returns the + result of applying f to val and the first item in coll, then + applying f to that result and the 2nd item, etc. If coll contains no + items, returns val and f is not called." + ([f coll] + (cond + (implements? IReduce coll) + (-reduce ^not-native coll f) + + (array? coll) + (array-reduce coll f) + + (string? coll) + (array-reduce coll f) + + (native-satisfies? IReduce coll) + (-reduce coll f) + + (iterable? coll) + (iter-reduce coll f) + + :else + (seq-reduce f coll))) + ([f val coll] + (cond + (implements? IReduce coll) + (-reduce ^not-native coll f val) + + (array? coll) + (array-reduce coll f val) + + (string? coll) + (array-reduce coll f val) + + (native-satisfies? IReduce coll) + (-reduce coll f val) + + (iterable? coll) + (iter-reduce coll f val) + + :else + (seq-reduce f val coll)))) + +(defn reduce-kv + "Reduces an associative collection. f should be a function of 3 + arguments. Returns the result of applying f to init, the first key + and the first value in coll, then applying f to that result and the + 2nd key and value, etc. If coll contains no entries, returns init + and f is not called. Note that reduce-kv is supported on vectors, + where the keys will be the ordinals." + ([f init coll] + (if-not (nil? coll) + (-kv-reduce coll f init) + init))) + +(defn identity + "Returns its argument." + [x] x) + +(defn completing + "Takes a reducing function f of 2 args and returns a fn suitable for + transduce by adding an arity-1 signature that calls cf (default - + identity) on the result argument." + ([f] (completing f identity)) + ([f cf] + (fn + ([] (f)) + ([x] (cf x)) + ([x y] (f x y))))) + +(defn transduce + "reduce with a transformation of f (xf). If init is not + supplied, (f) will be called to produce it. f should be a reducing + step function that accepts both 1 and 2 arguments, if it accepts + only 2 you can add the arity-1 with 'completing'. Returns the result + of applying (the transformed) xf to init and the first item in coll, + then applying xf to that result and the 2nd item, etc. If coll + contains no items, returns init and f is not called. Note that + certain transforms may inject or skip items." + ([xform f coll] (transduce xform f (f) coll)) + ([xform f init coll] + (let [f (xform f) + ret (reduce f init coll)] + (f ret)))) + +;;; Math - variadic forms will not work until the following implemented: +;;; first, next, reduce + +(defn ^number + + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/+ x y)) + ([x y & more] + (reduce + (cljs.core/+ x y) more))) + +(defn ^number - + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/- x)) + ([x y] (cljs.core/- x y)) + ([x y & more] (reduce - (cljs.core/- x y) more))) + +(defn ^number * + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/* x y)) + ([x y & more] (reduce * (cljs.core/* x y) more))) + +(declare divide) + +(defn ^number / + "If no denominators are supplied, returns 1/numerator, + else returns numerator divided by all of the denominators." + ([x] (/ 1 x)) + ([x y] (cljs.core/divide x y)) ;; FIXME: waiting on cljs.core// + ([x y & more] (reduce / (/ x y) more))) + +(defn ^boolean < + "Returns non-nil if nums are in monotonically increasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/< x y)) + ([x y & more] + (if (cljs.core/< x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/< y (first more))) + false))) + +(defn ^boolean <= + "Returns non-nil if nums are in monotonically non-decreasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/<= x y)) + ([x y & more] + (if (cljs.core/<= x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/<= y (first more))) + false))) + +(defn ^boolean > + "Returns non-nil if nums are in monotonically decreasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/> x y)) + ([x y & more] + (if (cljs.core/> x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/> y (first more))) + false))) + +(defn ^boolean >= + "Returns non-nil if nums are in monotonically non-increasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/>= x y)) + ([x y & more] + (if (cljs.core/>= x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/>= y (first more))) + false))) + +(defn dec + "Returns a number one less than num." + [x] (- x 1)) + +(defn ^number max + "Returns the greatest of the nums." + ([x] x) + ([x y] (cljs.core/max x y)) + ([x y & more] + (reduce max (cljs.core/max x y) more))) + +(defn ^number min + "Returns the least of the nums." + ([x] x) + ([x y] (cljs.core/min x y)) + ([x y & more] + (reduce min (cljs.core/min x y) more))) + +(defn ^number byte [x] x) + +(defn char + "Coerce to char" + [x] + (cond + (number? x) (.fromCharCode js/String x) + (and (string? x) (== (.-length x) 1)) x + :else (throw (js/Error. "Argument to char must be a character or number")))) + +(defn ^number short [x] x) +(defn ^number float [x] x) +(defn ^number double [x] x) + +(defn ^number unchecked-byte [x] x) +(defn ^number unchecked-char [x] x) +(defn ^number unchecked-short [x] x) +(defn ^number unchecked-float [x] x) +(defn ^number unchecked-double [x] x) + +(defn ^number unchecked-add + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/unchecked-add x y)) + ([x y & more] (reduce unchecked-add (cljs.core/unchecked-add x y) more))) + +(defn ^number unchecked-add-int + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/unchecked-add-int x y)) + ([x y & more] (reduce unchecked-add-int (cljs.core/unchecked-add-int x y) more))) + +(defn unchecked-dec + "Returns a number one less than x, an int." + [x] + (cljs.core/unchecked-dec x)) + +(defn unchecked-dec-int + "Returns a number one less than x, an int." + [x] + (cljs.core/unchecked-dec-int x)) + +(defn ^number unchecked-divide-int + "If no denominators are supplied, returns 1/numerator, + else returns numerator divided by all of the denominators." + ([x] (unchecked-divide-int 1 x)) + ([x y] (cljs.core/divide x y)) ;; FIXME: waiting on cljs.core// + ([x y & more] (reduce unchecked-divide-int (unchecked-divide-int x y) more))) + +(defn unchecked-inc [x] + (cljs.core/unchecked-inc x)) + +(defn unchecked-inc-int [x] + (cljs.core/unchecked-inc-int x)) + +(defn ^number unchecked-multiply + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/unchecked-multiply x y)) + ([x y & more] (reduce unchecked-multiply (cljs.core/unchecked-multiply x y) more))) + +(defn ^number unchecked-multiply-int + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/unchecked-multiply-int x y)) + ([x y & more] (reduce unchecked-multiply-int (cljs.core/unchecked-multiply-int x y) more))) + +(defn unchecked-negate [x] + (cljs.core/unchecked-negate x)) + +(defn unchecked-negate-int [x] + (cljs.core/unchecked-negate-int x)) + +(declare mod) + +(defn unchecked-remainder-int [x n] + (cljs.core/unchecked-remainder-int x n)) + +(defn ^number unchecked-subtract + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/unchecked-subtract x)) + ([x y] (cljs.core/unchecked-subtract x y)) + ([x y & more] (reduce unchecked-subtract (cljs.core/unchecked-subtract x y) more))) + +(defn ^number unchecked-subtract-int + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/unchecked-subtract-int x)) + ([x y] (cljs.core/unchecked-subtract-int x y)) + ([x y & more] (reduce unchecked-subtract-int (cljs.core/unchecked-subtract-int x y) more))) + +(defn- ^number fix [q] + (if (>= q 0) + (Math/floor q) + (Math/ceil q))) + +(defn int + "Coerce to int by stripping decimal places." + [x] + (bit-or x 0)) + +(defn unchecked-int + "Coerce to int by stripping decimal places." + [x] + (fix x)) + +(defn long + "Coerce to long by stripping decimal places. Identical to `int'." + [x] + (fix x)) + +(defn unchecked-long + "Coerce to long by stripping decimal places. Identical to `int'." + [x] + (fix x)) + +(defn booleans [x] x) +(defn bytes [x] x) +(defn chars [x] x) +(defn shorts [x] x) +(defn ints [x] x) +(defn floats [x] x) +(defn doubles [x] x) +(defn longs [x] x) + +(defn js-mod + "Modulus of num and div with original javascript behavior. i.e. bug for negative numbers" + [n d] + (cljs.core/js-mod n d)) + +(defn mod + "Modulus of num and div. Truncates toward negative infinity." + [n d] + (js-mod (+ (js-mod n d) d) d)) + +(defn quot + "quot[ient] of dividing numerator by denominator." + [n d] + (let [rem (js-mod n d)] + (fix (/ (- n rem) d)))) + +(defn rem + "remainder of dividing numerator by denominator." + [n d] + (let [q (quot n d)] + (- n (* d q)))) + +(defn bit-xor + "Bitwise exclusive or" + ([x y] (cljs.core/bit-xor x y)) + ([x y & more] + (reduce bit-xor (cljs.core/bit-xor x y) more))) + +(defn bit-and + "Bitwise and" + ([x y] (cljs.core/bit-and x y)) + ([x y & more] + (reduce bit-and (cljs.core/bit-and x y) more))) + +(defn bit-or + "Bitwise or" + ([x y] (cljs.core/bit-or x y)) + ([x y & more] + (reduce bit-or (cljs.core/bit-or x y) more))) + +(defn bit-and-not + "Bitwise and with complement" + ([x y] (cljs.core/bit-and-not x y)) + ([x y & more] + (reduce bit-and-not (cljs.core/bit-and-not x y) more))) + +(defn bit-clear + "Clear bit at index n" + [x n] + (cljs.core/bit-clear x n)) + +(defn bit-flip + "Flip bit at index n" + [x n] + (cljs.core/bit-flip x n)) + +(defn bit-not + "Bitwise complement" + [x] (cljs.core/bit-not x)) + +(defn bit-set + "Set bit at index n" + [x n] + (cljs.core/bit-set x n)) + +(defn ^boolean bit-test + "Test bit at index n" + [x n] + (cljs.core/bit-test x n)) + +(defn bit-shift-left + "Bitwise shift left" + [x n] (cljs.core/bit-shift-left x n)) + +(defn bit-shift-right + "Bitwise shift right" + [x n] (cljs.core/bit-shift-right x n)) + +(defn bit-shift-right-zero-fill + "DEPRECATED: Bitwise shift right with zero fill" + [x n] (cljs.core/bit-shift-right-zero-fill x n)) + +(defn unsigned-bit-shift-right + "Bitwise shift right with zero fill" + [x n] (cljs.core/unsigned-bit-shift-right x n)) + +(defn bit-count + "Counts the number of bits set in n" + [v] + (let [v (- v (bit-and (bit-shift-right v 1) 0x55555555)) + v (+ (bit-and v 0x33333333) (bit-and (bit-shift-right v 2) 0x33333333))] + (bit-shift-right (* (bit-and (+ v (bit-shift-right v 4)) 0xF0F0F0F) 0x1010101) 24))) + +(defn ^boolean == + "Returns non-nil if nums all have the equivalent + value, otherwise false. Behavior on non nums is + undefined." + ([x] true) + ([x y] (-equiv x y)) + ([x y & more] + (if (== x y) + (if (next more) + (recur y (first more) (next more)) + (== y (first more))) + false))) + +(defn ^boolean pos? + "Returns true if num is greater than zero, else false" + [x] (cljs.core/pos? x)) + +(defn ^boolean zero? + "Returns true if num is zero, else false" + [x] + (cljs.core/zero? x)) + +(defn ^boolean neg? + "Returns true if num is less than zero, else false" + [x] (cljs.core/neg? x)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; protocols for host types ;;;;;; + +(defn nthnext + "Returns the nth next of coll, (seq coll) when n is 0." + [coll n] + (loop [n n xs (seq coll)] + (if (and xs (pos? n)) + (recur (dec n) (next xs)) + xs))) + +;;;;;;;;;;;;;;;;;;;;;;;;;; basics ;;;;;;;;;;;;;;;;;; + +(defn str + "With no args, returns the empty string. With one arg x, returns + x.toString(). (str nil) returns the empty string. With more than + one arg, returns the concatenation of the str values of the args." + ([] "") + ([x] (if (nil? x) + "" + (.join #js [x] ""))) + ([x & ys] + (loop [sb (StringBuffer. (str x)) more ys] + (if more + (recur (. sb (append (str (first more)))) (next more)) + (.toString sb))))) + +(defn subs + "Returns the substring of s beginning at start inclusive, and ending + at end (defaults to length of string), exclusive." + ([s start] (.substring s start)) + ([s start end] (.substring s start end))) + +(declare map name) + +(defn- equiv-sequential + "Assumes x is sequential. Returns true if x equals y, otherwise + returns false." + [x y] + (boolean + (when (sequential? y) + (if (and (counted? x) (counted? y) + (not (== (count x) (count y)))) + false + (loop [xs (seq x) ys (seq y)] + (cond (nil? xs) (nil? ys) + (nil? ys) false + (= (first xs) (first ys)) (recur (next xs) (next ys)) + :else false)))))) + +(defn- hash-coll [coll] + (if (seq coll) + (loop [res (hash (first coll)) s (next coll)] + (if (nil? s) + res + (recur (hash-combine res (hash (first s))) (next s)))) + 0)) + +(declare key val) + +(defn- hash-imap [m] + ;; a la clojure.lang.APersistentMap + (loop [h 0 s (seq m)] + (if s + (let [e (first s)] + (recur (js-mod (+ h (bit-xor (hash (key e)) (hash (val e)))) + 4503599627370496) + (next s))) + h))) + +(defn- hash-iset [s] + ;; a la clojure.lang.APersistentSet + (loop [h 0 s (seq s)] + (if s + (let [e (first s)] + (recur (js-mod (+ h (hash e)) 4503599627370496) + (next s))) + h))) + +(declare name chunk-first chunk-rest) + +(defn- extend-object! + "Takes a JavaScript object and a map of names to functions and + attaches said functions as methods on the object. Any references to + JavaScript's implicit this (via the this-as macro) will resolve to the + object that the function is attached." + [obj fn-map] + (doseq [[key-name f] fn-map] + (let [str-name (name key-name)] + (gobject/set obj str-name f))) + obj) + +;;;;;;;;;;;;;;;; cons ;;;;;;;;;;;;;;;; +(deftype List [meta first rest count ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x count)) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IList + + ICloneable + (-clone [_] (List. meta first rest count __hash)) + + IWithMeta + (-with-meta [coll meta] (List. meta first rest count __hash)) + + IMeta + (-meta [coll] meta) + + ASeq + ISeq + (-first [coll] first) + (-rest [coll] + (if (== count 1) + () + rest)) + + INext + (-next [coll] + (if (== count 1) + nil + rest)) + + IStack + (-peek [coll] first) + (-pop [coll] (-rest coll)) + + ICollection + (-conj [coll o] (List. meta o coll (inc count) nil)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] coll) + + ICounted + (-count [coll] count) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn ^boolean list? + "Returns true if x implements IList" + [x] + (satisfies? IList x)) + +(es6-iterable List) + +(deftype EmptyList [meta] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IList + + ICloneable + (-clone [_] (EmptyList. meta)) + + IWithMeta + (-with-meta [coll meta] (EmptyList. meta)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] nil) + (-rest [coll] ()) + + INext + (-next [coll] nil) + + IStack + (-peek [coll] nil) + (-pop [coll] (throw (js/Error. "Can't pop empty list"))) + + ICollection + (-conj [coll o] (List. meta o nil 1 nil)) + + IEmptyableCollection + (-empty [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] + (if (or (list? other) + (sequential? other)) + (nil? (seq other)) + false)) + + IHash + (-hash [coll] empty-ordered-hash) + + ISeqable + (-seq [coll] nil) + + ICounted + (-count [coll] 0) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(set! (.-EMPTY List) (EmptyList. nil)) + +(es6-iterable EmptyList) + +(defn ^boolean reversible? + "Returns true if coll satisfies? IReversible." + [coll] + (satisfies? IReversible coll)) + +(defn ^seq rseq + "Returns, in constant time, a seq of the items in rev (which + can be a vector or sorted-map), in reverse order. If rev is empty returns nil" + [rev] + (-rseq rev)) + +(defn reverse + "Returns a seq of the items in coll in reverse order. Not lazy." + [coll] + (if (reversible? coll) + (or (rseq coll) ()) + (reduce conj () coll))) + +(defn list + "Creates a new list containing the items." + [& xs] + (let [arr (if (and (instance? IndexedSeq xs) (zero? (.-i xs))) + (.-arr xs) + (let [arr (array)] + (loop [^not-native xs xs] + (if-not (nil? xs) + (do + (.push arr (-first xs)) + (recur (-next xs))) + arr))))] + (loop [i (alength arr) ^not-native r ()] + (if (> i 0) + (recur (dec i) (-conj r (aget arr (dec i)))) + r)))) + +(deftype Cons [meta first rest ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IList + + ICloneable + (-clone [_] (Cons. meta first rest __hash)) + + IWithMeta + (-with-meta [coll meta] (Cons. meta first rest __hash)) + + IMeta + (-meta [coll] meta) + + ASeq + ISeq + (-first [coll] first) + (-rest [coll] (if (nil? rest) () rest)) + + INext + (-next [coll] + (if (nil? rest) nil (seq rest))) + + ICollection + (-conj [coll o] (Cons. nil o coll nil)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] coll) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable Cons) + +(defn cons + "Returns a new seq where x is the first element and coll is the rest." + [x coll] + (if (or (nil? coll) + (implements? ISeq coll)) + (Cons. nil x coll nil) + (Cons. nil x (seq coll) nil))) + +(defn hash-keyword [k] + (int (+ (hash-symbol k) 0x9e3779b9))) + +(defn- compare-keywords [a b] + (cond + (identical? (.-fqn a) (.-fqn b)) 0 + (and (not (.-ns a)) (.-ns b)) -1 + (.-ns a) (if-not (.-ns b) + 1 + (let [nsc (garray/defaultCompare (.-ns a) (.-ns b))] + (if (== 0 nsc) + (garray/defaultCompare (.-name a) (.-name b)) + nsc))) + :default (garray/defaultCompare (.-name a) (.-name b)))) + +(deftype Keyword [ns name fqn ^:mutable _hash] + Object + (toString [_] (str ":" fqn)) + (equiv [this other] + (-equiv this other)) + + IEquiv + (-equiv [_ other] + (if (instance? Keyword other) + (identical? fqn (.-fqn other)) + false)) + IFn + (-invoke [kw coll] + (get coll kw)) + (-invoke [kw coll not-found] + (get coll kw not-found)) + + IHash + (-hash [this] + (caching-hash this hash-keyword _hash)) + + INamed + (-name [_] name) + (-namespace [_] ns) + + IPrintWithWriter + (-pr-writer [o writer _] (-write writer (str ":" fqn)))) + +(defn ^boolean keyword? + "Return true if x is a Keyword" + [x] + (instance? Keyword x)) + +(defn ^boolean keyword-identical? + "Efficient test to determine that two keywords are identical." + [x y] + (if (identical? x y) + true + (if (and (keyword? x) (keyword? y)) + (identical? (.-fqn x) (.-fqn y)) + false))) + +(defn ^boolean symbol-identical? + "Efficient test to determine that two symbols are identical." + [x y] + (if (identical? x y) + true + (if (and (symbol? x) (symbol? y)) + (identical? (.-str x) (.-str y)) + false))) + +(defn namespace + "Returns the namespace String of a symbol or keyword, or nil if not present." + [x] + (if (implements? INamed x) + (-namespace ^not-native x) + (throw (js/Error. (str "Doesn't support namespace: " x))))) + +(defn ^boolean ident? + "Return true if x is a symbol or keyword" + [x] (or (keyword? x) (symbol? x))) + +(defn ^boolean simple-ident? + "Return true if x is a symbol or keyword without a namespace" + [x] (and (ident? x) (nil? (namespace x)))) + +(defn ^boolean qualified-ident? + "Return true if x is a symbol or keyword with a namespace" + [x] (boolean (and (ident? x) (namespace x) true))) + +(defn ^boolean simple-symbol? + "Return true if x is a symbol without a namespace" + [x] (and (symbol? x) (nil? (namespace x)))) + +(defn ^boolean qualified-symbol? + "Return true if x is a symbol with a namespace" + [x] (boolean (and (symbol? x) (namespace x) true))) + +(defn ^boolean simple-keyword? + "Return true if x is a keyword without a namespace" + [x] (and (keyword? x) (nil? (namespace x)))) + +(defn ^boolean qualified-keyword? + "Return true if x is a keyword with a namespace" + [x] (boolean (and (keyword? x) (namespace x) true))) + +(defn keyword + "Returns a Keyword with the given namespace and name. Do not use : + in the keyword strings, it will be added automatically." + ([name] (cond + (keyword? name) name + (symbol? name) (Keyword. + (cljs.core/namespace name) + (cljs.core/name name) (.-str name) nil) + (string? name) (let [parts (.split name "/")] + (if (== (alength parts) 2) + (Keyword. (aget parts 0) (aget parts 1) name nil) + (Keyword. nil (aget parts 0) name nil))))) + ([ns name] + (let [ns (cond + (keyword? ns) (cljs.core/name ns) + (symbol? ns) (cljs.core/name ns) + :else ns) + name (cond + (keyword? name) (cljs.core/name name) + (symbol? name) (cljs.core/name name) + :else name)] + (Keyword. ns name (str (when ns (str ns "/")) name) nil)))) + + +(deftype LazySeq [meta ^:mutable fn ^:mutable s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (sval [coll] + (if (nil? fn) + s + (do + (set! s (fn)) + (set! fn nil) + s))) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IPending + (-realized? [coll] + (not fn)) + + IWithMeta + (-with-meta [coll meta] (LazySeq. meta #(-seq coll) nil __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] + (-seq coll) + (when-not (nil? s) + (first s))) + (-rest [coll] + (-seq coll) + (if-not (nil? s) + (rest s) + ())) + + INext + (-next [coll] + (-seq coll) + (when-not (nil? s) + (next s))) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] + (.sval coll) + (when-not (nil? s) + (loop [ls s] + (if (instance? LazySeq ls) + (recur (.sval ls)) + (do (set! s ls) + (seq s)))))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable LazySeq) + +(declare ArrayChunk) + +(deftype ChunkBuffer [^:mutable buf ^:mutable end] + Object + (add [_ o] + (aset buf end o) + (set! end (inc end))) + + (chunk [_] + (let [ret (ArrayChunk. buf 0 end)] + (set! buf nil) + ret)) + + ICounted + (-count [_] end)) + +(defn chunk-buffer [capacity] + (ChunkBuffer. (make-array capacity) 0)) + +(deftype ArrayChunk [arr off end] + ICounted + (-count [_] (- end off)) + + IIndexed + (-nth [coll i] + (aget arr (+ off i))) + (-nth [coll i not-found] + (if (and (>= i 0) (< i (- end off))) + (aget arr (+ off i)) + not-found)) + + IChunk + (-drop-first [coll] + (if (== off end) + (throw (js/Error. "-drop-first of empty chunk")) + (ArrayChunk. arr (inc off) end))) + + IReduce + (-reduce [coll f] + (array-reduce arr f (aget arr off) (inc off))) + (-reduce [coll f start] + (array-reduce arr f start off))) + +(defn array-chunk + ([arr] + (ArrayChunk. arr 0 (alength arr))) + ([arr off] + (ArrayChunk. arr off (alength arr))) + ([arr off end] + (ArrayChunk. arr off end))) + +(deftype ChunkedCons [chunk more meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IWithMeta + (-with-meta [coll m] + (ChunkedCons. chunk more m __hash)) + + IMeta + (-meta [coll] meta) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ISeqable + (-seq [coll] coll) + + ASeq + ISeq + (-first [coll] (-nth chunk 0)) + (-rest [coll] + (if (> (-count chunk) 1) + (ChunkedCons. (-drop-first chunk) more meta nil) + (if (nil? more) + () + more))) + + INext + (-next [coll] + (if (> (-count chunk) 1) + (ChunkedCons. (-drop-first chunk) more meta nil) + (let [more (-seq more)] + (when-not (nil? more) + more)))) + + IChunkedSeq + (-chunked-first [coll] chunk) + (-chunked-rest [coll] + (if (nil? more) + () + more)) + + IChunkedNext + (-chunked-next [coll] + (if (nil? more) + nil + more)) + + ICollection + (-conj [this o] + (cons o this)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash))) + +(es6-iterable ChunkedCons) + +(defn chunk-cons [chunk rest] + (if (zero? (-count chunk)) + rest + (ChunkedCons. chunk rest nil nil))) + +(defn chunk-append [b x] + (.add b x)) + +(defn chunk [b] + (.chunk b)) + +(defn chunk-first [s] + (-chunked-first s)) + +(defn chunk-rest [s] + (-chunked-rest s)) + +(defn chunk-next [s] + (if (implements? IChunkedNext s) + (-chunked-next s) + (seq (-chunked-rest s)))) + +;;;;;;;;;;;;;;;; + +(defn to-array + "Naive impl of to-array as a start." + [s] + (let [ary (array)] + (loop [s (seq s)] + (if-not (nil? s) + (do (. ary push (first s)) + (recur (next s))) + ary)))) + +(defn to-array-2d + "Returns a (potentially-ragged) 2-dimensional array + containing the contents of coll." + [coll] + (let [ret (make-array (count coll))] + (loop [i 0 xs (seq coll)] + (when-not (nil? xs) + (aset ret i (to-array (first xs))) + (recur (inc i) (next xs)))) + ret)) + +(defn int-array + "Creates an array of ints. Does not coerce array, provided for compatibility + with Clojure." + ([size-or-seq] + (if (number? size-or-seq) + (int-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn long-array + "Creates an array of longs. Does not coerce array, provided for compatibility + with Clojure." + ([size-or-seq] + (if (number? size-or-seq) + (long-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn double-array + "Creates an array of doubles. Does not coerce array, provided for compatibility + with Clojure." + ([size-or-seq] + (if (number? size-or-seq) + (double-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn object-array + "Creates an array of objects. Does not coerce array, provided for compatibility + with Clojure." + ([size-or-seq] + (if (number? size-or-seq) + (object-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn bounded-count + "If coll is counted? returns its count, else will count at most the first n + elements of coll using its seq" + {:added "1.9"} + [n coll] + (if (counted? coll) + (count coll) + (loop [i 0 s (seq coll)] + (if (and (not (nil? s)) (< i n)) + (recur (inc i) (next s)) + i)))) + +(defn spread + [arglist] + (when-not (nil? arglist) + (let [n (next arglist)] + (if (nil? n) + (seq (first arglist)) + (cons (first arglist) + (spread n)))))) + +(defn concat + "Returns a lazy seq representing the concatenation of the elements in the supplied colls." + ([] (lazy-seq nil)) + ([x] (lazy-seq x)) + ([x y] + (lazy-seq + (let [s (seq x)] + (if s + (if (chunked-seq? s) + (chunk-cons (chunk-first s) (concat (chunk-rest s) y)) + (cons (first s) (concat (rest s) y))) + y)))) + ([x y & zs] + (let [cat (fn cat [xys zs] + (lazy-seq + (let [xys (seq xys)] + (if xys + (if (chunked-seq? xys) + (chunk-cons (chunk-first xys) + (cat (chunk-rest xys) zs)) + (cons (first xys) (cat (rest xys) zs))) + (when zs + (cat (first zs) (next zs)))))))] + (cat (concat x y) zs)))) + +(defn list* + "Creates a new list containing the items prepended to the rest, the + last of which will be treated as a sequence." + ([args] (seq args)) + ([a args] (cons a args)) + ([a b args] (cons a (cons b args))) + ([a b c args] (cons a (cons b (cons c args)))) + ([a b c d & more] + (cons a (cons b (cons c (cons d (spread more))))))) + + +;;; Transients + +(defn transient + "Returns a new, transient version of the collection, in constant time." + [coll] + (-as-transient coll)) + +(defn persistent! + "Returns a new, persistent version of the transient collection, in + constant time. The transient collection cannot be used after this + call, any such use will throw an exception." + [tcoll] + (-persistent! tcoll)) + +(defn conj! + "Adds val to the transient collection, and return tcoll. The 'addition' + may happen at different 'places' depending on the concrete type." + ([] (transient [])) + ([tcoll] tcoll) + ([tcoll val] + (-conj! tcoll val)) + ([tcoll val & vals] + (let [ntcoll (-conj! tcoll val)] + (if vals + (recur ntcoll (first vals) (next vals)) + ntcoll)))) + +(defn assoc! + "When applied to a transient map, adds mapping of key(s) to + val(s). When applied to a transient vector, sets the val at index. + Note - index must be <= (count vector). Returns coll." + ([tcoll key val] + (-assoc! tcoll key val)) + ([tcoll key val & kvs] + (let [ntcoll (-assoc! tcoll key val)] + (if kvs + (recur ntcoll (first kvs) (second kvs) (nnext kvs)) + ntcoll)))) + +(defn dissoc! + "Returns a transient map that doesn't contain a mapping for key(s)." + ([tcoll key] + (-dissoc! tcoll key)) + ([tcoll key & ks] + (let [ntcoll (-dissoc! tcoll key)] + (if ks + (recur ntcoll (first ks) (next ks)) + ntcoll)))) + +(defn pop! + "Removes the last item from a transient vector. If + the collection is empty, throws an exception. Returns tcoll" + [tcoll] + (-pop! tcoll)) + +(defn disj! + "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that + does not contain key(s)." + ([tcoll val] + (-disjoin! tcoll val)) + ([tcoll val & vals] + (let [ntcoll (-disjoin! tcoll val)] + (if vals + (recur ntcoll (first vals) (next vals)) + ntcoll)))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; apply ;;;;;;;;;;;;;;;; + +;; see core.clj +(gen-apply-to) + +(set! *unchecked-if* true) + +(defn- apply-to-simple + "Internal. DO NOT USE! + Assumes args was already called with seq beforehand!" + ([f ^seq args] + (if (nil? args) + (if (.-cljs$core$IFn$_invoke$arity$0 f) + (.cljs$core$IFn$_invoke$arity$0 f) + (.call f f)) + (apply-to-simple f (-first args) (next args)))) + ([f a0 ^seq args] + (if (nil? args) + (if (.-cljs$core$IFn$_invoke$arity$1 f) + (.cljs$core$IFn$_invoke$arity$1 f a0) + (.call f f a0)) + (apply-to-simple f a0 (-first args) (next args)))) + ([f a0 a1 ^seq args] + (if (nil? args) + (if (.-cljs$core$IFn$_invoke$arity$2 f) + (.cljs$core$IFn$_invoke$arity$2 f a0 a1) + (.call f f a0 a1)) + (apply-to-simple f a0 a1 (-first args) (next args)))) + ([f a0 a1 a2 ^seq args] + (if (nil? args) + (if (.-cljs$core$IFn$_invoke$arity$3 f) + (.cljs$core$IFn$_invoke$arity$3 f a0 a1 a2) + (.call f f a0 a1 a2)) + (apply-to-simple f a0 a1 a2 (-first args) (next args)))) + ([f a0 a1 a2 a3 ^seq args] + (if (nil? args) + (if (.-cljs$core$IFn$_invoke$arity$4 f) + (.cljs$core$IFn$_invoke$arity$4 f a0 a1 a2 a3) + (.call f f a0 a1 a2 a3)) + (gen-apply-to-simple f 4 args)))) + +(defn apply + "Applies fn f to the argument list formed by prepending intervening arguments to args." + ([f args] + (if (.-cljs$lang$applyTo f) + (let [fixed-arity (.-cljs$lang$maxFixedArity f) + bc (bounded-count (inc fixed-arity) args)] + (if (<= bc fixed-arity) + (apply-to f bc args) + (.cljs$lang$applyTo f args))) + (apply-to-simple f (seq args)))) + ([f x args] + (if (.-cljs$lang$applyTo f) + (let [arglist (list* x args) + fixed-arity (.-cljs$lang$maxFixedArity f) + bc (inc (bounded-count fixed-arity args))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (apply-to-simple f x (seq args)))) + ([f x y args] + (if (.-cljs$lang$applyTo f) + (let [arglist (list* x y args) + fixed-arity (.-cljs$lang$maxFixedArity f) + bc (+ 2 (bounded-count (dec fixed-arity) args))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (apply-to-simple f x y (seq args)))) + ([f x y z args] + (if (.-cljs$lang$applyTo f) + (let [arglist (list* x y z args) + fixed-arity (.-cljs$lang$maxFixedArity f) + bc (+ 3 (bounded-count (- fixed-arity 2) args))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (apply-to-simple f x y z (seq args)))) + ([f a b c d & args] + (if (.-cljs$lang$applyTo f) + (let [spread-args (spread args) + arglist (cons a (cons b (cons c (cons d spread-args)))) + fixed-arity (.-cljs$lang$maxFixedArity f) + bc (+ 4 (bounded-count (- fixed-arity 3) spread-args))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (apply-to-simple f a b c d (spread args))))) + +(set! *unchecked-if* false) + +(defn vary-meta + "Returns an object of the same type and value as obj, with + (apply f (meta obj) args) as its metadata." + ([obj f] + (with-meta obj (f (meta obj)))) + ([obj f a] + (with-meta obj (f (meta obj) a))) + ([obj f a b] + (with-meta obj (f (meta obj) a b))) + ([obj f a b c] + (with-meta obj (f (meta obj) a b c))) + ([obj f a b c d] + (with-meta obj (f (meta obj) a b c d))) + ([obj f a b c d & args] + (with-meta obj (apply f (meta obj) a b c d args)))) + +(defn ^boolean not= + "Same as (not (= obj1 obj2))" + ([x] false) + ([x y] (not (= x y))) + ([x y & more] + (not (apply = x y more)))) + +(defn not-empty + "If coll is empty, returns nil, else coll" + [coll] (when (seq coll) coll)) + +(defn nil-iter [] + (reify + Object + (hasNext [_] false) + (next [_] (js/Error. "No such element")) + (remove [_] (js/Error. "Unsupported operation")))) + +(deftype StringIter [s ^:mutable i] + Object + (hasNext [_] (< i (.-length s))) + (next [_] + (let [ret (.charAt s i)] + (set! i (inc i)) + ret)) + (remove [_] (js/Error. "Unsupported operation"))) + +(defn string-iter [x] + (StringIter. x 0)) + +(deftype ArrayIter [arr ^:mutable i] + Object + (hasNext [_] (< i (alength arr))) + (next [_] + (let [ret (aget arr i)] + (set! i (inc i)) + ret)) + (remove [_] (js/Error. "Unsupported operation"))) + +(defn array-iter [x] + (ArrayIter. x 0)) + +(def INIT #js {}) +(def START #js {}) + +(deftype SeqIter [^:mutable _seq ^:mutable _next] + Object + (hasNext [_] + (if (identical? _seq INIT) + (do + (set! _seq START) + (set! _next (seq _next))) + (if (identical? _seq _next) + (set! _next (next _seq)))) + (not (nil? _next))) + (next [this] + (if-not ^boolean (.hasNext this) + (throw (js/Error. "No such element")) + (do + (set! _seq _next) + (first _next)))) + (remove [_] (js/Error. "Unsupported operation"))) + +(defn seq-iter [coll] + (SeqIter. INIT coll)) + +(defn iter [coll] + (cond + (iterable? coll) (-iterator coll) + (nil? coll) (nil-iter) + (string? coll) (string-iter coll) + (array? coll) (array-iter coll) + (seqable? coll) (seq-iter coll) + :else (throw (js/Error. (str "Cannot create iterator from " coll))))) + +(deftype Many [vals] + Object + (add [this o] + (.push vals o) + this) + (remove [this] + (.shift vals)) + (isEmpty [this] + (zero? (.-length vals))) + (toString [this] + (str "Many: " vals))) + +(def ^:private NONE #js {}) + +(deftype Single [^:mutable val] + Object + (add [this o] + (if (identical? val NONE) + (do + (set! val o) + this) + (Many. #js [val o]))) + (remove [this] + (if (identical? val NONE) + (throw (js/Error. (str "Removing object from empty buffer"))) + (let [ret val] + (set! val NONE) + ret))) + (isEmpty [this] + (identical? val NONE)) + (toString [this] + (str "Single: " val))) + +(deftype Empty [] + Object + (add [this o] + (Single. o)) + (remove [this] + (throw (js/Error. (str "Removing object from empty buffer")))) + (isEmpty [this] + true) + (toString [this] + "Empty")) + +(def ^:private EMPTY (Empty.)) + +(deftype MultiIterator [iters] + Object + (hasNext [_] + (loop [iters (seq iters)] + (if-not (nil? iters) + (let [iter (first iters)] + (if-not ^boolean (.hasNext iter) + false + (recur (next iters)))) + true))) + (next [_] + (let [nexts (array)] + (dotimes [i (alength iters)] + (aset nexts i (.next (aget iters i)))) + (prim-seq nexts 0)))) + +(defn- chunkIteratorSeq [iter] + (lazy-seq + (when ^boolean (.hasNext iter) + (let [arr (array)] + (loop [n 0] + (if (and (.hasNext iter) (< n 32)) + (do + (aset arr n (.next iter)) + (recur (inc n))) + (chunk-cons (array-chunk arr 0 n) (chunkIteratorSeq iter)))))))) + +(deftype TransformerIterator [^:mutable buffer ^:mutable _next ^:mutable completed ^:mutable xf sourceIter multi] + Object + (step [this] + (if-not (identical? _next NONE) + true + (loop [] + (if (identical? _next NONE) + (if ^boolean (.isEmpty buffer) + (if ^boolean completed + false + (if ^boolean (.hasNext sourceIter) + (let [iter (if ^boolean multi + (apply xf (cons nil (.next sourceIter))) + (xf nil (.next sourceIter)))] + (when (reduced? iter) + (xf nil) + (set! completed true)) + (recur)) + (do + (xf nil) + (set! completed true) + (recur)))) + (do + (set! _next (.remove buffer)) + (recur))) + true)))) + (hasNext [this] + (.step this)) + (next [this] + (if ^boolean (.hasNext this) + (let [ret _next] + (set! _next NONE) + ret) + (throw (js/Error. "No such element")))) + (remove [_] + (js/Error. "Unsupported operation"))) + +(es6-iterable TransformerIterator) + +(defn transformer-iterator + [xform sourceIter multi] + (let [iterator (TransformerIterator. EMPTY NONE false nil sourceIter multi)] + (set! (.-xf iterator) + (xform (fn + ([] nil) + ([acc] acc) + ([acc o] + (set! (.-buffer iterator) (.add (.-buffer iterator) o)) + acc)))) + iterator)) + +(set! (.-create TransformerIterator) + (fn [xform source] + (transformer-iterator xform source false))) + +(set! (.-createMulti TransformerIterator) + (fn [xform sources] + (transformer-iterator xform (MultiIterator. (to-array sources)) true))) + +(defn sequence + "Coerces coll to a (possibly empty) sequence, if it is not already + one. Will not force a lazy seq. (sequence nil) yields (), When a + transducer is supplied, returns a lazy sequence of applications of + the transform to the items in coll(s), i.e. to the set of first + items of each coll, followed by the set of second + items in each coll, until any one of the colls is exhausted. Any + remaining items in other colls are ignored. The transform should accept + number-of-colls arguments" + ([coll] + (if (seq? coll) + coll + (or (seq coll) ()))) + ([xform coll] + (or (chunkIteratorSeq + (.create TransformerIterator xform (iter coll))) + ())) + ([xform coll & colls] + (or (chunkIteratorSeq + (.createMulti TransformerIterator xform (map iter (cons coll colls)))) + ()))) + +(defn ^boolean every? + "Returns true if (pred x) is logical true for every x in coll, else + false." + [pred coll] + (cond + (nil? (seq coll)) true + (pred (first coll)) (recur pred (next coll)) + :else false)) + +(defn ^boolean not-every? + "Returns false if (pred x) is logical true for every x in + coll, else true." + [pred coll] (not (every? pred coll))) + +(defn some + "Returns the first logical true value of (pred x) for any x in coll, + else nil. One common idiom is to use a set as pred, for example + this will return :fred if :fred is in the sequence, otherwise nil: + (some #{:fred} coll)" + [pred coll] + (when (seq coll) + (or (pred (first coll)) (recur pred (next coll))))) + +(defn ^boolean not-any? + "Returns false if (pred x) is logical true for any x in coll, + else true." + [pred coll] (not (some pred coll))) + +(defn ^boolean even? + "Returns true if n is even, throws an exception if n is not an integer" + [n] (if (integer? n) + (zero? (bit-and n 1)) + (throw (js/Error. (str "Argument must be an integer: " n))))) + +(defn ^boolean odd? + "Returns true if n is odd, throws an exception if n is not an integer" + [n] (not (even? n))) + +(defn complement + "Takes a fn f and returns a fn that takes the same arguments as f, + has the same effects, if any, and returns the opposite truth value." + [f] + (fn + ([] (not (f))) + ([x] (not (f x))) + ([x y] (not (f x y))) + ([x y & zs] (not (apply f x y zs))))) + +(defn constantly + "Returns a function that takes any number of arguments and returns x." + [x] (fn [& args] x)) + +(defn comp + "Takes a set of functions and returns a fn that is the composition + of those fns. The returned fn takes a variable number of args, + applies the rightmost of fns to the args, the next + fn (right-to-left) to the result, etc." + ([] identity) + ([f] f) + ([f g] + (fn + ([] (f (g))) + ([x] (f (g x))) + ([x y] (f (g x y))) + ([x y z] (f (g x y z))) + ([x y z & args] (f (apply g x y z args))))) + ([f g h] + (fn + ([] (f (g (h)))) + ([x] (f (g (h x)))) + ([x y] (f (g (h x y)))) + ([x y z] (f (g (h x y z)))) + ([x y z & args] (f (g (apply h x y z args)))))) + ([f1 f2 f3 & fs] + (let [fs (reverse (list* f1 f2 f3 fs))] + (fn [& args] + (loop [ret (apply (first fs) args) fs (next fs)] + (if fs + (recur ((first fs) ret) (next fs)) + ret)))))) + +(defn partial + "Takes a function f and fewer than the normal arguments to f, and + returns a fn that takes a variable number of additional args. When + called, the returned function calls f with args + additional args." + ([f] f) + ([f arg1] + (fn + ([] (f arg1)) + ([x] (f arg1 x)) + ([x y] (f arg1 x y)) + ([x y z] (f arg1 x y z)) + ([x y z & args] (apply f arg1 x y z args)))) + ([f arg1 arg2] + (fn + ([] (f arg1 arg2)) + ([x] (f arg1 arg2 x)) + ([x y] (f arg1 arg2 x y)) + ([x y z] (f arg1 arg2 x y z)) + ([x y z & args] (apply f arg1 arg2 x y z args)))) + ([f arg1 arg2 arg3] + (fn + ([] (f arg1 arg2 arg3)) + ([x] (f arg1 arg2 arg3 x)) + ([x y] (f arg1 arg2 arg3 x y)) + ([x y z] (f arg1 arg2 arg3 x y z)) + ([x y z & args] (apply f arg1 arg2 arg3 x y z args)))) + ([f arg1 arg2 arg3 & more] + (fn [& args] (apply f arg1 arg2 arg3 (concat more args))))) + +(defn fnil + "Takes a function f, and returns a function that calls f, replacing + a nil first argument to f with the supplied value x. Higher arity + versions can replace arguments in the second and third + positions (y, z). Note that the function f can take any number of + arguments, not just the one(s) being nil-patched." + ([f x] + (fn + ([a] (f (if (nil? a) x a))) + ([a b] (f (if (nil? a) x a) b)) + ([a b c] (f (if (nil? a) x a) b c)) + ([a b c & ds] (apply f (if (nil? a) x a) b c ds)))) + ([f x y] + (fn + ([a b] (f (if (nil? a) x a) (if (nil? b) y b))) + ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) c)) + ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) c ds)))) + ([f x y z] + (fn + ([a b] (f (if (nil? a) x a) (if (nil? b) y b))) + ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c))) + ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) ds))))) + +(declare volatile!) + +(defn map-indexed + "Returns a lazy sequence consisting of the result of applying f to 0 + and the first item of coll, followed by applying f to 1 and the second + item in coll, etc, until coll is exhausted. Thus function f should + accept 2 arguments, index and item. Returns a stateful transducer when + no collection is provided." + ([f] + (fn [rf] + (let [i (volatile! -1)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (rf result (f (vswap! i inc) input))))))) + ([f coll] + (letfn [(mapi [idx coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (chunk-append b (f (+ idx i) (-nth c i)))) + (chunk-cons (chunk b) (mapi (+ idx size) (chunk-rest s)))) + (cons (f idx (first s)) (mapi (inc idx) (rest s)))))))] + (mapi 0 coll)))) + +(defn keep + "Returns a lazy sequence of the non-nil results of (f item). Note, + this means false return values will be included. f must be free of + side-effects. Returns a transducer when no collection is provided." + ([f] + (fn [rf] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [v (f input)] + (if (nil? v) + result + (rf result v))))))) + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (let [x (f (-nth c i))] + (when-not (nil? x) + (chunk-append b x)))) + (chunk-cons (chunk b) (keep f (chunk-rest s)))) + (let [x (f (first s))] + (if (nil? x) + (keep f (rest s)) + (cons x (keep f (rest s)))))))))) + +;; ============================================================================= +;; Atom + +(deftype Atom [state meta validator watches] + Object + (equiv [this other] + (-equiv this other)) + + IAtom + + IEquiv + (-equiv [o other] (identical? o other)) + + IDeref + (-deref [_] state) + + IMeta + (-meta [_] meta) + + IWatchable + (-notify-watches [this oldval newval] + (doseq [[key f] watches] + (f key this oldval newval))) + (-add-watch [this key f] + (set! (.-watches this) (assoc watches key f)) + this) + (-remove-watch [this key] + (set! (.-watches this) (dissoc watches key))) + + IHash + (-hash [this] (goog/getUid this))) + +(defn atom + "Creates and returns an Atom with an initial value of x and zero or + more options (in any order): + + :meta metadata-map + + :validator validate-fn + + If metadata-map is supplied, it will be come the metadata on the + atom. validate-fn must be nil or a side-effect-free fn of one + argument, which will be passed the intended new state on any state + change. If the new state is unacceptable, the validate-fn should + return false or throw an Error. If either of these error conditions + occur, then the value of the atom will not change." + ([x] (Atom. x nil nil nil)) + ([x & {:keys [meta validator]}] (Atom. x meta validator nil))) + +(declare pr-str) + +(defn reset! + "Sets the value of atom to newval without regard for the + current value. Returns new-value." + [a new-value] + (if (instance? Atom a) + (let [validate (.-validator a)] + (when-not (nil? validate) + (when-not (validate new-value) + (throw (js/Error. "Validator rejected reference state")))) + (let [old-value (.-state a)] + (set! (.-state a) new-value) + (when-not (nil? (.-watches a)) + (-notify-watches a old-value new-value)) + new-value)) + (-reset! a new-value))) + +(defn reset-vals! + "Sets the value of atom to newval. Returns [old new], the value of the + atom before and after the reset." + {:added "1.9"} + [a new-value] + (let [validate (.-validator a)] + (when-not (nil? validate) + (when-not (validate new-value) + (throw (js/Error. "Validator rejected reference state")))) + (let [old-value (.-state a)] + (set! (.-state a) new-value) + (when-not (nil? (.-watches a)) + (-notify-watches a old-value new-value)) + [old-value new-value]))) + +(defn swap! + "Atomically swaps the value of atom to be: + (apply f current-value-of-atom args). Note that f may be called + multiple times, and thus should be free of side effects. Returns + the value that was swapped in." + ([a f] + (if (instance? Atom a) + (reset! a (f (.-state a))) + (-swap! a f))) + ([a f x] + (if (instance? Atom a) + (reset! a (f (.-state a) x)) + (-swap! a f x))) + ([a f x y] + (if (instance? Atom a) + (reset! a (f (.-state a) x y)) + (-swap! a f x y))) + ([a f x y & more] + (if (instance? Atom a) + (reset! a (apply f (.-state a) x y more)) + (-swap! a f x y more)))) + +(defn swap-vals! + "Atomically swaps the value of atom to be: + (apply f current-value-of-atom args). Note that f may be called + multiple times, and thus should be free of side effects. + Returns [old new], the value of the atom before and after the swap." + {:added "1.9"} + ([a f] + (reset-vals! a (f (.-state a)))) + ([a f x] + (reset-vals! a (f (.-state a) x))) + ([a f x y] + (reset-vals! a (f (.-state a) x y))) + ([a f x y & more] + (reset-vals! a (apply f (.-state a) x y more)))) + +(defn compare-and-set! + "Atomically sets the value of atom to newval if and only if the + current value of the atom is equal to oldval. Returns true if + set happened, else false." + [^not-native a oldval newval] + (if (= (-deref a) oldval) + (do (reset! a newval) true) + false)) + +(defn set-validator! + "Sets the validator-fn for an atom. validator-fn must be nil or a + side-effect-free fn of one argument, which will be passed the intended + new state on any state change. If the new state is unacceptable, the + validator-fn should return false or throw an Error. If the current state + is not acceptable to the new validator, an Error will be thrown and the + validator will not be changed." + [iref val] + (when (and (some? val) + (not (val (-deref iref)))) + (throw (js/Error. "Validator rejected reference state"))) + (set! (.-validator iref) val)) + +(defn get-validator + "Gets the validator-fn for a var/ref/agent/atom." + [iref] + (.-validator iref)) + +(deftype Volatile [^:mutable state] + IVolatile + (-vreset! [_ new-state] + (set! state new-state)) + + IDeref + (-deref [_] state)) + +(defn volatile! + "Creates and returns a Volatile with an initial value of val." + [val] + (Volatile. val)) + +(defn ^boolean volatile? + "Returns true if x is a volatile." + [x] (instance? Volatile x)) + +(defn vreset! + "Sets the value of volatile to newval without regard for the + current value. Returns newval." + [vol newval] (-vreset! vol newval)) + +(defn keep-indexed + "Returns a lazy sequence of the non-nil results of (f index item). Note, + this means false return values will be included. f must be free of + side-effects. Returns a stateful transducer when no collection is + provided." + ([f] + (fn [rf] + (let [ia (volatile! -1)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [i (vswap! ia inc) + v (f i input)] + (if (nil? v) + result + (rf result v)))))))) + ([f coll] + (letfn [(keepi [idx coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (let [x (f (+ idx i) (-nth c i))] + (when-not (nil? x) + (chunk-append b x)))) + (chunk-cons (chunk b) (keepi (+ idx size) (chunk-rest s)))) + (let [x (f idx (first s))] + (if (nil? x) + (keepi (inc idx) (rest s)) + (cons x (keepi (inc idx) (rest s)))))))))] + (keepi 0 coll)))) + +(defn every-pred + "Takes a set of predicates and returns a function f that returns true if all of its + composing predicates return a logical true value against all of its arguments, else it returns + false. Note that f is short-circuiting in that it will stop execution on the first + argument that triggers a logical false result against the original predicates." + ([p] + (fn ep1 + ([] true) + ([x] (boolean (p x))) + ([x y] (boolean (and (p x) (p y)))) + ([x y z] (boolean (and (p x) (p y) (p z)))) + ([x y z & args] (boolean (and (ep1 x y z) + (every? p args)))))) + ([p1 p2] + (fn ep2 + ([] true) + ([x] (boolean (and (p1 x) (p2 x)))) + ([x y] (boolean (and (p1 x) (p1 y) (p2 x) (p2 y)))) + ([x y z] (boolean (and (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z)))) + ([x y z & args] (boolean (and (ep2 x y z) + (every? #(and (p1 %) (p2 %)) args)))))) + ([p1 p2 p3] + (fn ep3 + ([] true) + ([x] (boolean (and (p1 x) (p2 x) (p3 x)))) + ([x y] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y)))) + ([x y z] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y) (p1 z) (p2 z) (p3 z)))) + ([x y z & args] (boolean (and (ep3 x y z) + (every? #(and (p1 %) (p2 %) (p3 %)) args)))))) + ([p1 p2 p3 & ps] + (let [ps (list* p1 p2 p3 ps)] + (fn epn + ([] true) + ([x] (every? #(% x) ps)) + ([x y] (every? #(and (% x) (% y)) ps)) + ([x y z] (every? #(and (% x) (% y) (% z)) ps)) + ([x y z & args] (boolean (and (epn x y z) + (every? #(every? % args) ps)))))))) + +(defn some-fn + "Takes a set of predicates and returns a function f that returns the first logical true value + returned by one of its composing predicates against any of its arguments, else it returns + logical false. Note that f is short-circuiting in that it will stop execution on the first + argument that triggers a logical true result against the original predicates." + ([p] + (fn sp1 + ([] nil) + ([x] (p x)) + ([x y] (or (p x) (p y))) + ([x y z] (or (p x) (p y) (p z))) + ([x y z & args] (or (sp1 x y z) + (some p args))))) + ([p1 p2] + (fn sp2 + ([] nil) + ([x] (or (p1 x) (p2 x))) + ([x y] (or (p1 x) (p1 y) (p2 x) (p2 y))) + ([x y z] (or (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z))) + ([x y z & args] (or (sp2 x y z) + (some #(or (p1 %) (p2 %)) args))))) + ([p1 p2 p3] + (fn sp3 + ([] nil) + ([x] (or (p1 x) (p2 x) (p3 x))) + ([x y] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y))) + ([x y z] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y) (p1 z) (p2 z) (p3 z))) + ([x y z & args] (or (sp3 x y z) + (some #(or (p1 %) (p2 %) (p3 %)) args))))) + ([p1 p2 p3 & ps] + (let [ps (list* p1 p2 p3 ps)] + (fn spn + ([] nil) + ([x] (some #(% x) ps)) + ([x y] (some #(or (% x) (% y)) ps)) + ([x y z] (some #(or (% x) (% y) (% z)) ps)) + ([x y z & args] (or (spn x y z) + (some #(some % args) ps))))))) + +(defn map + "Returns a lazy sequence consisting of the result of applying f to + the set of first items of each coll, followed by applying f to the + set of second items in each coll, until any one of the colls is + exhausted. Any remaining items in other colls are ignored. Function + f should accept number-of-colls arguments. Returns a transducer when + no collection is provided." + ([f] + (fn [rf] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (rf result (f input))) + ([result input & inputs] + (rf result (apply f input inputs)))))) + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (chunk-append b (f (-nth c i)))) + (chunk-cons (chunk b) (map f (chunk-rest s)))) + (cons (f (first s)) (map f (rest s))))))) + ([f c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (f (first s1) (first s2)) + (map f (rest s1) (rest s2))))))) + ([f c1 c2 c3] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2) s3 (seq c3)] + (when (and s1 s2 s3) + (cons (f (first s1) (first s2) (first s3)) + (map f (rest s1) (rest s2) (rest s3))))))) + ([f c1 c2 c3 & colls] + (let [step (fn step [cs] + (lazy-seq + (let [ss (map seq cs)] + (when (every? identity ss) + (cons (map first ss) (step (map rest ss)))))))] + (map #(apply f %) (step (conj colls c3 c2 c1)))))) + +(defn take + "Returns a lazy sequence of the first n items in coll, or all items if + there are fewer than n. Returns a stateful transducer when + no collection is provided." + ([n] + {:pre [(number? n)]} + (fn [rf] + (let [na (volatile! n)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [n @na + nn (vswap! na dec) + result (if (pos? n) + (rf result input) + result)] + (if (not (pos? nn)) + (ensure-reduced result) + result))))))) + ([n coll] + {:pre [(number? n)]} + (lazy-seq + (when (pos? n) + (when-let [s (seq coll)] + (cons (first s) (take (dec n) (rest s)))))))) + +(defn drop + "Returns a lazy sequence of all but the first n items in coll. + Returns a stateful transducer when no collection is provided." + ([n] + {:pre [(number? n)]} + (fn [rf] + (let [na (volatile! n)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [n @na] + (vswap! na dec) + (if (pos? n) + result + (rf result input)))))))) + ([n coll] + {:pre [(number? n)]} + (let [step (fn [n coll] + (let [s (seq coll)] + (if (and (pos? n) s) + (recur (dec n) (rest s)) + s)))] + (lazy-seq (step n coll))))) + +(defn drop-last + "Return a lazy sequence of all but the last n (default 1) items in coll" + ([s] (drop-last 1 s)) + ([n s] (map (fn [x _] x) s (drop n s)))) + +(defn take-last + "Returns a seq of the last n items in coll. Depending on the type + of coll may be no better than linear time. For vectors, see also subvec." + [n coll] + (loop [s (seq coll), lead (seq (drop n coll))] + (if lead + (recur (next s) (next lead)) + s))) + +(defn drop-while + "Returns a lazy sequence of the items in coll starting from the + first item for which (pred item) returns logical false. Returns a + stateful transducer when no collection is provided." + ([pred] + (fn [rf] + (let [da (volatile! true)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [drop? @da] + (if (and drop? (pred input)) + result + (do + (vreset! da nil) + (rf result input))))))))) + ([pred coll] + (let [step (fn [pred coll] + (let [s (seq coll)] + (if (and s (pred (first s))) + (recur pred (rest s)) + s)))] + (lazy-seq (step pred coll))))) + +(deftype Cycle [meta all prev ^:mutable current ^:mutable _next] + Object + (toString [coll] + (pr-str* coll)) + (currentval [coll] + (when-not ^seq current + (if-let [c (next prev)] + (set! current c) + (set! current all))) + current) + + IPending + (-realized? [coll] + (some? current)) + + IWithMeta + (-with-meta [coll meta] (Cycle. meta all prev current _next)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] + (first (.currentval coll))) + (-rest [coll] + (when (nil? _next) + (set! _next (Cycle. nil all (.currentval coll) nil nil))) + _next) + + INext + (-next [coll] + (-rest coll)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + ISeqable + (-seq [coll] coll) + + IReduce + (-reduce [coll f] + (loop [s (.currentval coll) ret (first s)] + (let [s (or (next s) all) + ret (f ret (first s))] + (if (reduced? ret) + @ret + (recur s ret))))) + (-reduce [coll f start] + (loop [s (.currentval coll) ret start] + (let [ret (f ret (first s))] + (if (reduced? ret) + @ret + (recur (or (next s) all) ret)))))) + +(defn cycle + "Returns a lazy (infinite!) sequence of repetitions of the items in coll." + [coll] (if-let [vals (seq coll)] + (Cycle. nil vals nil vals nil) + (.-EMPTY List))) + +(defn split-at + "Returns a vector of [(take n coll) (drop n coll)]" + [n coll] + [(take n coll) (drop n coll)]) + +(deftype Repeat [meta count val ^:mutable next ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x count)) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IPending + (-realized? [coll] false) + + IWithMeta + (-with-meta [coll meta] (Repeat. meta count val next nil)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] + val) + (-rest [coll] + (if (nil? next) + (if (> count 1) + (do + (set! next (Repeat. nil (dec count) val nil nil)) + next) + (if (== -1 count) + coll + ())) + next)) + + INext + (-next [coll] + (if (nil? next) + (if (> count 1) + (do + (set! next (Repeat. nil (dec count) val nil nil)) + next) + (if (== -1 count) + coll + nil)) + next)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISequential + ISeqable + (-seq [coll] coll) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IReduce + (-reduce [coll f] + (if (== count -1) + (loop [ret (f val val)] + (if (reduced? ret) + @ret + (recur (f ret val)))) + (loop [i 1 ret val] + (if (< i count) + (let [ret (f ret val)] + (if (reduced? ret) + @ret + (recur (inc i) ret))) + ret)))) + (-reduce [coll f start] + (if (== count -1) + (loop [ret (f start val)] + (if (reduced? ret) + @ret + (recur (f ret val)))) + (loop [i 0 ret start] + (if (< i count) + (let [ret (f ret val)] + (if (reduced? ret) + @ret + (recur (inc i) ret))) + ret))))) + +(defn repeat + "Returns a lazy (infinite!, or length n if supplied) sequence of xs." + ([x] (Repeat. nil -1 x nil nil)) + ([n x] (if (pos? n) + (Repeat. nil n x nil nil) + (.-EMPTY List)))) + +(defn replicate + "DEPRECATED: Use 'repeat' instead. + Returns a lazy seq of n xs." + [n x] (take n (repeat x))) + +(defn repeatedly + "Takes a function of no args, presumably with side effects, and + returns an infinite (or length n if supplied) lazy sequence of calls + to it" + ([f] (lazy-seq (cons (f) (repeatedly f)))) + ([n f] (take n (repeatedly f)))) + +(def ^:private UNREALIZED-SEED #js {}) + +(deftype Iterate [meta f prev-seed ^:mutable seed ^:mutable next] + Object + (toString [coll] + (pr-str* coll)) + + IPending + (-realized? [coll] + (not (identical? seed UNREALIZED-SEED))) + + IWithMeta + (-with-meta [coll meta] (Iterate. meta f prev-seed seed next)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] + (when (identical? UNREALIZED-SEED seed) + (set! seed (f prev-seed))) + seed) + (-rest [coll] + (when (nil? next) + (set! next (Iterate. nil f (-first coll) UNREALIZED-SEED nil))) + next) + + INext + (-next [coll] + (-rest coll)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + ISeqable + (-seq [coll] coll) + + IReduce + (-reduce [coll rf] + (let [first (-first coll) + v (f first)] + (loop [ret (rf first v) v v] + (if (reduced? ret) + @ret + (let [v (f v)] + (recur (rf ret v) v)))))) + (-reduce [coll rf start] + (let [v (-first coll)] + (loop [ret (rf start v) v v] + (if (reduced? ret) + @ret + (let [v (f v)] + (recur (rf ret v) v))))))) + +(defn iterate + "Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects" + {:added "1.0"} + [f x] (Iterate. nil f nil x nil)) + +(defn interleave + "Returns a lazy seq of the first item in each coll, then the second etc." + ([] ()) + ([c1] (lazy-seq c1)) + ([c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (first s1) (cons (first s2) + (interleave (rest s1) (rest s2)))))))) + ([c1 c2 & colls] + (lazy-seq + (let [ss (map seq (conj colls c2 c1))] + (when (every? identity ss) + (concat (map first ss) (apply interleave (map rest ss)))))))) + +(defn interpose + "Returns a lazy seq of the elements of coll separated by sep. + Returns a stateful transducer when no collection is provided." + ([sep] + (fn [rf] + (let [started (volatile! false)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (if @started + (let [sepr (rf result sep)] + (if (reduced? sepr) + sepr + (rf sepr input))) + (do + (vreset! started true) + (rf result input)))))))) + ([sep coll] (drop 1 (interleave (repeat sep) coll)))) + + + +(defn- flatten1 + "Take a collection of collections, and return a lazy seq + of items from the inner collection" + [colls] + (let [cat (fn cat [coll colls] + (lazy-seq + (if-let [coll (seq coll)] + (cons (first coll) (cat (rest coll) colls)) + (when (seq colls) + (cat (first colls) (rest colls))))))] + (cat nil colls))) + +(declare cat) + +(defn mapcat + "Returns the result of applying concat to the result of applying map + to f and colls. Thus function f should return a collection. Returns + a transducer when no collections are provided" + {:added "1.0" + :static true} + ([f] (comp (map f) cat)) + ([f & colls] + (apply concat (apply map f colls)))) + +(defn filter + "Returns a lazy sequence of the items in coll for which + (pred item) returns logical true. pred must be free of side-effects. + Returns a transducer when no collection is provided." + ([pred] + (fn [rf] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (if (pred input) + (rf result input) + result))))) + ([pred coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (when (pred (-nth c i)) + (chunk-append b (-nth c i)))) + (chunk-cons (chunk b) (filter pred (chunk-rest s)))) + (let [f (first s) r (rest s)] + (if (pred f) + (cons f (filter pred r)) + (filter pred r)))))))) + +(defn remove + "Returns a lazy sequence of the items in coll for which + (pred item) returns logical false. pred must be free of side-effects. + Returns a transducer when no collection is provided." + ([pred] (filter (complement pred))) + ([pred coll] + (filter (complement pred) coll))) + +(defn tree-seq + "Returns a lazy sequence of the nodes in a tree, via a depth-first walk. + branch? must be a fn of one arg that returns true if passed a node + that can have children (but may not). children must be a fn of one + arg that returns a sequence of the children. Will only be called on + nodes for which branch? returns true. Root is the root node of the + tree." + [branch? children root] + (let [walk (fn walk [node] + (lazy-seq + (cons node + (when (branch? node) + (mapcat walk (children node))))))] + (walk root))) + +(defn flatten + "Takes any nested combination of sequential things (lists, vectors, + etc.) and returns their contents as a single, flat sequence. + (flatten nil) returns nil." + [x] + (filter #(not (sequential? %)) + (rest (tree-seq sequential? seq x)))) + +(defn into + "Returns a new coll consisting of to-coll with all of the items of + from-coll conjoined. A transducer may be supplied." + ([] []) + ([to] to) + ([to from] + (if-not (nil? to) + (if (implements? IEditableCollection to) + (-with-meta (persistent! (reduce -conj! (transient to) from)) (meta to)) + (reduce -conj to from)) + (reduce conj () from))) + ([to xform from] + (if (implements? IEditableCollection to) + (-with-meta (persistent! (transduce xform conj! (transient to) from)) (meta to)) + (transduce xform conj to from)))) + +(defn mapv + "Returns a vector consisting of the result of applying f to the + set of first items of each coll, followed by applying f to the set + of second items in each coll, until any one of the colls is + exhausted. Any remaining items in other colls are ignored. Function + f should accept number-of-colls arguments." + ([f coll] + (-> (reduce (fn [v o] (conj! v (f o))) (transient []) coll) + persistent!)) + ([f c1 c2] + (into [] (map f c1 c2))) + ([f c1 c2 c3] + (into [] (map f c1 c2 c3))) + ([f c1 c2 c3 & colls] + (into [] (apply map f c1 c2 c3 colls)))) + +(defn filterv + "Returns a vector of the items in coll for which + (pred item) returns logical true. pred must be free of side-effects." + [pred coll] + (-> (reduce (fn [v o] (if (pred o) (conj! v o) v)) + (transient []) + coll) + persistent!)) + +(defn partition + "Returns a lazy sequence of lists of n items each, at offsets step + apart. If step is not supplied, defaults to n, i.e. the partitions + do not overlap. If a pad collection is supplied, use its elements as + necessary to complete last partition up to n items. In case there are + not enough padding elements, return a partition with less than n items." + ([n coll] + (partition n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (when (== n (count p)) + (cons p (partition n step (drop step s)))))))) + ([n step pad coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (if (== n (count p)) + (cons p (partition n step pad (drop step s))) + (list (take n (concat p pad))))))))) + +(defn get-in + "Returns the value in a nested associative structure, + where ks is a sequence of keys. Returns nil if the key is not present, + or the not-found value if supplied." + {:added "1.2" + :static true} + ([m ks] + (reduce get m ks)) + ([m ks not-found] + (loop [sentinel lookup-sentinel + m m + ks (seq ks)] + (if-not (nil? ks) + (let [m (get m (first ks) sentinel)] + (if (identical? sentinel m) + not-found + (recur sentinel m (next ks)))) + m)))) + +(defn assoc-in + "Associates a value in a nested associative structure, where ks is a + sequence of keys and v is the new value and returns a new nested structure. + If any levels do not exist, hash-maps will be created." + [m [k & ks] v] + (if ks + (assoc m k (assoc-in (get m k) ks v)) + (assoc m k v))) + +(defn update-in + "'Updates' a value in a nested associative structure, where ks is a + sequence of keys and f is a function that will take the old value + and any supplied args and return the new value, and returns a new + nested structure. If any levels do not exist, hash-maps will be + created." + ([m [k & ks] f] + (if ks + (assoc m k (update-in (get m k) ks f)) + (assoc m k (f (get m k))))) + ([m [k & ks] f a] + (if ks + (assoc m k (update-in (get m k) ks f a)) + (assoc m k (f (get m k) a)))) + ([m [k & ks] f a b] + (if ks + (assoc m k (update-in (get m k) ks f a b)) + (assoc m k (f (get m k) a b)))) + ([m [k & ks] f a b c] + (if ks + (assoc m k (update-in (get m k) ks f a b c)) + (assoc m k (f (get m k) a b c)))) + ([m [k & ks] f a b c & args] + (if ks + (assoc m k (apply update-in (get m k) ks f a b c args)) + (assoc m k (apply f (get m k) a b c args))))) + +(defn update + "'Updates' a value in an associative structure, where k is a + key and f is a function that will take the old value + and any supplied args and return the new value, and returns a new + structure. If the key does not exist, nil is passed as the old value." + ([m k f] + (assoc m k (f (get m k)))) + ([m k f x] + (assoc m k (f (get m k) x))) + ([m k f x y] + (assoc m k (f (get m k) x y))) + ([m k f x y z] + (assoc m k (f (get m k) x y z))) + ([m k f x y z & more] + (assoc m k (apply f (get m k) x y z more)))) + +;;; PersistentVector + +(deftype VectorNode [edit arr]) + +(defn- pv-fresh-node [edit] + (VectorNode. edit (make-array 32))) + +(defn- pv-aget [node idx] + (aget (.-arr node) idx)) + +(defn- pv-aset [node idx val] + (aset (.-arr node) idx val)) + +(defn- pv-clone-node [node] + (VectorNode. (.-edit node) (aclone (.-arr node)))) + +(defn- tail-off [pv] + (let [cnt (.-cnt pv)] + (if (< cnt 32) + 0 + (bit-shift-left (bit-shift-right-zero-fill (dec cnt) 5) 5)))) + +(defn- new-path [edit level node] + (loop [ll level + ret node] + (if (zero? ll) + ret + (let [embed ret + r (pv-fresh-node edit) + _ (pv-aset r 0 embed)] + (recur (- ll 5) r))))) + +(defn- push-tail [pv level parent tailnode] + (let [ret (pv-clone-node parent) + subidx (bit-and (bit-shift-right-zero-fill (dec (.-cnt pv)) level) 0x01f)] + (if (== 5 level) + (do + (pv-aset ret subidx tailnode) + ret) + (let [child (pv-aget parent subidx)] + (if-not (nil? child) + (let [node-to-insert (push-tail pv (- level 5) child tailnode)] + (pv-aset ret subidx node-to-insert) + ret) + (let [node-to-insert (new-path nil (- level 5) tailnode)] + (pv-aset ret subidx node-to-insert) + ret)))))) + +(defn- vector-index-out-of-bounds [i cnt] + (throw (js/Error. (str "No item " i " in vector of length " cnt)))) + +(defn- first-array-for-longvec [pv] + ;; invariants: (count pv) > 32. + (loop [node (.-root pv) + level (.-shift pv)] + (if (pos? level) + (recur (pv-aget node 0) (- level 5)) + (.-arr node)))) + +(defn- unchecked-array-for [pv i] + ;; invariant: i is a valid index of pv (use array-for if unknown). + (if (>= i (tail-off pv)) + (.-tail pv) + (loop [node (.-root pv) + level (.-shift pv)] + (if (pos? level) + (recur (pv-aget node (bit-and (bit-shift-right-zero-fill i level) 0x01f)) + (- level 5)) + (.-arr node))))) + +(defn- array-for [pv i] + (if (and (<= 0 i) (< i (.-cnt pv))) + (unchecked-array-for pv i) + (vector-index-out-of-bounds i (.-cnt pv)))) + +(defn- do-assoc [pv level node i val] + (let [ret (pv-clone-node node)] + (if (zero? level) + (do + (pv-aset ret (bit-and i 0x01f) val) + ret) + (let [subidx (bit-and (bit-shift-right-zero-fill i level) 0x01f)] + (pv-aset ret subidx (do-assoc pv (- level 5) (pv-aget node subidx) i val)) + ret)))) + +(defn- pop-tail [pv level node] + (let [subidx (bit-and (bit-shift-right-zero-fill (- (.-cnt pv) 2) level) 0x01f)] + (cond + (> level 5) (let [new-child (pop-tail pv (- level 5) (pv-aget node subidx))] + (if (and (nil? new-child) (zero? subidx)) + nil + (let [ret (pv-clone-node node)] + (pv-aset ret subidx new-child) + ret))) + (zero? subidx) nil + :else (let [ret (pv-clone-node node)] + (pv-aset ret subidx nil) + ret)))) + +(deftype RangedIterator [^:mutable i ^:mutable base ^:mutable arr v start end] + Object + (hasNext [this] + (< i end)) + (next [this] + (when (== (- i base) 32) + (set! arr (unchecked-array-for v i)) + (set! base (+ base 32))) + (let [ret (aget arr (bit-and i 0x01f))] + (set! i (inc i)) + ret))) + +(defn ranged-iterator [v start end] + (let [i start] + (RangedIterator. i (- i (js-mod i 32)) + (when (< start (count v)) + (unchecked-array-for v i)) + v start end))) + +(defn- pv-reduce + ([pv f start end] + (if (< start end) + (pv-reduce pv f (nth pv start) (inc start) end) + (f))) + ([pv f init start end] + (loop [acc init i start arr (unchecked-array-for pv start)] + (if (< i end) + (let [j (bit-and i 0x01f) + arr (if (zero? j) (unchecked-array-for pv i) arr) + nacc (f acc (aget arr j))] + (if (reduced? nacc) + @nacc + (recur nacc (inc i) arr))) + acc)))) + +(declare tv-editable-root tv-editable-tail TransientVector deref + pr-sequential-writer pr-writer chunked-seq) + +(defprotocol APersistentVector + "Marker protocol") + +(deftype PersistentVector [meta cnt shift root tail ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ICloneable + (-clone [_] (PersistentVector. meta cnt shift root tail __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentVector. meta cnt shift root tail __hash)) + + IMeta + (-meta [coll] meta) + + IStack + (-peek [coll] + (when (> cnt 0) + (-nth coll (dec cnt)))) + (-pop [coll] + (cond + (zero? cnt) (throw (js/Error. "Can't pop empty vector")) + (== 1 cnt) (-with-meta (.-EMPTY PersistentVector) meta) + (< 1 (- cnt (tail-off coll))) + (PersistentVector. meta (dec cnt) shift root (.slice tail 0 -1) nil) + :else (let [new-tail (unchecked-array-for coll (- cnt 2)) + nr (pop-tail coll shift root) + new-root (if (nil? nr) (.-EMPTY-NODE PersistentVector) nr) + cnt-1 (dec cnt)] + (if (and (< 5 shift) (nil? (pv-aget new-root 1))) + (PersistentVector. meta cnt-1 (- shift 5) (pv-aget new-root 0) new-tail nil) + (PersistentVector. meta cnt-1 shift new-root new-tail nil))))) + + ICollection + (-conj [coll o] + (if (< (- cnt (tail-off coll)) 32) + (let [len (alength tail) + new-tail (make-array (inc len))] + (dotimes [i len] + (aset new-tail i (aget tail i))) + (aset new-tail len o) + (PersistentVector. meta (inc cnt) shift root new-tail nil)) + (let [root-overflow? (> (bit-shift-right-zero-fill cnt 5) (bit-shift-left 1 shift)) + new-shift (if root-overflow? (+ shift 5) shift) + new-root (if root-overflow? + (let [n-r (pv-fresh-node nil)] + (pv-aset n-r 0 root) + (pv-aset n-r 1 (new-path nil shift (VectorNode. nil tail))) + n-r) + (push-tail coll shift root (VectorNode. nil tail)))] + (PersistentVector. meta (inc cnt) new-shift new-root (array o) nil)))) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY PersistentVector) meta)) + + ISequential + IEquiv + (-equiv [coll other] + (if (instance? PersistentVector other) + (if (== cnt (count other)) + (let [me-iter (-iterator coll) + you-iter (-iterator other)] + (loop [] + (if ^boolean (.hasNext me-iter) + (let [x (.next me-iter) + y (.next you-iter)] + (if (= x y) + (recur) + false)) + true))) + false) + (equiv-sequential coll other))) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] + (cond + (zero? cnt) nil + (<= cnt 32) (IndexedSeq. tail 0 nil) + :else (chunked-seq coll (first-array-for-longvec coll) 0 0))) + + ICounted + (-count [coll] cnt) + + IIndexed + (-nth [coll n] + (aget (array-for coll n) (bit-and n 0x01f))) + (-nth [coll n not-found] + (if (and (<= 0 n) (< n cnt)) + (aget (unchecked-array-for coll n) (bit-and n 0x01f)) + not-found)) + + ILookup + (-lookup [coll k] (-lookup coll k nil)) + (-lookup [coll k not-found] (if (number? k) + (-nth coll k not-found) + not-found)) + + IAssociative + (-assoc [coll k v] + (if (number? k) + (-assoc-n coll k v) + (throw (js/Error. "Vector's key for assoc must be a number.")))) + (-contains-key? [coll k] + (if (integer? k) + (and (<= 0 k) (< k cnt)) + false)) + + IFind + (-find [coll n] + (when (and (<= 0 n) (< n cnt)) + (MapEntry. n (aget (unchecked-array-for coll n) (bit-and n 0x01f)) nil))) + + APersistentVector + IVector + (-assoc-n [coll n val] + (cond + (and (<= 0 n) (< n cnt)) + (if (<= (tail-off coll) n) + (let [new-tail (aclone tail)] + (aset new-tail (bit-and n 0x01f) val) + (PersistentVector. meta cnt shift root new-tail nil)) + (PersistentVector. meta cnt shift (do-assoc coll shift root n val) tail nil)) + (== n cnt) (-conj coll val) + :else (throw (js/Error. (str "Index " n " out of bounds [0," cnt "]"))))) + + IReduce + (-reduce [v f] + (pv-reduce v f 0 cnt)) + (-reduce [v f init] + (loop [i 0 init init] + (if (< i cnt) + (let [arr (unchecked-array-for v i) + len (alength arr) + init (loop [j 0 init init] + (if (< j len) + (let [init (f init (aget arr j))] + (if (reduced? init) + init + (recur (inc j) init))) + init))] + (if (reduced? init) + @init + (recur (+ i len) init))) + init))) + + IKVReduce + (-kv-reduce [v f init] + (loop [i 0 init init] + (if (< i cnt) + (let [arr (unchecked-array-for v i) + len (alength arr) + init (loop [j 0 init init] + (if (< j len) + (let [init (f init (+ j i) (aget arr j))] + (if (reduced? init) + init + (recur (inc j) init))) + init))] + (if (reduced? init) + @init + (recur (+ i len) init))) + init))) + + IFn + (-invoke [coll k] + (-nth coll k)) + (-invoke [coll k not-found] + (-nth coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientVector. cnt shift (tv-editable-root root) (tv-editable-tail tail))) + + IReversible + (-rseq [coll] + (when (pos? cnt) + (RSeq. coll (dec cnt) nil))) + + IIterable + (-iterator [this] + (ranged-iterator this 0 cnt))) + +(set! (.-EMPTY-NODE PersistentVector) (VectorNode. nil (make-array 32))) + +(set! (.-EMPTY PersistentVector) + (PersistentVector. nil 0 5 (.-EMPTY-NODE PersistentVector) (array) empty-ordered-hash)) + +(set! (.-fromArray PersistentVector) + (fn [xs ^boolean no-clone] + (let [l (alength xs) + xs (if no-clone xs (aclone xs))] + (if (< l 32) + (PersistentVector. nil l 5 (.-EMPTY-NODE PersistentVector) xs nil) + (let [node (.slice xs 0 32) + v (PersistentVector. nil 32 5 (.-EMPTY-NODE PersistentVector) node nil)] + (loop [i 32 out (-as-transient v)] + (if (< i l) + (recur (inc i) (conj! out (aget xs i))) + (persistent! out)))))))) + +(es6-iterable PersistentVector) + +(defn vec + "Creates a new vector containing the contents of coll. JavaScript arrays + will be aliased and should not be modified." + [coll] + (if (array? coll) + (.fromArray PersistentVector coll true) + (-persistent! + (reduce -conj! + (-as-transient (.-EMPTY PersistentVector)) + coll)))) + +(defn vector + "Creates a new vector containing the args." + [& args] + (if (and (instance? IndexedSeq args) (zero? (.-i args))) + (.fromArray PersistentVector (.-arr args) true) + (vec args))) + +(declare subvec) + +(deftype ChunkedSeq [vec node i off meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IWithMeta + (-with-meta [coll m] + (chunked-seq vec node i off m)) + IMeta + (-meta [coll] meta) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ASeq + ISeq + (-first [coll] + (aget node off)) + (-rest [coll] + (if (< (inc off) (alength node)) + (let [s (chunked-seq vec node i (inc off))] + (if (nil? s) + () + s)) + (-chunked-rest coll))) + + INext + (-next [coll] + (if (< (inc off) (alength node)) + (let [s (chunked-seq vec node i (inc off))] + (if (nil? s) + nil + s)) + (-chunked-next coll))) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] + ()) + + IChunkedSeq + (-chunked-first [coll] + (array-chunk node off)) + (-chunked-rest [coll] + (let [end (+ i (alength node))] + (if (< end (-count vec)) + (chunked-seq vec (unchecked-array-for vec end) end 0) + ()))) + + IChunkedNext + (-chunked-next [coll] + (let [end (+ i (alength node))] + (when (< end (-count vec)) + (chunked-seq vec (unchecked-array-for vec end) end 0)))) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IReduce + (-reduce [coll f] + (pv-reduce vec f (+ i off) (count vec))) + + (-reduce [coll f start] + (pv-reduce vec f start (+ i off) (count vec)))) + +(es6-iterable ChunkedSeq) + +(defn chunked-seq + ([vec i off] (ChunkedSeq. vec (array-for vec i) i off nil nil)) + ([vec node i off] (ChunkedSeq. vec node i off nil nil)) + ([vec node i off meta] + (ChunkedSeq. vec node i off meta nil))) + +(declare build-subvec) + +(deftype Subvec [meta v start end ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ICloneable + (-clone [_] (Subvec. meta v start end __hash)) + + IWithMeta + (-with-meta [coll meta] (build-subvec meta v start end __hash)) + + IMeta + (-meta [coll] meta) + + IStack + (-peek [coll] + (-nth v (dec end))) + (-pop [coll] + (if (== start end) + (throw (js/Error. "Can't pop empty vector")) + (build-subvec meta v start (dec end) nil))) + + ICollection + (-conj [coll o] + (build-subvec meta (-assoc-n v end o) start (inc end) nil)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY PersistentVector) meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] + (let [subvec-seq (fn subvec-seq [i] + (when-not (== i end) + (cons (-nth v i) + (lazy-seq + (subvec-seq (inc i))))))] + (subvec-seq start))) + + IReversible + (-rseq [coll] + (if-not (== start end) + (RSeq. coll (dec (- end start)) nil))) + + ICounted + (-count [coll] (- end start)) + + IIndexed + (-nth [coll n] + (if (or (neg? n) (<= end (+ start n))) + (vector-index-out-of-bounds n (- end start)) + (-nth v (+ start n)))) + (-nth [coll n not-found] + (if (or (neg? n) (<= end (+ start n))) + not-found + (-nth v (+ start n) not-found))) + + ILookup + (-lookup [coll k] (-lookup coll k nil)) + (-lookup [coll k not-found] (if (number? k) + (-nth coll k not-found) + not-found)) + + IAssociative + (-assoc [coll key val] + (if (number? key) + (-assoc-n coll key val) + (throw (js/Error. "Subvec's key for assoc must be a number.")))) + + IFind + (-find [coll n] + (when-not (neg? n) + (let [idx (+ start n)] + (when (< idx end) + (MapEntry. n (-lookup v idx) nil))))) + + IVector + (-assoc-n [coll n val] + (let [v-pos (+ start n)] + (if (or (neg? n) (<= (inc end) v-pos)) + (throw (js/Error. (str "Index " n " out of bounds [0," (-count coll) "]"))) + (build-subvec meta (assoc v v-pos val) start (max end (inc v-pos)) nil)))) + + IReduce + (-reduce [coll f] + (if (implements? APersistentVector v) + (pv-reduce v f start end) + (ci-reduce coll f))) + (-reduce [coll f init] + (if (implements? APersistentVector v) + (pv-reduce v f init start end) + (ci-reduce coll f init))) + + IKVReduce + (-kv-reduce [coll f init] + (loop [i start j 0 init init] + (if (< i end) + (let [init (f init j (-nth v i))] + (if (reduced? init) + @init + (recur (inc i) (inc j) init))) + init))) + + IFn + (-invoke [coll k] + (-nth coll k)) + (-invoke [coll k not-found] + (-nth coll k not-found)) + + IIterable + (-iterator [coll] + (if (implements? APersistentVector v) + (ranged-iterator v start end) + (seq-iter coll)))) + +(es6-iterable Subvec) + +(defn- build-subvec [meta v start end __hash] + (if (instance? Subvec v) + (recur meta (.-v v) (+ (.-start v) start) (+ (.-start v) end) __hash) + (do + (when-not (vector? v) + (throw (js/Error. "v must satisfy IVector"))) + (let [c (count v)] + (when (or (neg? start) + (neg? end) + (> start c) + (> end c)) + (throw (js/Error. "Index out of bounds")))) + (Subvec. meta v start end __hash)))) + +(defn subvec + "Returns a persistent vector of the items in vector from + start (inclusive) to end (exclusive). If end is not supplied, + defaults to (count vector). This operation is O(1) and very fast, as + the resulting vector shares structure with the original and no + trimming is done." + ([v start] + (subvec v start (count v))) + ([v start end] + (assert (and (not (nil? start)) (not (nil? end)))) + (build-subvec nil v (int start) (int end) nil))) + +(defn- tv-ensure-editable [edit node] + (if (identical? edit (.-edit node)) + node + (VectorNode. edit (aclone (.-arr node))))) + +(defn- tv-editable-root [node] + (VectorNode. (js-obj) (aclone (.-arr node)))) + +(defn- tv-editable-tail [tl] + (let [ret (make-array 32)] + (array-copy tl 0 ret 0 (alength tl)) + ret)) + +(defn- tv-push-tail [tv level parent tail-node] + (let [ret (tv-ensure-editable (.. tv -root -edit) parent) + subidx (bit-and (bit-shift-right-zero-fill (dec (.-cnt tv)) level) 0x01f)] + (pv-aset ret subidx + (if (== level 5) + tail-node + (let [child (pv-aget ret subidx)] + (if-not (nil? child) + (tv-push-tail tv (- level 5) child tail-node) + (new-path (.. tv -root -edit) (- level 5) tail-node))))) + ret)) + +(defn- tv-pop-tail [tv level node] + (let [node (tv-ensure-editable (.. tv -root -edit) node) + subidx (bit-and (bit-shift-right-zero-fill (- (.-cnt tv) 2) level) 0x01f)] + (cond + (> level 5) (let [new-child (tv-pop-tail + tv (- level 5) (pv-aget node subidx))] + (if (and (nil? new-child) (zero? subidx)) + nil + (do (pv-aset node subidx new-child) + node))) + (zero? subidx) nil + :else (do (pv-aset node subidx nil) + node)))) + +(defn- unchecked-editable-array-for [tv i] + ;; invariant: i is a valid index of tv. + (if (>= i (tail-off tv)) + (.-tail tv) + (let [root (.-root tv)] + (loop [node root + level (.-shift tv)] + (if (pos? level) + (recur (tv-ensure-editable + (.-edit root) + (pv-aget node + (bit-and (bit-shift-right-zero-fill i level) + 0x01f))) + (- level 5)) + (.-arr node)))))) + +(deftype TransientVector [^:mutable cnt + ^:mutable shift + ^:mutable root + ^:mutable tail] + ITransientCollection + (-conj! [tcoll o] + (if ^boolean (.-edit root) + (if (< (- cnt (tail-off tcoll)) 32) + (do (aset tail (bit-and cnt 0x01f) o) + (set! cnt (inc cnt)) + tcoll) + (let [tail-node (VectorNode. (.-edit root) tail) + new-tail (make-array 32)] + (aset new-tail 0 o) + (set! tail new-tail) + (if (> (bit-shift-right-zero-fill cnt 5) + (bit-shift-left 1 shift)) + (let [new-root-array (make-array 32) + new-shift (+ shift 5)] + (aset new-root-array 0 root) + (aset new-root-array 1 (new-path (.-edit root) shift tail-node)) + (set! root (VectorNode. (.-edit root) new-root-array)) + (set! shift new-shift) + (set! cnt (inc cnt)) + tcoll) + (let [new-root (tv-push-tail tcoll shift root tail-node)] + (set! root new-root) + (set! cnt (inc cnt)) + tcoll)))) + (throw (js/Error. "conj! after persistent!")))) + + (-persistent! [tcoll] + (if ^boolean (.-edit root) + (do (set! (.-edit root) nil) + (let [len (- cnt (tail-off tcoll)) + trimmed-tail (make-array len)] + (array-copy tail 0 trimmed-tail 0 len) + (PersistentVector. nil cnt shift root trimmed-tail nil))) + (throw (js/Error. "persistent! called twice")))) + + ITransientAssociative + (-assoc! [tcoll key val] + (if (number? key) + (-assoc-n! tcoll key val) + (throw (js/Error. "TransientVector's key for assoc! must be a number.")))) + + ITransientVector + (-assoc-n! [tcoll n val] + (if ^boolean (.-edit root) + (cond + (and (<= 0 n) (< n cnt)) + (if (<= (tail-off tcoll) n) + (do (aset tail (bit-and n 0x01f) val) + tcoll) + (let [new-root + ((fn go [level node] + (let [node (tv-ensure-editable (.-edit root) node)] + (if (zero? level) + (do (pv-aset node (bit-and n 0x01f) val) + node) + (let [subidx (bit-and (bit-shift-right-zero-fill n level) + 0x01f)] + (pv-aset node subidx + (go (- level 5) (pv-aget node subidx))) + node)))) + shift root)] + (set! root new-root) + tcoll)) + (== n cnt) (-conj! tcoll val) + :else + (throw + (js/Error. + (str "Index " n " out of bounds for TransientVector of length" cnt)))) + (throw (js/Error. "assoc! after persistent!")))) + + (-pop! [tcoll] + (if ^boolean (.-edit root) + (cond + (zero? cnt) (throw (js/Error. "Can't pop empty vector")) + (== 1 cnt) (do (set! cnt 0) tcoll) + (pos? (bit-and (dec cnt) 0x01f)) (do (set! cnt (dec cnt)) tcoll) + :else + (let [new-tail (unchecked-editable-array-for tcoll (- cnt 2)) + new-root (let [nr (tv-pop-tail tcoll shift root)] + (if-not (nil? nr) + nr + (VectorNode. (.-edit root) (make-array 32))))] + (if (and (< 5 shift) (nil? (pv-aget new-root 1))) + (let [new-root (tv-ensure-editable (.-edit root) (pv-aget new-root 0))] + (set! root new-root) + (set! shift (- shift 5)) + (set! cnt (dec cnt)) + (set! tail new-tail) + tcoll) + (do (set! root new-root) + (set! cnt (dec cnt)) + (set! tail new-tail) + tcoll)))) + (throw (js/Error. "pop! after persistent!")))) + + ICounted + (-count [coll] + (if ^boolean (.-edit root) + cnt + (throw (js/Error. "count after persistent!")))) + + IIndexed + (-nth [coll n] + (if ^boolean (.-edit root) + (aget (array-for coll n) (bit-and n 0x01f)) + (throw (js/Error. "nth after persistent!")))) + + (-nth [coll n not-found] + (if (and (<= 0 n) (< n cnt)) + (-nth coll n) + not-found)) + + ILookup + (-lookup [coll k] (-lookup coll k nil)) + + (-lookup [coll k not-found] (if (number? k) + (-nth coll k not-found) + not-found)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found))) + +;;; PersistentQueue ;;; + +(deftype PersistentQueueIter [^:mutable fseq riter] + Object + (hasNext [_] + (or (and (some? fseq) (seq fseq)) (and (some? riter) (.hasNext riter)))) + (next [_] + (cond + (some? fseq) + (let [ret (first fseq)] + (set! fseq (next fseq)) + ret) + (and (some? riter) ^boolean (.hasNext riter)) + (.next riter) + :else (throw (js/Error. "No such element")))) + (remove [_] (js/Error. "Unsupported operation"))) + +(deftype PersistentQueueSeq [meta front rear ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IWithMeta + (-with-meta [coll meta] (PersistentQueueSeq. meta front rear __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] (first front)) + (-rest [coll] + (if-let [f1 (next front)] + (PersistentQueueSeq. meta f1 rear nil) + (if (nil? rear) + (-empty coll) + (PersistentQueueSeq. meta rear nil nil)))) + + INext + (-next [coll] + (if-let [f1 (next front)] + (PersistentQueueSeq. meta f1 rear nil) + (when (some? rear) + (PersistentQueueSeq. meta rear nil nil)))) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] coll)) + +(es6-iterable PersistentQueueSeq) + +(deftype PersistentQueue [meta count front rear ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ICloneable + (-clone [coll] (PersistentQueue. meta count front rear __hash)) + + IIterable + (-iterator [coll] + (PersistentQueueIter. front (-iterator rear))) + + IWithMeta + (-with-meta [coll meta] (PersistentQueue. meta count front rear __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] (first front)) + (-rest [coll] (rest (seq coll))) + + IStack + (-peek [coll] (first front)) + (-pop [coll] + (if front + (if-let [f1 (next front)] + (PersistentQueue. meta (dec count) f1 rear nil) + (PersistentQueue. meta (dec count) (seq rear) [] nil)) + coll)) + + ICollection + (-conj [coll o] + (if front + (PersistentQueue. meta (inc count) front (conj (or rear []) o) nil) + (PersistentQueue. meta (inc count) (conj front o) [] nil))) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY PersistentQueue) meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + ISeqable + (-seq [coll] + (let [rear (seq rear)] + (if (or front rear) + (PersistentQueueSeq. nil front (seq rear) nil)))) + + ICounted + (-count [coll] count)) + +(set! (.-EMPTY PersistentQueue) (PersistentQueue. nil 0 nil [] empty-ordered-hash)) + +(es6-iterable PersistentQueue) + +(deftype NeverEquiv [] + Object + (equiv [this other] + (-equiv this other)) + IEquiv + (-equiv [o other] false)) + +(def ^:private never-equiv (NeverEquiv.)) + +(defn ^boolean equiv-map + "Test map equivalence. Returns true if x equals y, otherwise returns false." + [x y] + (boolean + (when (and (map? y) (not (record? y))) + ; assume all maps are counted + (when (== (count x) (count y)) + (if (satisfies? IKVReduce x) + (reduce-kv + (fn [_ k v] + (if (= (get y k never-equiv) v) + true + (reduced false))) + true x) + (every? + (fn [xkv] + (= (get y (first xkv) never-equiv) (second xkv))) + x)))))) + + +(defn- scan-array [incr k array] + (let [len (alength array)] + (loop [i 0] + (when (< i len) + (if (identical? k (aget array i)) + i + (recur (+ i incr))))))) + +; The keys field is an array of all keys of this map, in no particular +; order. Any string, keyword, or symbol key is used as a property name +; to store the value in strobj. If a key is assoc'ed when that same +; key already exists in strobj, the old value is overwritten. If a +; non-string key is assoc'ed, return a HashMap object instead. + +(defn- obj-map-compare-keys [a b] + (let [a (hash a) + b (hash b)] + (cond + (< a b) -1 + (> a b) 1 + :else 0))) + +(defn- obj-map->hash-map [m k v] + (let [ks (.-keys m) + len (alength ks) + so (.-strobj m) + mm (meta m)] + (loop [i 0 + out (transient (.-EMPTY PersistentHashMap))] + (if (< i len) + (let [k (aget ks i)] + (recur (inc i) (assoc! out k (gobject/get so k)))) + (-with-meta (persistent! (assoc! out k v)) mm))))) + +;;; ObjMap - DEPRECATED + +(defn- obj-clone [obj ks] + (let [new-obj (js-obj) + l (alength ks)] + (loop [i 0] + (when (< i l) + (let [k (aget ks i)] + (gobject/set new-obj k (gobject/get obj k)) + (recur (inc i))))) + new-obj)) + +(deftype ObjMap [meta keys strobj update-count ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + + IWithMeta + (-with-meta [coll meta] (ObjMap. meta keys strobj update-count __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj + coll + entry))) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY ObjMap) meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-unordered-coll __hash)) + + ISeqable + (-seq [coll] + (when (pos? (alength keys)) + (map #(vector % (unchecked-get strobj %)) + (.sort keys obj-map-compare-keys)))) + + ICounted + (-count [coll] (alength keys)) + + ILookup + (-lookup [coll k] (-lookup coll k nil)) + (-lookup [coll k not-found] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (unchecked-get strobj k) + not-found)) + + IAssociative + (-assoc [coll k v] + (if ^boolean (goog/isString k) + (if (or (> update-count (.-HASHMAP_THRESHOLD ObjMap)) + (>= (alength keys) (.-HASHMAP_THRESHOLD ObjMap))) + (obj-map->hash-map coll k v) + (if-not (nil? (scan-array 1 k keys)) + (let [new-strobj (obj-clone strobj keys)] + (gobject/set new-strobj k v) + (ObjMap. meta keys new-strobj (inc update-count) nil)) ; overwrite + (let [new-strobj (obj-clone strobj keys) ; append + new-keys (aclone keys)] + (gobject/set new-strobj k v) + (.push new-keys k) + (ObjMap. meta new-keys new-strobj (inc update-count) nil)))) + ;; non-string key. game over. + (obj-map->hash-map coll k v))) + (-contains-key? [coll k] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + true + false)) + + IFind + (-find [coll k] + (when (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (MapEntry. k (unchecked-get strobj k) nil))) + + IKVReduce + (-kv-reduce [coll f init] + (let [len (alength keys)] + (loop [keys (.sort keys obj-map-compare-keys) + init init] + (if (seq keys) + (let [k (first keys) + init (f init k (unchecked-get strobj k))] + (if (reduced? init) + @init + (recur (rest keys) init))) + init)))) + + IMap + (-dissoc [coll k] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (let [new-keys (aclone keys) + new-strobj (obj-clone strobj keys)] + (.splice new-keys (scan-array 1 k new-keys) 1) + (js-delete new-strobj k) + (ObjMap. meta new-keys new-strobj (inc update-count) nil)) + coll)) ; key not found, return coll unchanged + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (transient (into (hash-map) coll)))) + +(set! (.-EMPTY ObjMap) (ObjMap. nil (array) (js-obj) 0 empty-unordered-hash)) + +(set! (.-HASHMAP_THRESHOLD ObjMap) 8) + +(set! (.-fromObject ObjMap) (fn [ks obj] (ObjMap. nil ks obj 0 nil))) + +;; Record Iterator +(deftype RecordIter [^:mutable i record base-count fields ext-map-iter] + Object + (hasNext [_] + (or (< i base-count) (.hasNext ext-map-iter))) + (next [_] + (if (< i base-count) + (let [k (nth fields i)] + (set! i (inc i)) + (MapEntry. k (-lookup record k) nil)) + (.next ext-map-iter))) + (remove [_] (js/Error. "Unsupported operation"))) + +;; EXPERIMENTAL: subject to change +(deftype ES6EntriesIterator [^:mutable s] + Object + (next [_] + (if-not (nil? s) + (let [[k v] (first s)] + (set! s (next s)) + #js {:value #js [k v] :done false}) + #js {:value nil :done true}))) + +(defn es6-entries-iterator [coll] + (ES6EntriesIterator. (seq coll))) + +;; EXPERIMENTAL: subject to change +(deftype ES6SetEntriesIterator [^:mutable s] + Object + (next [_] + (if-not (nil? s) + (let [x (first s)] + (set! s (next s)) + #js {:value #js [x x] :done false}) + #js {:value nil :done true}))) + +(defn es6-set-entries-iterator [coll] + (ES6SetEntriesIterator. (seq coll))) + +;;; PersistentArrayMap + +(defn- array-index-of-nil? [arr] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (nil? (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-index-of-keyword? [arr k] + (let [len (alength arr) + kstr (.-fqn k)] + (loop [i 0] + (cond + (<= len i) -1 + (and (keyword? (aget arr i)) + (identical? kstr (.-fqn (aget arr i)))) i + :else (recur (+ i 2)))))) + +(defn- array-index-of-symbol? [arr k] + (let [len (alength arr) + kstr (.-str k)] + (loop [i 0] + (cond + (<= len i) -1 + (and (symbol? (aget arr i)) + (identical? kstr (.-str (aget arr i)))) i + :else (recur (+ i 2)))))) + +(defn- array-index-of-identical? [arr k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (identical? k (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-index-of-equiv? [arr k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (= k (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn array-index-of [arr k] + (cond + (keyword? k) (array-index-of-keyword? arr k) + + (or ^boolean (goog/isString k) (number? k)) + (array-index-of-identical? arr k) + + (symbol? k) (array-index-of-symbol? arr k) + + (nil? k) + (array-index-of-nil? arr) + + :else (array-index-of-equiv? arr k))) + +(defn- array-map-index-of [m k] + (array-index-of (.-arr m) k)) + +(defn- array-extend-kv [arr k v] + (let [l (alength arr) + narr (make-array (+ l 2))] + (loop [i 0] + (when (< i l) + (aset narr i (aget arr i)) + (recur (inc i)))) + (aset narr l k) + (aset narr (inc l) v) + narr)) + +(defn- array-map-extend-kv [m k v] + (array-extend-kv (.-arr m) k v)) + +(declare TransientArrayMap) + +(deftype MapEntry [key val ^:mutable __hash] + Object + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] nil) + + ISequential + ISeqable + (-seq [node] (IndexedSeq. #js [key val] 0 nil)) + + IReversible + (-rseq [node] (IndexedSeq. #js [val key] 0 nil)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else (throw (js/Error. "Index out of bounds")))) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + (-contains-key? [node k] + (or (== k 0) (== k 1))) + + IFind + (-find [node k] + (case k + 0 (MapEntry. 0 key nil) + 1 (MapEntry. 1 val nil) + nil)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-nth node k)) + + (-invoke [node k not-found] + (-nth node k not-found))) + +(defn ^boolean map-entry? + "Returns true if x satisfies IMapEntry" + [x] + (implements? IMapEntry x)) + +(deftype PersistentArrayMapSeq [arr i _meta] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] + (PersistentArrayMapSeq. arr i new-meta)) + + ICounted + (-count [coll] + (/ (- (alength arr) i) 2)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) _meta)) + + IHash + (-hash [coll] (hash-ordered-coll coll)) + + ISeq + (-first [coll] + (MapEntry. (aget arr i) (aget arr (inc i)) nil)) + + (-rest [coll] + (if (< i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr (+ i 2) _meta) + ())) + + INext + (-next [coll] + (when (< i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr (+ i 2) _meta))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable PersistentArrayMapSeq) + +(defn persistent-array-map-seq [arr i _meta] + (when (<= i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr i _meta))) + +(declare keys vals) + +(deftype PersistentArrayMapIterator [arr ^:mutable i cnt] + Object + (hasNext [_] + (< i cnt)) + (next [_] + (let [ret (MapEntry. (aget arr i) (aget arr (inc i)) nil)] + (set! i (+ i 2)) + ret))) + +(deftype PersistentArrayMap [meta cnt arr ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + + ;; EXPERIMENTAL: subject to change + (keys [coll] + (es6-iterator (keys coll))) + (entries [coll] + (es6-entries-iterator (seq coll))) + (values [coll] + (es6-iterator (vals coll))) + (has [coll k] + (contains? coll k)) + (get [coll k not-found] + (-lookup coll k not-found)) + (forEach [coll f] + (doseq [[k v] coll] + (f v k))) + + ICloneable + (-clone [_] (PersistentArrayMap. meta cnt arr __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentArrayMap. meta cnt arr __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (loop [ret coll es (seq entry)] + (if (nil? es) + ret + (let [e (first es)] + (if (vector? e) + (recur (-assoc ret (-nth e 0) (-nth e 1)) + (next es)) + (throw (js/Error. "conj on a map takes map entries or seqables of map entries")))))))) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY PersistentArrayMap) meta)) + + IEquiv + (-equiv [coll other] + (if (and (map? other) (not (record? other))) + (let [alen (alength arr) + ^not-native other other] + (if (== cnt (-count other)) + (loop [i 0] + (if (< i alen) + (let [v (-lookup other (aget arr i) lookup-sentinel)] + (if-not (identical? v lookup-sentinel) + (if (= (aget arr (inc i)) v) + (recur (+ i 2)) + false) + false)) + true)) + false)) + false)) + + IHash + (-hash [coll] (caching-hash coll hash-unordered-coll __hash)) + + IIterable + (-iterator [this] + (PersistentArrayMapIterator. arr 0 (* cnt 2))) + + ISeqable + (-seq [coll] + (persistent-array-map-seq arr 0 nil)) + + ICounted + (-count [coll] cnt) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (let [idx (array-map-index-of coll k)] + (if (== idx -1) + not-found + (aget arr (inc idx))))) + + IAssociative + (-assoc [coll k v] + (let [idx (array-map-index-of coll k)] + (cond + (== idx -1) + (if (< cnt (.-HASHMAP-THRESHOLD PersistentArrayMap)) + (let [arr (array-map-extend-kv coll k v)] + (PersistentArrayMap. meta (inc cnt) arr nil)) + (-> (into (.-EMPTY PersistentHashMap) coll) + (-assoc k v) + (-with-meta meta))) + + (identical? v (aget arr (inc idx))) + coll + + :else + (let [arr (doto (aclone arr) + (aset (inc idx) v))] + (PersistentArrayMap. meta cnt arr nil))))) + + (-contains-key? [coll k] + (not (== (array-map-index-of coll k) -1))) + + IFind + (-find [coll k] + (let [idx (array-map-index-of coll k)] + (when-not (== idx -1) + (MapEntry. (aget arr idx) (aget arr (inc idx)) nil)))) + + IMap + (-dissoc [coll k] + (let [idx (array-map-index-of coll k)] + (if (>= idx 0) + (let [len (alength arr) + new-len (- len 2)] + (if (zero? new-len) + (-empty coll) + (let [new-arr (make-array new-len)] + (loop [s 0 d 0] + (cond + (>= s len) (PersistentArrayMap. meta (dec cnt) new-arr nil) + (= k (aget arr s)) (recur (+ s 2) d) + :else (do (aset new-arr d (aget arr s)) + (aset new-arr (inc d) (aget arr (inc s))) + (recur (+ s 2) (+ d 2)))))))) + coll))) + + IKVReduce + (-kv-reduce [coll f init] + (let [len (alength arr)] + (loop [i 0 init init] + (if (< i len) + (let [init (f init (aget arr i) (aget arr (inc i)))] + (if (reduced? init) + @init + (recur (+ i 2) init))) + init)))) + + IReduce + (-reduce [coll f] + (iter-reduce coll f)) + (-reduce [coll f start] + (iter-reduce coll f start)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientArrayMap. (js-obj) (alength arr) (aclone arr)))) + +(set! (.-EMPTY PersistentArrayMap) (PersistentArrayMap. nil 0 (array) empty-unordered-hash)) + +(set! (.-HASHMAP-THRESHOLD PersistentArrayMap) 8) + +(set! (.-fromArray PersistentArrayMap) + (fn [arr ^boolean no-clone ^boolean no-check] + (as-> (if no-clone arr (aclone arr)) arr + (if no-check + arr + (let [ret (array)] + (loop [i 0] + (when (< i (alength arr)) + (let [k (aget arr i) + v (aget arr (inc i)) + idx (array-index-of ret k)] + (when (== idx -1) + (.push ret k) + (.push ret v))) + (recur (+ i 2)))) + ret)) + (let [cnt (/ (alength arr) 2)] + (PersistentArrayMap. nil cnt arr nil))))) + +(set! (.-createWithCheck PersistentArrayMap) + (fn [arr] + (let [ret (array)] + (loop [i 0] + (when (< i (alength arr)) + (let [k (aget arr i) + v (aget arr (inc i)) + idx (array-index-of ret k)] + (if (== idx -1) + (doto ret (.push k) (.push v)) + (throw (js/Error. (str "Duplicate key: " k))))) + (recur (+ i 2)))) + (let [cnt (/ (alength arr) 2)] + (PersistentArrayMap. nil cnt arr nil))))) + +(set! (.-createAsIfByAssoc PersistentArrayMap) + (fn [arr] + (let [ret (array)] + (loop [i 0] + (when (< i (alength arr)) + (let [k (aget arr i) + v (aget arr (inc i)) + idx (array-index-of ret k)] + (if (== idx -1) + (doto ret (.push k) (.push v)) + (aset ret (inc idx) v))) + (recur (+ i 2)))) + (PersistentArrayMap. nil (/ (alength ret) 2) ret nil)))) + +(es6-iterable PersistentArrayMap) + +(declare array->transient-hash-map) + +(deftype TransientArrayMap [^:mutable editable? + ^:mutable len + arr] + ICounted + (-count [tcoll] + (if editable? + (quot len 2) + (throw (js/Error. "count after persistent!")))) + + ILookup + (-lookup [tcoll k] + (-lookup tcoll k nil)) + + (-lookup [tcoll k not-found] + (if editable? + (let [idx (array-map-index-of tcoll k)] + (if (== idx -1) + not-found + (aget arr (inc idx)))) + (throw (js/Error. "lookup after persistent!")))) + + ITransientCollection + (-conj! [tcoll o] + (if editable? + (cond + (map-entry? o) + (-assoc! tcoll (key o) (val o)) + + (vector? o) + (-assoc! tcoll (o 0) (o 1)) + + :else + (loop [es (seq o) tcoll tcoll] + (if-let [e (first es)] + (recur (next es) + (-assoc! tcoll (key e) (val e))) + tcoll))) + (throw (js/Error. "conj! after persistent!")))) + + (-persistent! [tcoll] + (if editable? + (do (set! editable? false) + (PersistentArrayMap. nil (quot len 2) arr nil)) + (throw (js/Error. "persistent! called twice")))) + + ITransientAssociative + (-assoc! [tcoll key val] + (if editable? + (let [idx (array-map-index-of tcoll key)] + (if (== idx -1) + (if (<= (+ len 2) (* 2 (.-HASHMAP-THRESHOLD PersistentArrayMap))) + (do (set! len (+ len 2)) + (.push arr key) + (.push arr val) + tcoll) + (assoc! (array->transient-hash-map len arr) key val)) + (if (identical? val (aget arr (inc idx))) + tcoll + (do (aset arr (inc idx) val) + tcoll)))) + (throw (js/Error. "assoc! after persistent!")))) + + ITransientMap + (-dissoc! [tcoll key] + (if editable? + (let [idx (array-map-index-of tcoll key)] + (when (>= idx 0) + (aset arr idx (aget arr (- len 2))) + (aset arr (inc idx) (aget arr (dec len))) + (doto arr .pop .pop) + (set! len (- len 2))) + tcoll) + (throw (js/Error. "dissoc! after persistent!")))) + + IFn + (-invoke [tcoll key] + (-lookup tcoll key nil)) + (-invoke [tcoll key not-found] + (-lookup tcoll key not-found))) + +(declare TransientHashMap) + +(defn- array->transient-hash-map [len arr] + (loop [out (transient (.-EMPTY PersistentHashMap)) + i 0] + (if (< i len) + (recur (assoc! out (aget arr i) (aget arr (inc i))) (+ i 2)) + out))) + +;;; PersistentHashMap + +(deftype Box [^:mutable val]) + +(declare create-inode-seq create-array-node-seq reset! create-node atom deref) + +(defn ^boolean key-test [key other] + (cond + (identical? key other) true + (keyword-identical? key other) true + :else (= key other))) + +(defn- mask [hash shift] + (bit-and (bit-shift-right-zero-fill hash shift) 0x01f)) + +(defn- clone-and-set + ([arr i a] + (doto (aclone arr) + (aset i a))) + ([arr i a j b] + (doto (aclone arr) + (aset i a) + (aset j b)))) + +(defn- remove-pair [arr i] + (let [new-arr (make-array (- (alength arr) 2))] + (array-copy arr 0 new-arr 0 (* 2 i)) + (array-copy arr (* 2 (inc i)) new-arr (* 2 i) (- (alength new-arr) (* 2 i))) + new-arr)) + +(defn- bitmap-indexed-node-index [bitmap bit] + (bit-count (bit-and bitmap (dec bit)))) + +(defn- bitpos [hash shift] + (bit-shift-left 1 (mask hash shift))) + +(defn- edit-and-set + ([inode edit i a] + (let [editable (.ensure-editable inode edit)] + (aset (.-arr editable) i a) + editable)) + ([inode edit i a j b] + (let [editable (.ensure-editable inode edit)] + (aset (.-arr editable) i a) + (aset (.-arr editable) j b) + editable))) + +(defn- inode-kv-reduce [arr f init] + (let [len (alength arr)] + (loop [i 0 init init] + (if (< i len) + (let [init (let [k (aget arr i)] + (if-not (nil? k) + (f init k (aget arr (inc i))) + (let [node (aget arr (inc i))] + (if-not (nil? node) + (.kv-reduce node f init) + init))))] + (if (reduced? init) + init + (recur (+ i 2) init))) + init)))) + +(declare ArrayNode) + + (deftype NodeIterator [arr ^:mutable i ^:mutable next-entry ^:mutable next-iter] + Object + (advance [this] + (let [len (alength arr)] + (loop [] + (if (< i len) + (let [key (aget arr i) + node-or-val (aget arr (inc i)) + ^boolean found + (cond (some? key) + (set! next-entry (MapEntry. key node-or-val nil)) + (some? node-or-val) + (let [new-iter (-iterator node-or-val)] + (if ^boolean (.hasNext new-iter) + (set! next-iter new-iter) + false)) + :else false)] + (set! i (+ i 2)) + (if found true (recur))) + false)))) + (hasNext [this] + (or (some? next-entry) (some? next-iter) (.advance this))) + (next [this] + (cond + (some? next-entry) + (let [ret next-entry] + (set! next-entry nil) + ret) + (some? next-iter) + (let [ret (.next next-iter)] + (when-not ^boolean (.hasNext next-iter) + (set! next-iter nil)) + ret) + ^boolean (.advance this) + (.next this) + :else (throw (js/Error. "No such element")))) + (remove [_] (js/Error. "Unsupported operation"))) + +(deftype BitmapIndexedNode [edit ^:mutable bitmap ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (let [bit (bitpos hash shift) + idx (bitmap-indexed-node-index bitmap bit)] + (if (zero? (bit-and bitmap bit)) + (let [n (bit-count bitmap)] + (if (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash shift)] + (aset nodes jdx (.inode-assoc (.-EMPTY BitmapIndexedNode) (+ shift 5) hash key val added-leaf?)) + (loop [i 0 j 0] + (if (< i 32) + (if (zero? (bit-and (bit-shift-right-zero-fill bitmap i) 1)) + (recur (inc i) j) + (do (aset nodes i + (if-not (nil? (aget arr j)) + (.inode-assoc (.-EMPTY BitmapIndexedNode) + (+ shift 5) (cljs.core/hash (aget arr j)) (aget arr j) (aget arr (inc j)) added-leaf?) + (aget arr (inc j)))) + (recur (inc i) (+ j 2)))))) + (ArrayNode. nil (inc n) nodes)) + (let [new-arr (make-array (* 2 (inc n)))] + (array-copy arr 0 new-arr 0 (* 2 idx)) + (aset new-arr (* 2 idx) key) + (aset new-arr (inc (* 2 idx)) val) + (array-copy arr (* 2 idx) new-arr (* 2 (inc idx)) (* 2 (- n idx))) + (set! (.-val added-leaf?) true) + (BitmapIndexedNode. nil (bit-or bitmap bit) new-arr)))) + (let [key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-assoc val-or-node (+ shift 5) hash key val added-leaf?)] + (if (identical? n val-or-node) + inode + (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) n)))) + + (key-test key key-or-nil) + (if (identical? val val-or-node) + inode + (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) val))) + + :else + (do (set! (.-val added-leaf?) true) + (BitmapIndexedNode. nil bitmap + (clone-and-set arr (* 2 idx) nil (inc (* 2 idx)) + (create-node (+ shift 5) key-or-nil val-or-node hash key val))))))))) + + (inode-without [inode shift hash key] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + inode + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-without val-or-node (+ shift 5) hash key)] + (cond (identical? n val-or-node) inode + (not (nil? n)) (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) n)) + (== bitmap bit) nil + :else (BitmapIndexedNode. nil (bit-xor bitmap bit) (remove-pair arr idx)))) + (key-test key key-or-nil) + (BitmapIndexedNode. nil (bit-xor bitmap bit) (remove-pair arr idx)) + :else inode))))) + + (inode-lookup [inode shift hash key not-found] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + not-found + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) (.inode-lookup val-or-node (+ shift 5) hash key not-found) + (key-test key key-or-nil) val-or-node + :else not-found))))) + + (inode-find [inode shift hash key not-found] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + not-found + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) (.inode-find val-or-node (+ shift 5) hash key not-found) + (key-test key key-or-nil) (MapEntry. key-or-nil val-or-node nil) + :else not-found))))) + + (inode-seq [inode] + (create-inode-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (let [n (bit-count bitmap) + new-arr (make-array (if (neg? n) 4 (* 2 (inc n))))] + (array-copy arr 0 new-arr 0 (* 2 n)) + (BitmapIndexedNode. e bitmap new-arr)))) + + (edit-and-remove-pair [inode e bit i] + (if (== bitmap bit) + nil + (let [editable (.ensure-editable inode e) + earr (.-arr editable) + len (alength earr)] + (set! (.-bitmap editable) (bit-xor bit (.-bitmap editable))) + (array-copy earr (* 2 (inc i)) + earr (* 2 i) + (- len (* 2 (inc i)))) + (aset earr (- len 2) nil) + (aset earr (dec len) nil) + editable))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (let [bit (bitpos hash shift) + idx (bitmap-indexed-node-index bitmap bit)] + (if (zero? (bit-and bitmap bit)) + (let [n (bit-count bitmap)] + (cond + (< (* 2 n) (alength arr)) + (let [editable (.ensure-editable inode edit) + earr (.-arr editable)] + (set! (.-val added-leaf?) true) + (array-copy-downward earr (* 2 idx) + earr (* 2 (inc idx)) + (* 2 (- n idx))) + (aset earr (* 2 idx) key) + (aset earr (inc (* 2 idx)) val) + (set! (.-bitmap editable) (bit-or (.-bitmap editable) bit)) + editable) + + (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash shift)] + (aset nodes jdx (.inode-assoc! (.-EMPTY BitmapIndexedNode) edit (+ shift 5) hash key val added-leaf?)) + (loop [i 0 j 0] + (if (< i 32) + (if (zero? (bit-and (bit-shift-right-zero-fill bitmap i) 1)) + (recur (inc i) j) + (do (aset nodes i + (if-not (nil? (aget arr j)) + (.inode-assoc! (.-EMPTY BitmapIndexedNode) + edit (+ shift 5) (cljs.core/hash (aget arr j)) (aget arr j) (aget arr (inc j)) added-leaf?) + (aget arr (inc j)))) + (recur (inc i) (+ j 2)))))) + (ArrayNode. edit (inc n) nodes)) + + :else + (let [new-arr (make-array (* 2 (+ n 4)))] + (array-copy arr 0 new-arr 0 (* 2 idx)) + (aset new-arr (* 2 idx) key) + (aset new-arr (inc (* 2 idx)) val) + (array-copy arr (* 2 idx) new-arr (* 2 (inc idx)) (* 2 (- n idx))) + (set! (.-val added-leaf?) true) + (let [editable (.ensure-editable inode edit)] + (set! (.-arr editable) new-arr) + (set! (.-bitmap editable) (bit-or (.-bitmap editable) bit)) + editable)))) + (let [key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-assoc! val-or-node edit (+ shift 5) hash key val added-leaf?)] + (if (identical? n val-or-node) + inode + (edit-and-set inode edit (inc (* 2 idx)) n))) + + (key-test key key-or-nil) + (if (identical? val val-or-node) + inode + (edit-and-set inode edit (inc (* 2 idx)) val)) + + :else + (do (set! (.-val added-leaf?) true) + (edit-and-set inode edit (* 2 idx) nil (inc (* 2 idx)) + (create-node edit (+ shift 5) key-or-nil val-or-node hash key val)))))))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + inode + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-without! val-or-node edit (+ shift 5) hash key removed-leaf?)] + (cond (identical? n val-or-node) inode + (not (nil? n)) (edit-and-set inode edit (inc (* 2 idx)) n) + (== bitmap bit) nil + :else (.edit-and-remove-pair inode edit bit idx))) + (key-test key key-or-nil) + (do (set! (.-val removed-leaf?) true) + (.edit-and-remove-pair inode edit bit idx)) + :else inode))))) + + (kv-reduce [inode f init] + (inode-kv-reduce arr f init)) + + IIterable + (-iterator [coll] + (NodeIterator. arr 0 nil nil))) + +(set! (.-EMPTY BitmapIndexedNode) (BitmapIndexedNode. nil 0 (make-array 0))) + +(defn- pack-array-node [array-node edit idx] + (let [arr (.-arr array-node) + len (alength arr) + new-arr (make-array (* 2 (dec (.-cnt array-node))))] + (loop [i 0 j 1 bitmap 0] + (if (< i len) + (if (and (not (== i idx)) + (not (nil? (aget arr i)))) + (do (aset new-arr j (aget arr i)) + (recur (inc i) (+ j 2) (bit-or bitmap (bit-shift-left 1 i)))) + (recur (inc i) j bitmap)) + (BitmapIndexedNode. edit bitmap new-arr))))) + +(deftype ArrayNodeIterator [arr ^:mutable i ^:mutable next-iter] + Object + (hasNext [this] + (let [len (alength arr)] + (loop [] + (if-not (and (some? next-iter) ^boolean (.hasNext next-iter)) + (if (< i len) + (let [node (aget arr i)] + (set! i (inc i)) + (when (some? node) + (set! next-iter (-iterator node))) + (recur)) + false) + true)))) + (next [this] + (if ^boolean (.hasNext this) + (.next next-iter) + (throw (js/Error. "No such element")))) + (remove [_] (js/Error. "Unsupported operation"))) + +(deftype ArrayNode [edit ^:mutable cnt ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + (ArrayNode. nil (inc cnt) (clone-and-set arr idx (.inode-assoc (.-EMPTY BitmapIndexedNode) (+ shift 5) hash key val added-leaf?))) + (let [n (.inode-assoc node (+ shift 5) hash key val added-leaf?)] + (if (identical? n node) + inode + (ArrayNode. nil cnt (clone-and-set arr idx n))))))) + + (inode-without [inode shift hash key] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (let [n (.inode-without node (+ shift 5) hash key)] + (cond + (identical? n node) + inode + + (nil? n) + (if (<= cnt 8) + (pack-array-node inode nil idx) + (ArrayNode. nil (dec cnt) (clone-and-set arr idx n))) + + :else + (ArrayNode. nil cnt (clone-and-set arr idx n)))) + inode))) + + (inode-lookup [inode shift hash key not-found] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (.inode-lookup node (+ shift 5) hash key not-found) + not-found))) + + (inode-find [inode shift hash key not-found] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (.inode-find node (+ shift 5) hash key not-found) + not-found))) + + (inode-seq [inode] + (create-array-node-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (ArrayNode. e cnt (aclone arr)))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + (let [editable (edit-and-set inode edit idx (.inode-assoc! (.-EMPTY BitmapIndexedNode) edit (+ shift 5) hash key val added-leaf?))] + (set! (.-cnt editable) (inc (.-cnt editable))) + editable) + (let [n (.inode-assoc! node edit (+ shift 5) hash key val added-leaf?)] + (if (identical? n node) + inode + (edit-and-set inode edit idx n)))))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + inode + (let [n (.inode-without! node edit (+ shift 5) hash key removed-leaf?)] + (cond + (identical? n node) + inode + + (nil? n) + (if (<= cnt 8) + (pack-array-node inode edit idx) + (let [editable (edit-and-set inode edit idx n)] + (set! (.-cnt editable) (dec (.-cnt editable))) + editable)) + + :else + (edit-and-set inode edit idx n)))))) + + (kv-reduce [inode f init] + (let [len (alength arr)] ; actually 32 + (loop [i 0 init init] + (if (< i len) + (let [node (aget arr i)] + (if-not (nil? node) + (let [init (.kv-reduce node f init)] + (if (reduced? init) + init + (recur (inc i) init))) + (recur (inc i) init))) + init)))) + + IIterable + (-iterator [coll] + (ArrayNodeIterator. arr 0 nil))) + +(defn- hash-collision-node-find-index [arr cnt key] + (let [lim (* 2 cnt)] + (loop [i 0] + (if (< i lim) + (if (key-test key (aget arr i)) + i + (recur (+ i 2))) + -1)))) + +(deftype HashCollisionNode [edit + ^:mutable collision-hash + ^:mutable cnt + ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (if (== hash collision-hash) + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + (let [len (* 2 cnt) + new-arr (make-array (+ len 2))] + (array-copy arr 0 new-arr 0 len) + (aset new-arr len key) + (aset new-arr (inc len) val) + (set! (.-val added-leaf?) true) + (HashCollisionNode. nil collision-hash (inc cnt) new-arr)) + (if (= (aget arr (inc idx)) val) + inode + (HashCollisionNode. nil collision-hash cnt (clone-and-set arr (inc idx) val))))) + (.inode-assoc (BitmapIndexedNode. nil (bitpos collision-hash shift) (array nil inode)) + shift hash key val added-leaf?))) + + (inode-without [inode shift hash key] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (== idx -1) inode + (== cnt 1) nil + :else (HashCollisionNode. nil collision-hash (dec cnt) (remove-pair arr (quot idx 2)))))) + + (inode-lookup [inode shift hash key not-found] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (< idx 0) not-found + (key-test key (aget arr idx)) (aget arr (inc idx)) + :else not-found))) + + (inode-find [inode shift hash key not-found] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (< idx 0) not-found + (key-test key (aget arr idx)) (MapEntry. (aget arr idx) (aget arr (inc idx)) nil) + :else not-found))) + + (inode-seq [inode] + (create-inode-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (let [new-arr (make-array (* 2 (inc cnt)))] + (array-copy arr 0 new-arr 0 (* 2 cnt)) + (HashCollisionNode. e collision-hash cnt new-arr)))) + + (ensure-editable-array [inode e count array] + (if (identical? e edit) + (do (set! arr array) + (set! cnt count) + inode) + (HashCollisionNode. edit collision-hash count array))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (if (== hash collision-hash) + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + (if (> (alength arr) (* 2 cnt)) + (let [editable (edit-and-set inode edit (* 2 cnt) key (inc (* 2 cnt)) val)] + (set! (.-val added-leaf?) true) + (set! (.-cnt editable) (inc (.-cnt editable))) + editable) + (let [len (alength arr) + new-arr (make-array (+ len 2))] + (array-copy arr 0 new-arr 0 len) + (aset new-arr len key) + (aset new-arr (inc len) val) + (set! (.-val added-leaf?) true) + (.ensure-editable-array inode edit (inc cnt) new-arr))) + (if (identical? (aget arr (inc idx)) val) + inode + (edit-and-set inode edit (inc idx) val)))) + (.inode-assoc! (BitmapIndexedNode. edit (bitpos collision-hash shift) (array nil inode nil nil)) + edit shift hash key val added-leaf?))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + inode + (do (set! (.-val removed-leaf?) true) + (if (== cnt 1) + nil + (let [editable (.ensure-editable inode edit) + earr (.-arr editable)] + (aset earr idx (aget earr (- (* 2 cnt) 2))) + (aset earr (inc idx) (aget earr (dec (* 2 cnt)))) + (aset earr (dec (* 2 cnt)) nil) + (aset earr (- (* 2 cnt) 2) nil) + (set! (.-cnt editable) (dec (.-cnt editable))) + editable)))))) + + (kv-reduce [inode f init] + (inode-kv-reduce arr f init)) + + IIterable + (-iterator [coll] + (NodeIterator. arr 0 nil nil))) + +(defn- create-node + ([shift key1 val1 key2hash key2 val2] + (let [key1hash (hash key1)] + (if (== key1hash key2hash) + (HashCollisionNode. nil key1hash 2 (array key1 val1 key2 val2)) + (let [added-leaf? (Box. false)] + (-> (.-EMPTY BitmapIndexedNode) + (.inode-assoc shift key1hash key1 val1 added-leaf?) + (.inode-assoc shift key2hash key2 val2 added-leaf?)))))) + ([edit shift key1 val1 key2hash key2 val2] + (let [key1hash (hash key1)] + (if (== key1hash key2hash) + (HashCollisionNode. nil key1hash 2 (array key1 val1 key2 val2)) + (let [added-leaf? (Box. false)] + (-> (.-EMPTY BitmapIndexedNode) + (.inode-assoc! edit shift key1hash key1 val1 added-leaf?) + (.inode-assoc! edit shift key2hash key2 val2 added-leaf?))))))) + +(deftype NodeSeq [meta nodes i s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] (NodeSeq. meta nodes i s __hash)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + ISeq + (-first [coll] + (if (nil? s) + (MapEntry. (aget nodes i) (aget nodes (inc i)) nil) + (first s))) + + (-rest [coll] + (let [ret (if (nil? s) + (create-inode-seq nodes (+ i 2) nil) + (create-inode-seq nodes i (next s)))] + (if-not (nil? ret) ret ()))) + + INext + (-next [coll] + (if (nil? s) + (create-inode-seq nodes (+ i 2) nil) + (create-inode-seq nodes i (next s)))) + + ISeqable + (-seq [this] this) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable NodeSeq) + +(defn- create-inode-seq + ([nodes] + (create-inode-seq nodes 0 nil)) + ([nodes i s] + (if (nil? s) + (let [len (alength nodes)] + (loop [j i] + (if (< j len) + (if-not (nil? (aget nodes j)) + (NodeSeq. nil nodes j nil nil) + (if-let [node (aget nodes (inc j))] + (if-let [node-seq (.inode-seq node)] + (NodeSeq. nil nodes (+ j 2) node-seq nil) + (recur (+ j 2))) + (recur (+ j 2))))))) + (NodeSeq. nil nodes i s nil)))) + +(deftype ArrayNodeSeq [meta nodes i s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] (ArrayNodeSeq. meta nodes i s __hash)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + ISequential + ISeq + (-first [coll] (first s)) + (-rest [coll] + (let [ret (create-array-node-seq nil nodes i (next s))] + (if-not (nil? ret) ret ()))) + + INext + (-next [coll] + (create-array-node-seq nil nodes i (next s))) + + ISeqable + (-seq [this] this) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable ArrayNodeSeq) + +(defn- create-array-node-seq + ([nodes] (create-array-node-seq nil nodes 0 nil)) + ([meta nodes i s] + (if (nil? s) + (let [len (alength nodes)] + (loop [j i] + (if (< j len) + (if-let [nj (aget nodes j)] + (if-let [ns (.inode-seq nj)] + (ArrayNodeSeq. meta nodes (inc j) ns nil) + (recur (inc j))) + (recur (inc j)))))) + (ArrayNodeSeq. meta nodes i s nil)))) + +(deftype HashMapIter [nil-val root-iter ^:mutable seen] + Object + (hasNext [_] + (or (not ^boolean seen) ^boolean (.hasNext root-iter))) + (next [_] + (if-not ^boolean seen + (do + (set! seen true) + (MapEntry. nil nil-val nil)) + (.next root-iter))) + (remove [_] (js/Error. "Unsupported operation"))) + +(deftype PersistentHashMap [meta cnt root ^boolean has-nil? nil-val ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + + ;; EXPERIMENTAL: subject to change + (keys [coll] + (es6-iterator (keys coll))) + (entries [coll] + (es6-entries-iterator (seq coll))) + (values [coll] + (es6-iterator (vals coll))) + (has [coll k] + (contains? coll k)) + (get [coll k not-found] + (-lookup coll k not-found)) + (forEach [coll f] + (doseq [[k v] coll] + (f v k))) + + ICloneable + (-clone [_] (PersistentHashMap. meta cnt root has-nil? nil-val __hash)) + + IIterable + (-iterator [coll] + (let [root-iter (if ^boolean root (-iterator root) (nil-iter))] + (if has-nil? + (HashMapIter. nil-val root-iter false) + root-iter))) + + IWithMeta + (-with-meta [coll meta] (PersistentHashMap. meta cnt root has-nil? nil-val __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (loop [ret coll es (seq entry)] + (if (nil? es) + ret + (let [e (first es)] + (if (vector? e) + (recur (-assoc ret (-nth e 0) (-nth e 1)) + (next es)) + (throw (js/Error. "conj on a map takes map entries or seqables of map entries")))))))) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY PersistentHashMap) meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-unordered-coll __hash)) + + ISeqable + (-seq [coll] + (when (pos? cnt) + (let [s (if-not (nil? root) (.inode-seq root))] + (if has-nil? + (cons (MapEntry. nil nil-val nil) s) + s)))) + + ICounted + (-count [coll] cnt) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (cond (nil? k) (if has-nil? + nil-val + not-found) + (nil? root) not-found + :else (.inode-lookup root 0 (hash k) k not-found))) + + IAssociative + (-assoc [coll k v] + (if (nil? k) + (if (and has-nil? (identical? v nil-val)) + coll + (PersistentHashMap. meta (if has-nil? cnt (inc cnt)) root true v nil)) + (let [added-leaf? (Box. false) + new-root (-> (if (nil? root) + (.-EMPTY BitmapIndexedNode) + root) + (.inode-assoc 0 (hash k) k v added-leaf?))] + (if (identical? new-root root) + coll + (PersistentHashMap. meta (if ^boolean (.-val added-leaf?) (inc cnt) cnt) new-root has-nil? nil-val nil))))) + + (-contains-key? [coll k] + (cond (nil? k) has-nil? + (nil? root) false + :else (not (identical? (.inode-lookup root 0 (hash k) k lookup-sentinel) + lookup-sentinel)))) + + IFind + (-find [coll k] + (cond + (nil? k) (when has-nil? (MapEntry. nil nil-val nil)) + (nil? root) nil + :else (.inode-find root 0 (hash k) k nil))) + + IMap + (-dissoc [coll k] + (cond (nil? k) (if has-nil? + (PersistentHashMap. meta (dec cnt) root false nil nil) + coll) + (nil? root) coll + :else + (let [new-root (.inode-without root 0 (hash k) k)] + (if (identical? new-root root) + coll + (PersistentHashMap. meta (dec cnt) new-root has-nil? nil-val nil))))) + + IKVReduce + (-kv-reduce [coll f init] + (let [init (if has-nil? (f init nil nil-val) init)] + (cond + (reduced? init) @init + (not (nil? root)) (unreduced (.kv-reduce root f init)) + :else init))) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientHashMap. (js-obj) root cnt has-nil? nil-val))) + +(set! (.-EMPTY PersistentHashMap) (PersistentHashMap. nil 0 nil false nil empty-unordered-hash)) + +(set! (.-fromArray PersistentHashMap) + (fn [arr ^boolean no-clone] + (let [arr (if no-clone arr (aclone arr)) + len (alength arr)] + (loop [i 0 ret (transient (.-EMPTY PersistentHashMap))] + (if (< i len) + (recur (+ i 2) + (-assoc! ret (aget arr i) (aget arr (inc i)))) + (-persistent! ret)))))) + +(set! (.-fromArrays PersistentHashMap) + (fn [ks vs] + (let [len (alength ks)] + (loop [i 0 ^not-native out (transient (.-EMPTY PersistentHashMap))] + (if (< i len) + (recur (inc i) (-assoc! out (aget ks i) (aget vs i))) + (persistent! out)))))) + +(set! (.-createWithCheck PersistentHashMap) + (fn [arr] + (let [len (alength arr) + ret (transient (.-EMPTY PersistentHashMap))] + (loop [i 0] + (when (< i len) + (-assoc! ret (aget arr i) (aget arr (inc i))) + (if (not= (-count ret) (inc (/ i 2))) + (throw (js/Error. (str "Duplicate key: " (aget arr i)))) + (recur (+ i 2))))) + (-persistent! ret)))) + +(es6-iterable PersistentHashMap) + +(deftype TransientHashMap [^:mutable ^boolean edit + ^:mutable root + ^:mutable count + ^:mutable ^boolean has-nil? + ^:mutable nil-val] + Object + (conj! [tcoll o] + (if edit + (cond + (map-entry? o) + (.assoc! tcoll (key o) (val o)) + + (vector? o) + (.assoc! tcoll (o 0) (o 1)) + + :else + (loop [es (seq o) tcoll tcoll] + (if-let [e (first es)] + (recur (next es) + (.assoc! tcoll (key e) (val e))) + tcoll))) + (throw (js/Error. "conj! after persistent")))) + + (assoc! [tcoll k v] + (if edit + (if (nil? k) + (do (if (identical? nil-val v) + nil + (set! nil-val v)) + (if has-nil? + nil + (do (set! count (inc count)) + (set! has-nil? true))) + tcoll) + (let [added-leaf? (Box. false) + node (-> (if (nil? root) + (.-EMPTY BitmapIndexedNode) + root) + (.inode-assoc! edit 0 (hash k) k v added-leaf?))] + (if (identical? node root) + nil + (set! root node)) + (if ^boolean (.-val added-leaf?) + (set! count (inc count))) + tcoll)) + (throw (js/Error. "assoc! after persistent!")))) + + (without! [tcoll k] + (if edit + (if (nil? k) + (if has-nil? + (do (set! has-nil? false) + (set! nil-val nil) + (set! count (dec count)) + tcoll) + tcoll) + (if (nil? root) + tcoll + (let [removed-leaf? (Box. false) + node (.inode-without! root edit 0 (hash k) k removed-leaf?)] + (if (identical? node root) + nil + (set! root node)) + (if ^boolean (.-val removed-leaf?) + (set! count (dec count))) + tcoll))) + (throw (js/Error. "dissoc! after persistent!")))) + + (persistent! [tcoll] + (if edit + (do (set! edit nil) + (PersistentHashMap. nil count root has-nil? nil-val nil)) + (throw (js/Error. "persistent! called twice")))) + + ICounted + (-count [coll] + (if edit + count + (throw (js/Error. "count after persistent!")))) + + ILookup + (-lookup [tcoll k] + (if (nil? k) + (if has-nil? + nil-val) + (if (nil? root) + nil + (.inode-lookup root 0 (hash k) k)))) + + (-lookup [tcoll k not-found] + (if (nil? k) + (if has-nil? + nil-val + not-found) + (if (nil? root) + not-found + (.inode-lookup root 0 (hash k) k not-found)))) + + ITransientCollection + (-conj! [tcoll val] (.conj! tcoll val)) + + (-persistent! [tcoll] (.persistent! tcoll)) + + ITransientAssociative + (-assoc! [tcoll key val] (.assoc! tcoll key val)) + + ITransientMap + (-dissoc! [tcoll key] (.without! tcoll key)) + + IFn + (-invoke [tcoll key] + (-lookup tcoll key)) + (-invoke [tcoll key not-found] + (-lookup tcoll key not-found))) + +;;; PersistentTreeMap + +(defn- tree-map-seq-push [node stack ^boolean ascending?] + (loop [t node stack stack] + (if-not (nil? t) + (recur (if ascending? (.-left t) (.-right t)) + (conj stack t)) + stack))) + +(deftype PersistentTreeMapSeq [meta stack ^boolean ascending? cnt ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ISeqable + (-seq [this] this) + + ISequential + ISeq + (-first [this] (peek stack)) + (-rest [this] + (let [t (first stack) + next-stack (tree-map-seq-push (if ascending? (.-right t) (.-left t)) + (next stack) + ascending?)] + (if-not (nil? next-stack) + (PersistentTreeMapSeq. nil next-stack ascending? (dec cnt) nil) + ()))) + INext + (-next [this] + (let [t (first stack) + next-stack (tree-map-seq-push (if ascending? (.-right t) (.-left t)) + (next stack) + ascending?)] + (when-not (nil? next-stack) + (PersistentTreeMapSeq. nil next-stack ascending? (dec cnt) nil)))) + + ICounted + (-count [coll] + (if (neg? cnt) + (inc (count (next coll))) + cnt)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) meta)) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] + (PersistentTreeMapSeq. meta stack ascending? cnt __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable PersistentTreeMapSeq) + +(defn- create-tree-map-seq [tree ascending? cnt] + (PersistentTreeMapSeq. nil (tree-map-seq-push tree nil ascending?) ascending? cnt nil)) + +(declare RedNode BlackNode) + +(defn- balance-left [key val ins right] + (if (instance? RedNode ins) + (cond + (instance? RedNode (.-left ins)) + (RedNode. (.-key ins) (.-val ins) + (.blacken (.-left ins)) + (BlackNode. key val (.-right ins) right nil) + nil) + + (instance? RedNode (.-right ins)) + (RedNode. (.. ins -right -key) (.. ins -right -val) + (BlackNode. (.-key ins) (.-val ins) + (.-left ins) + (.. ins -right -left) + nil) + (BlackNode. key val + (.. ins -right -right) + right + nil) + nil) + + :else + (BlackNode. key val ins right nil)) + (BlackNode. key val ins right nil))) + +(defn- balance-right [key val left ins] + (if (instance? RedNode ins) + (cond + (instance? RedNode (.-right ins)) + (RedNode. (.-key ins) (.-val ins) + (BlackNode. key val left (.-left ins) nil) + (.blacken (.-right ins)) + nil) + + (instance? RedNode (.-left ins)) + (RedNode. (.. ins -left -key) (.. ins -left -val) + (BlackNode. key val left (.. ins -left -left) nil) + (BlackNode. (.-key ins) (.-val ins) + (.. ins -left -right) + (.-right ins) + nil) + nil) + + :else + (BlackNode. key val left ins nil)) + (BlackNode. key val left ins nil))) + +(defn- balance-left-del [key val del right] + (cond + (instance? RedNode del) + (RedNode. key val (.blacken del) right nil) + + (instance? BlackNode right) + (balance-right key val del (.redden right)) + + (and (instance? RedNode right) (instance? BlackNode (.-left right))) + (RedNode. (.. right -left -key) (.. right -left -val) + (BlackNode. key val del (.. right -left -left) nil) + (balance-right (.-key right) (.-val right) + (.. right -left -right) + (.redden (.-right right))) + nil) + + :else + (throw (js/Error. "red-black tree invariant violation")))) + +(defn- balance-right-del [key val left del] + (cond + (instance? RedNode del) + (RedNode. key val left (.blacken del) nil) + + (instance? BlackNode left) + (balance-left key val (.redden left) del) + + (and (instance? RedNode left) (instance? BlackNode (.-right left))) + (RedNode. (.. left -right -key) (.. left -right -val) + (balance-left (.-key left) (.-val left) + (.redden (.-left left)) + (.. left -right -left)) + (BlackNode. key val (.. left -right -right) del nil) + nil) + + :else + (throw (js/Error. "red-black tree invariant violation")))) + +(defn- tree-map-kv-reduce [node f init] + (let [init (if-not (nil? (.-left node)) + (tree-map-kv-reduce (.-left node) f init) + init)] + (if (reduced? init) + init + (let [init (f init (.-key node) (.-val node))] + (if (reduced? init) + init + (if-not (nil? (.-right node)) + (tree-map-kv-reduce (.-right node) f init) + init)))))) + +(deftype BlackNode [key val left right ^:mutable __hash] + Object + (add-left [node ins] + (.balance-left ins node)) + + (add-right [node ins] + (.balance-right ins node)) + + (remove-left [node del] + (balance-left-del key val del right)) + + (remove-right [node del] + (balance-right-del key val left del)) + + (blacken [node] node) + + (redden [node] (RedNode. key val left right nil)) + + (balance-left [node parent] + (BlackNode. (.-key parent) (.-val parent) node (.-right parent) nil)) + + (balance-right [node parent] + (BlackNode. (.-key parent) (.-val parent) (.-left parent) node nil)) + + (replace [node key val left right] + (BlackNode. key val left right nil)) + + (kv-reduce [node f init] + (tree-map-kv-reduce node f init)) + + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (-with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] nil) + + ISequential + ISeqable + (-seq [node] (IndexedSeq. #js [key val] 0 nil)) + + IReversible + (-rseq [node] (IndexedSeq. #js [val key] 0 nil)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else (throw (js/Error. "Index out of bounds")))) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + (-contains-key? [node k] + (or (== k 0) (== k 1))) + + IFind + (-find [node k] + (case k + 0 (MapEntry. 0 key nil) + 1 (MapEntry. 1 val nil) + nil)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-nth node k)) + + (-invoke [node k not-found] + (-nth node k not-found))) + +(es6-iterable BlackNode) + +(deftype RedNode [key val left right ^:mutable __hash] + Object + (add-left [node ins] + (RedNode. key val ins right nil)) + + (add-right [node ins] + (RedNode. key val left ins nil)) + + (remove-left [node del] + (RedNode. key val del right nil)) + + (remove-right [node del] + (RedNode. key val left del nil)) + + (blacken [node] + (BlackNode. key val left right nil)) + + (redden [node] + (throw (js/Error. "red-black tree invariant violation"))) + + (balance-left [node parent] + (cond + (instance? RedNode left) + (RedNode. key val + (.blacken left) + (BlackNode. (.-key parent) (.-val parent) right (.-right parent) nil) + nil) + + (instance? RedNode right) + (RedNode. (.-key right) (.-val right) + (BlackNode. key val left (.-left right) nil) + (BlackNode. (.-key parent) (.-val parent) + (.-right right) + (.-right parent) + nil) + nil) + + :else + (BlackNode. (.-key parent) (.-val parent) node (.-right parent) nil))) + + (balance-right [node parent] + (cond + (instance? RedNode right) + (RedNode. key val + (BlackNode. (.-key parent) (.-val parent) + (.-left parent) + left + nil) + (.blacken right) + nil) + + (instance? RedNode left) + (RedNode. (.-key left) (.-val left) + (BlackNode. (.-key parent) (.-val parent) + (.-left parent) + (.-left left) + nil) + (BlackNode. key val (.-right left) right nil) + nil) + + :else + (BlackNode. (.-key parent) (.-val parent) (.-left parent) node nil))) + + (replace [node key val left right] + (RedNode. key val left right nil)) + + (kv-reduce [node f init] + (tree-map-kv-reduce node f init)) + + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-ordered-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (-with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] nil) + + ISequential + ISeqable + (-seq [node] (IndexedSeq. #js [key val] 0 nil)) + + IReversible + (-rseq [node] (IndexedSeq. #js [val key] 0 nil)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else (throw (js/Error. "Index out of bounds")))) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + (-contains-key? [node k] + (or (== k 0) (== k 1))) + + IFind + (-find [node k] + (case k + 0 (MapEntry. 0 key nil) + 1 (MapEntry. 1 val nil) + nil)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-nth node k)) + + (-invoke [node k not-found] + (-nth node k not-found))) + +(es6-iterable RedNode) + +(defn- tree-map-add [comp tree k v found] + (if (nil? tree) + (RedNode. k v nil nil nil) + (let [c (comp k (.-key tree))] + (cond + (zero? c) + (do (aset found 0 tree) + nil) + + (neg? c) + (let [ins (tree-map-add comp (.-left tree) k v found)] + (if-not (nil? ins) + (.add-left tree ins))) + + :else + (let [ins (tree-map-add comp (.-right tree) k v found)] + (if-not (nil? ins) + (.add-right tree ins))))))) + +(defn- tree-map-append [left right] + (cond + (nil? left) + right + + (nil? right) + left + + (instance? RedNode left) + (if (instance? RedNode right) + (let [app (tree-map-append (.-right left) (.-left right))] + (if (instance? RedNode app) + (RedNode. (.-key app) (.-val app) + (RedNode. (.-key left) (.-val left) + (.-left left) + (.-left app) + nil) + (RedNode. (.-key right) (.-val right) + (.-right app) + (.-right right) + nil) + nil) + (RedNode. (.-key left) (.-val left) + (.-left left) + (RedNode. (.-key right) (.-val right) app (.-right right) nil) + nil))) + (RedNode. (.-key left) (.-val left) + (.-left left) + (tree-map-append (.-right left) right) + nil)) + + (instance? RedNode right) + (RedNode. (.-key right) (.-val right) + (tree-map-append left (.-left right)) + (.-right right) + nil) + + :else + (let [app (tree-map-append (.-right left) (.-left right))] + (if (instance? RedNode app) + (RedNode. (.-key app) (.-val app) + (BlackNode. (.-key left) (.-val left) + (.-left left) + (.-left app) + nil) + (BlackNode. (.-key right) (.-val right) + (.-right app) + (.-right right) + nil) + nil) + (balance-left-del (.-key left) (.-val left) + (.-left left) + (BlackNode. (.-key right) (.-val right) + app + (.-right right) + nil)))))) + +(defn- tree-map-remove [comp tree k found] + (if-not (nil? tree) + (let [c (comp k (.-key tree))] + (cond + (zero? c) + (do (aset found 0 tree) + (tree-map-append (.-left tree) (.-right tree))) + + (neg? c) + (let [del (tree-map-remove comp (.-left tree) k found)] + (if (or (not (nil? del)) (not (nil? (aget found 0)))) + (if (instance? BlackNode (.-left tree)) + (balance-left-del (.-key tree) (.-val tree) del (.-right tree)) + (RedNode. (.-key tree) (.-val tree) del (.-right tree) nil)))) + + :else + (let [del (tree-map-remove comp (.-right tree) k found)] + (if (or (not (nil? del)) (not (nil? (aget found 0)))) + (if (instance? BlackNode (.-right tree)) + (balance-right-del (.-key tree) (.-val tree) (.-left tree) del) + (RedNode. (.-key tree) (.-val tree) (.-left tree) del nil)))))))) + +(defn- tree-map-replace [comp tree k v] + (let [tk (.-key tree) + c (comp k tk)] + (cond (zero? c) (.replace tree tk v (.-left tree) (.-right tree)) + (neg? c) (.replace tree tk (.-val tree) (tree-map-replace comp (.-left tree) k v) (.-right tree)) + :else (.replace tree tk (.-val tree) (.-left tree) (tree-map-replace comp (.-right tree) k v))))) + +(declare key) + +(deftype PersistentTreeMap [comp tree cnt meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + + ;; EXPERIMENTAL: subject to change + (keys [coll] + (es6-iterator (keys coll))) + (entries [coll] + (es6-entries-iterator (seq coll))) + (values [coll] + (es6-iterator (vals coll))) + (has [coll k] + (contains? coll k)) + (get [coll k not-found] + (-lookup coll k not-found)) + (forEach [coll f] + (doseq [[k v] coll] + (f v k))) + + (entry-at [coll k] + (loop [t tree] + (if-not (nil? t) + (let [c (comp k (.-key t))] + (cond (zero? c) t + (neg? c) (recur (.-left t)) + :else (recur (.-right t))))))) + + ICloneable + (-clone [_] (PersistentTreeMap. comp tree cnt meta __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentTreeMap. comp tree cnt meta __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (loop [ret coll es (seq entry)] + (if (nil? es) + ret + (let [e (first es)] + (if (vector? e) + (recur (-assoc ret (-nth e 0) (-nth e 1)) + (next es)) + (throw (js/Error. "conj on a map takes map entries or seqables of map entries")))))))) + + IEmptyableCollection + (-empty [coll] (PersistentTreeMap. comp nil 0 meta 0)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-unordered-coll __hash)) + + ICounted + (-count [coll] cnt) + + IKVReduce + (-kv-reduce [coll f init] + (if-not (nil? tree) + (unreduced (tree-map-kv-reduce tree f init)) + init)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + ISeqable + (-seq [coll] + (if (pos? cnt) + (create-tree-map-seq tree true cnt))) + + IReversible + (-rseq [coll] + (if (pos? cnt) + (create-tree-map-seq tree false cnt))) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (let [n (.entry-at coll k)] + (if-not (nil? n) + (.-val n) + not-found))) + + IAssociative + (-assoc [coll k v] + (let [found (array nil) + t (tree-map-add comp tree k v found)] + (if (nil? t) + (let [found-node (nth found 0)] + (if (= v (.-val found-node)) + coll + (PersistentTreeMap. comp (tree-map-replace comp tree k v) cnt meta nil))) + (PersistentTreeMap. comp (.blacken t) (inc cnt) meta nil)))) + + (-contains-key? [coll k] + (not (nil? (.entry-at coll k)))) + + IFind + (-find [coll k] + (.entry-at coll k)) + + IMap + (-dissoc [coll k] + (let [found (array nil) + t (tree-map-remove comp tree k found)] + (if (nil? t) + (if (nil? (nth found 0)) + coll + (PersistentTreeMap. comp nil 0 meta nil)) + (PersistentTreeMap. comp (.blacken t) (dec cnt) meta nil)))) + + ISorted + (-sorted-seq [coll ascending?] + (if (pos? cnt) + (create-tree-map-seq tree ascending? cnt))) + + (-sorted-seq-from [coll k ascending?] + (if (pos? cnt) + (loop [stack nil t tree] + (if-not (nil? t) + (let [c (comp k (.-key t))] + (cond + (zero? c) (PersistentTreeMapSeq. nil (conj stack t) ascending? -1 nil) + ascending? (if (neg? c) + (recur (conj stack t) (.-left t)) + (recur stack (.-right t))) + :else (if (pos? c) + (recur (conj stack t) (.-right t)) + (recur stack (.-left t))))) + (when-not (nil? stack) + (PersistentTreeMapSeq. nil stack ascending? -1 nil)))))) + + (-entry-key [coll entry] (key entry)) + + (-comparator [coll] comp)) + +(set! (.-EMPTY PersistentTreeMap) (PersistentTreeMap. compare nil 0 nil empty-unordered-hash)) + +(es6-iterable PersistentTreeMap) + +(defn hash-map + "keyval => key val + Returns a new hash map with supplied mappings." + [& keyvals] + (loop [in (seq keyvals), out (transient (.-EMPTY PersistentHashMap))] + (if in + (recur (nnext in) (assoc! out (first in) (second in))) + (persistent! out)))) + +(defn array-map + "keyval => key val + Returns a new array map with supplied mappings." + [& keyvals] + (let [arr (if (and (instance? IndexedSeq keyvals) (zero? (.-i keyvals))) + (.-arr keyvals) + (into-array keyvals))] + (.createAsIfByAssoc PersistentArrayMap arr))) + +(defn obj-map + "keyval => key val + Returns a new object map with supplied mappings." + [& keyvals] + (let [ks (array) + obj (js-obj)] + (loop [kvs (seq keyvals)] + (if kvs + (do (.push ks (first kvs)) + (gobject/set obj (first kvs) (second kvs)) + (recur (nnext kvs))) + (.fromObject ObjMap ks obj))))) + +(defn sorted-map + "keyval => key val + Returns a new sorted map with supplied mappings." + ([& keyvals] + (loop [in (seq keyvals) out (.-EMPTY PersistentTreeMap)] + (if in + (recur (nnext in) (assoc out (first in) (second in))) + out)))) + +(defn sorted-map-by + "keyval => key val + Returns a new sorted map with supplied mappings, using the supplied comparator." + ([comparator & keyvals] + (loop [in (seq keyvals) + out (PersistentTreeMap. (fn->comparator comparator) nil 0 nil 0)] + (if in + (recur (nnext in) (assoc out (first in) (second in))) + out)))) + +(deftype KeySeq [^not-native mseq _meta] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] (KeySeq. mseq new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) _meta)) + + IHash + (-hash [coll] (hash-ordered-coll coll)) + + ISeq + (-first [coll] + (let [^not-native me (-first mseq)] + (-key me))) + + (-rest [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (if-not (nil? nseq) + (KeySeq. nseq _meta) + ()))) + + INext + (-next [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (when-not (nil? nseq) + (KeySeq. nseq _meta)))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable KeySeq) + +(defn keys + "Returns a sequence of the map's keys." + [hash-map] + (when-let [mseq (seq hash-map)] + (KeySeq. mseq nil))) + +(defn key + "Returns the key of the map entry." + [map-entry] + (-key map-entry)) + +(deftype ValSeq [^not-native mseq _meta] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] (ValSeq. mseq new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY List) _meta)) + + IHash + (-hash [coll] (hash-ordered-coll coll)) + + ISeq + (-first [coll] + (let [^not-native me (-first mseq)] + (-val me))) + + (-rest [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (if-not (nil? nseq) + (ValSeq. nseq _meta) + ()))) + + INext + (-next [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (when-not (nil? nseq) + (ValSeq. nseq _meta)))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(es6-iterable ValSeq) + +(defn vals + "Returns a sequence of the map's values." + [hash-map] + (when-let [mseq (seq hash-map)] + (ValSeq. mseq nil))) + +(defn val + "Returns the value in the map entry." + [map-entry] + (-val map-entry)) + +(defn merge + "Returns a map that consists of the rest of the maps conj-ed onto + the first. If a key occurs in more than one map, the mapping from + the latter (left-to-right) will be the mapping in the result." + [& maps] + (when (some identity maps) + (reduce #(conj (or %1 {}) %2) maps))) + +(defn merge-with + "Returns a map that consists of the rest of the maps conj-ed onto + the first. If a key occurs in more than one map, the mapping(s) + from the latter (left-to-right) will be combined with the mapping in + the result by calling (f val-in-result val-in-latter)." + [f & maps] + (when (some identity maps) + (let [merge-entry (fn [m e] + (let [k (first e) v (second e)] + (if (contains? m k) + (assoc m k (f (get m k) v)) + (assoc m k v)))) + merge2 (fn [m1 m2] + (reduce merge-entry (or m1 {}) (seq m2)))] + (reduce merge2 maps)))) + +(defn select-keys + "Returns a map containing only those entries in map whose key is in keys" + [map keyseq] + (loop [ret {} keys (seq keyseq)] + (if keys + (let [key (first keys) + entry (get map key ::not-found)] + (recur + (if (not= entry ::not-found) + (assoc ret key entry) + ret) + (next keys))) + (-with-meta ret (meta map))))) + +;;; PersistentHashSet + +(declare TransientHashSet) + +(deftype HashSetIter [iter] + Object + (hasNext [_] + (.hasNext iter)) + (next [_] + (if ^boolean (.hasNext iter) + (.-key (.next iter)) + (throw (js/Error. "No such element")))) + (remove [_] (js/Error. "Unsupported operation"))) + +(deftype PersistentHashSet [meta hash-map ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + + ;; EXPERIMENTAL: subject to change + (keys [coll] + (es6-iterator (seq coll))) + (entries [coll] + (es6-set-entries-iterator (seq coll))) + (values [coll] + (es6-iterator (seq coll))) + (has [coll k] + (contains? coll k)) + (forEach [coll f] + (doseq [[k v] coll] + (f v k))) + + ICloneable + (-clone [_] (PersistentHashSet. meta hash-map __hash)) + + IIterable + (-iterator [coll] + (HashSetIter. (-iterator hash-map))) + + IWithMeta + (-with-meta [coll meta] (PersistentHashSet. meta hash-map __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll o] + (PersistentHashSet. meta (assoc hash-map o nil) nil)) + + IEmptyableCollection + (-empty [coll] (-with-meta (.-EMPTY PersistentHashSet) meta)) + + IEquiv + (-equiv [coll other] + (and + (set? other) + (== (count coll) (count other)) + ^boolean + (try + (reduce-kv + #(or (contains? other %2) (reduced false)) + true hash-map) + (catch js/Error ex + false)))) + + IHash + (-hash [coll] (caching-hash coll hash-unordered-coll __hash)) + + ISeqable + (-seq [coll] (keys hash-map)) + + ICounted + (-count [coll] (-count hash-map)) + + ILookup + (-lookup [coll v] + (-lookup coll v nil)) + (-lookup [coll v not-found] + (if-let [entry (-find hash-map v)] + (key entry) + not-found)) + + ISet + (-disjoin [coll v] + (PersistentHashSet. meta (-dissoc hash-map v) nil)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] (TransientHashSet. (-as-transient hash-map)))) + +(set! (.-EMPTY PersistentHashSet) + (PersistentHashSet. nil (.-EMPTY PersistentArrayMap) empty-unordered-hash)) + +(set! (.-fromArray PersistentHashSet) + (fn [items ^boolean no-clone] + (let [len (alength items)] + (if (<= len (.-HASHMAP-THRESHOLD PersistentArrayMap)) + (let [arr (if no-clone items (aclone items))] + (loop [i 0 + out (transient (.-EMPTY PersistentArrayMap))] + (if (< i len) + (recur (inc i) (-assoc! out (aget items i) nil)) + (PersistentHashSet. nil (-persistent! out) nil)))) + (loop [i 0 + out (transient (.-EMPTY PersistentHashSet))] + (if (< i len) + (recur (inc i) (-conj! out (aget items i))) + (-persistent! out))))))) + +(set! (.-createWithCheck PersistentHashSet) + (fn [items] + (let [len (alength items) + t (-as-transient (.-EMPTY PersistentHashSet))] + (dotimes [i len] + (-conj! t (aget items i)) + (when-not (= (count t) (inc i)) + (throw (js/Error. (str "Duplicate key: " (aget items i)))))) + (-persistent! t)))) + +(set! (.-createAsIfByAssoc PersistentHashSet) + (fn [items] + (let [len (alength items) + t (-as-transient (.-EMPTY PersistentHashSet))] + (dotimes [i len] (-conj! t (aget items i))) + (-persistent! t)))) + +(es6-iterable PersistentHashSet) + +(deftype TransientHashSet [^:mutable transient-map] + ITransientCollection + (-conj! [tcoll o] + (set! transient-map (assoc! transient-map o nil)) + tcoll) + + (-persistent! [tcoll] + (PersistentHashSet. nil (persistent! transient-map) nil)) + + ITransientSet + (-disjoin! [tcoll v] + (set! transient-map (dissoc! transient-map v)) + tcoll) + + ICounted + (-count [tcoll] (count transient-map)) + + ILookup + (-lookup [tcoll v] + (-lookup tcoll v nil)) + + (-lookup [tcoll v not-found] + (if (identical? (-lookup transient-map v lookup-sentinel) lookup-sentinel) + not-found + v)) + + IFn + (-invoke [tcoll k] + (if (identical? (-lookup transient-map k lookup-sentinel) lookup-sentinel) + nil + k)) + + (-invoke [tcoll k not-found] + (if (identical? (-lookup transient-map k lookup-sentinel) lookup-sentinel) + not-found + k))) + +(deftype PersistentTreeSet [meta tree-map ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + + ;; EXPERIMENTAL: subject to change + (keys [coll] + (es6-iterator (seq coll))) + (entries [coll] + (es6-set-entries-iterator (seq coll))) + (values [coll] + (es6-iterator (seq coll))) + (has [coll k] + (contains? coll k)) + (forEach [coll f] + (doseq [[k v] coll] + (f v k))) + + ICloneable + (-clone [_] (PersistentTreeSet. meta tree-map __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentTreeSet. meta tree-map __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll o] + (PersistentTreeSet. meta (assoc tree-map o nil) nil)) + + IEmptyableCollection + (-empty [coll] (PersistentTreeSet. meta (-empty tree-map) 0)) + + IEquiv + (-equiv [coll other] + (and + (set? other) + (== (count coll) (count other)) + ^boolean + (try + (reduce-kv + #(or (contains? other %2) (reduced false)) + true tree-map) + (catch js/Error ex + false)))) + + IHash + (-hash [coll] (caching-hash coll hash-unordered-coll __hash)) + + ISeqable + (-seq [coll] (keys tree-map)) + + ISorted + (-sorted-seq [coll ascending?] + (map key (-sorted-seq tree-map ascending?))) + + (-sorted-seq-from [coll k ascending?] + (map key (-sorted-seq-from tree-map k ascending?))) + + (-entry-key [coll entry] entry) + + (-comparator [coll] (-comparator tree-map)) + + IReversible + (-rseq [coll] + (if (pos? (count tree-map)) + (map key (rseq tree-map)))) + + ICounted + (-count [coll] (count tree-map)) + + ILookup + (-lookup [coll v] + (-lookup coll v nil)) + (-lookup [coll v not-found] + (let [n (.entry-at tree-map v)] + (if-not (nil? n) + (.-key n) + not-found))) + + ISet + (-disjoin [coll v] + (PersistentTreeSet. meta (dissoc tree-map v) nil)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found))) + +(set! (.-EMPTY PersistentTreeSet) + (PersistentTreeSet. nil (.-EMPTY PersistentTreeMap) empty-unordered-hash)) + +(es6-iterable PersistentTreeSet) + +(defn set-from-indexed-seq [iseq] + (let [arr (.-arr iseq) + ret (areduce arr i ^not-native res (-as-transient #{}) + (-conj! res (aget arr i)))] + (-persistent! ^not-native ret))) + +(defn set + "Returns a set of the distinct elements of coll." + [coll] + (let [in (seq coll)] + (cond + (nil? in) #{} + + (and (instance? IndexedSeq in) (zero? (.-i in))) + (.createAsIfByAssoc PersistentHashSet (.-arr in)) + + :else + (loop [^not-native in in + ^not-native out (-as-transient #{})] + (if-not (nil? in) + (recur (next in) (-conj! out (-first in))) + (persistent! out)))))) + +(defn hash-set + "Returns a new hash set with supplied keys. Any equal keys are + handled as if by repeated uses of conj." + ([] #{}) + ([& keys] (set keys))) + +(defn sorted-set + "Returns a new sorted set with supplied keys." + ([& keys] + (reduce -conj (.-EMPTY PersistentTreeSet) keys))) + +(defn sorted-set-by + "Returns a new sorted set with supplied keys, using the supplied comparator." + ([comparator & keys] + (reduce -conj + (PersistentTreeSet. nil (sorted-map-by comparator) 0) + keys))) + +(defn replace + "Given a map of replacement pairs and a vector/collection, returns a + vector/seq with any elements = a key in smap replaced with the + corresponding val in smap. Returns a transducer when no collection + is provided." + ([smap] + (map #(if-let [e (find smap %)] (val e) %))) + ([smap coll] + (if (vector? coll) + (let [n (count coll)] + (reduce (fn [v i] + (if-let [e (find smap (nth v i))] + (assoc v i (second e)) + v)) + coll (take n (iterate inc 0)))) + (map #(if-let [e (find smap %)] (second e) %) coll)))) + +(defn distinct + "Returns a lazy sequence of the elements of coll with duplicates removed. + Returns a stateful transducer when no collection is provided." + ([] + (fn [rf] + (let [seen (volatile! #{})] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (if (contains? @seen input) + result + (do (vswap! seen conj input) + (rf result input)))))))) + ([coll] + (let [step (fn step [xs seen] + (lazy-seq + ((fn [[f :as xs] seen] + (when-let [s (seq xs)] + (if (contains? seen f) + (recur (rest s) seen) + (cons f (step (rest s) (conj seen f)))))) + xs seen)))] + (step coll #{})))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defn butlast + "Return a seq of all but the last item in coll, in linear time" + [s] + (loop [ret [] s s] + (if (next s) + (recur (conj ret (first s)) (next s)) + (seq ret)))) + +(defn name + "Returns the name String of a string, symbol or keyword." + [x] + (if (implements? INamed x) + (-name ^not-native x) + (if (string? x) + x + (throw (js/Error. (str "Doesn't support name: " x)))))) + +(defn zipmap + "Returns a map with the keys mapped to the corresponding vals." + [keys vals] + (loop [map (transient {}) + ks (seq keys) + vs (seq vals)] + (if (and ks vs) + (recur (assoc! map (first ks) (first vs)) + (next ks) + (next vs)) + (persistent! map)))) + +(defn max-key + "Returns the x for which (k x), a number, is greatest. + + If there are multiple such xs, the last one is returned." + ([k x] x) + ([k x y] (if (> (k x) (k y)) x y)) + ([k x y & more] + (reduce #(max-key k %1 %2) (max-key k x y) more))) + +(defn min-key + "Returns the x for which (k x), a number, is least. + + If there are multiple such xs, the last one is returned." + ([k x] x) + ([k x y] (if (< (k x) (k y)) x y)) + ([k x y & more] + (reduce #(min-key k %1 %2) (min-key k x y) more))) + +(deftype ArrayList [^:mutable arr] + Object + (add [_ x] (.push arr x)) + (size [_] (alength arr)) + (clear [_] (set! arr (array))) + (isEmpty [_] (zero? (alength arr))) + (toArray [_] arr)) + +(defn array-list [] + (ArrayList. (array))) + +(defn partition-all + "Returns a lazy sequence of lists like partition, but may include + partitions with fewer than n items at the end. Returns a stateful + transducer when no collection is provided." + ([n] + (fn [rf] + (let [a (array-list)] + (fn + ([] (rf)) + ([result] + (let [result (if (.isEmpty a) + result + (let [v (vec (.toArray a))] + ;;clear first! + (.clear a) + (unreduced (rf result v))))] + (rf result))) + ([result input] + (.add a input) + (if (== n (.size a)) + (let [v (vec (.toArray a))] + (.clear a) + (rf result v)) + result)))))) + ([n coll] + (partition-all n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (cons (take n s) (partition-all n step (drop step s))))))) + +(defn take-while + "Returns a lazy sequence of successive items from coll while + (pred item) returns logical true. pred must be free of side-effects. + Returns a transducer when no collection is provided." + ([pred] + (fn [rf] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (if (pred input) + (rf result input) + (reduced result)))))) + ([pred coll] + (lazy-seq + (when-let [s (seq coll)] + (when (pred (first s)) + (cons (first s) (take-while pred (rest s)))))))) + +(defn mk-bound-fn + [sc test key] + (fn [e] + (let [comp (-comparator sc)] + (test (comp (-entry-key sc e) key) 0)))) + +(defn subseq + "sc must be a sorted collection, test(s) one of <, <=, > or + >=. Returns a seq of those entries with keys ek for + which (test (.. sc comparator (compare ek key)) 0) is true" + ([sc test key] + (let [include (mk-bound-fn sc test key)] + (if (#{> >=} test) + (when-let [[e :as s] (-sorted-seq-from sc key true)] + (if (include e) s (next s))) + (take-while include (-sorted-seq sc true))))) + ([sc start-test start-key end-test end-key] + (when-let [[e :as s] (-sorted-seq-from sc start-key true)] + (take-while (mk-bound-fn sc end-test end-key) + (if ((mk-bound-fn sc start-test start-key) e) s (next s)))))) + +(defn rsubseq + "sc must be a sorted collection, test(s) one of <, <=, > or + >=. Returns a reverse seq of those entries with keys ek for + which (test (.. sc comparator (compare ek key)) 0) is true" + ([sc test key] + (let [include (mk-bound-fn sc test key)] + (if (#{< <=} test) + (when-let [[e :as s] (-sorted-seq-from sc key false)] + (if (include e) s (next s))) + (take-while include (-sorted-seq sc false))))) + ([sc start-test start-key end-test end-key] + (when-let [[e :as s] (-sorted-seq-from sc end-key false)] + (take-while (mk-bound-fn sc start-test start-key) + (if ((mk-bound-fn sc end-test end-key) e) s (next s)))))) + +(deftype RangeIterator [^:mutable i end step] + Object + (hasNext [_] + (if (pos? step) + (< i end) + (> i end))) + (next [_] + (let [ret i] + (set! i (+ i step)) + ret))) + +(deftype Range [meta start end step ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + (equiv [this other] + (-equiv this other)) + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ICloneable + (-clone [_] (Range. meta start end step __hash)) + + IWithMeta + (-with-meta [rng meta] (Range. meta start end step __hash)) + + IMeta + (-meta [rng] meta) + + ISeqable + (-seq [rng] + (cond + (pos? step) (when (< start end) rng) + (neg? step) (when (> start end) rng) + :else (when-not (== start end) rng))) + + ISeq + (-first [rng] + (when-not (nil? (-seq rng)) start)) + (-rest [rng] + (if-not (nil? (-seq rng)) + (Range. meta (+ start step) end step nil) + ())) + + IIterable + (-iterator [_] + (RangeIterator. start end step)) + + INext + (-next [rng] + (if (pos? step) + (when (< (+ start step) end) + (Range. meta (+ start step) end step nil)) + (when (> (+ start step) end) + (Range. meta (+ start step) end step nil)))) + + ICollection + (-conj [rng o] (cons o rng)) + + IEmptyableCollection + (-empty [rng] (-with-meta (.-EMPTY List) meta)) + + ISequential + IEquiv + (-equiv [rng other] (equiv-sequential rng other)) + + IHash + (-hash [rng] (caching-hash rng hash-ordered-coll __hash)) + + ICounted + (-count [rng] + (if-not (-seq rng) + 0 + (Math/ceil (/ (- end start) step)))) + + IIndexed + (-nth [rng n] + (if (and (<= 0 n) (< n (-count rng))) + (+ start (* n step)) + (if (and (<= 0 n) (> start end) (zero? step)) + start + (throw (js/Error. "Index out of bounds"))))) + (-nth [rng n not-found] + (if (and (<= 0 n) (< n (-count rng))) + (+ start (* n step)) + (if (and (<= 0 n) (> start end) (zero? step)) + start + not-found))) + + IReduce + (-reduce [rng f] (ci-reduce rng f)) + (-reduce [rng f init] + (loop [i start ret init] + (if (if (pos? step) (< i end) (> i end)) + (let [ret (f ret i)] + (if (reduced? ret) + @ret + (recur (+ i step) ret))) + ret)))) + +(es6-iterable Range) + +(defn range + "Returns a lazy seq of nums from start (inclusive) to end + (exclusive), by step, where start defaults to 0, step to 1, + and end to infinity." + ([] (range 0 (.-MAX_VALUE js/Number) 1)) + ([end] (range 0 end 1)) + ([start end] (range start end 1)) + ([start end step] (Range. nil start end step nil))) + +(defn take-nth + "Returns a lazy seq of every nth item in coll. Returns a stateful + transducer when no collection is provided." + ([n] + {:pre [(number? n)]} + (fn [rf] + (let [ia (volatile! -1)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [i (vswap! ia inc)] + (if (zero? (rem i n)) + (rf result input) + result))))))) + ([n coll] + {:pre [(number? n)]} + (lazy-seq + (when-let [s (seq coll)] + (cons (first s) (take-nth n (drop n s))))))) + +(defn split-with + "Returns a vector of [(take-while pred coll) (drop-while pred coll)]" + [pred coll] + [(take-while pred coll) (drop-while pred coll)]) + +(defn partition-by + "Applies f to each value in coll, splitting it each time f returns a + new value. Returns a lazy seq of partitions. Returns a stateful + transducer when no collection is provided." + ([f] + (fn [rf] + (let [a (array-list) + pa (volatile! ::none)] + (fn + ([] (rf)) + ([result] + (let [result (if (.isEmpty a) + result + (let [v (vec (.toArray a))] + ;;clear first! + (.clear a) + (unreduced (rf result v))))] + (rf result))) + ([result input] + (let [pval @pa + val (f input)] + (vreset! pa val) + (if (or (keyword-identical? pval ::none) + (= val pval)) + (do + (.add a input) + result) + (let [v (vec (.toArray a))] + (.clear a) + (let [ret (rf result v)] + (when-not (reduced? ret) + (.add a input)) + ret))))))))) + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (let [fst (first s) + fv (f fst) + run (cons fst (take-while #(= fv (f %)) (next s)))] + (cons run (partition-by f (seq (drop (count run) s))))))))) + +(defn frequencies + "Returns a map from distinct items in coll to the number of times + they appear." + [coll] + (persistent! + (reduce (fn [counts x] + (assoc! counts x (inc (get counts x 0)))) + (transient {}) coll))) + +(defn reductions + "Returns a lazy seq of the intermediate values of the reduction (as + per reduce) of coll by f, starting with init." + ([f coll] + (lazy-seq + (if-let [s (seq coll)] + (reductions f (first s) (rest s)) + (list (f))))) + ([f init coll] + (if (reduced? init) + (list @init) + (cons init + (lazy-seq + (when-let [s (seq coll)] + (reductions f (f init (first s)) (rest s)))))))) + +(defn juxt + "Takes a set of functions and returns a fn that is the juxtaposition + of those fns. The returned fn takes a variable number of args, and + returns a vector containing the result of applying each fn to the + args (left-to-right). + ((juxt a b c) x) => [(a x) (b x) (c x)]" + ([f] + (fn + ([] (vector (f))) + ([x] (vector (f x))) + ([x y] (vector (f x y))) + ([x y z] (vector (f x y z))) + ([x y z & args] (vector (apply f x y z args))))) + ([f g] + (fn + ([] (vector (f) (g))) + ([x] (vector (f x) (g x))) + ([x y] (vector (f x y) (g x y))) + ([x y z] (vector (f x y z) (g x y z))) + ([x y z & args] (vector (apply f x y z args) (apply g x y z args))))) + ([f g h] + (fn + ([] (vector (f) (g) (h))) + ([x] (vector (f x) (g x) (h x))) + ([x y] (vector (f x y) (g x y) (h x y))) + ([x y z] (vector (f x y z) (g x y z) (h x y z))) + ([x y z & args] (vector (apply f x y z args) (apply g x y z args) (apply h x y z args))))) + ([f g h & fs] + (let [fs (list* f g h fs)] + (fn + ([] (reduce #(conj %1 (%2)) [] fs)) + ([x] (reduce #(conj %1 (%2 x)) [] fs)) + ([x y] (reduce #(conj %1 (%2 x y)) [] fs)) + ([x y z] (reduce #(conj %1 (%2 x y z)) [] fs)) + ([x y z & args] (reduce #(conj %1 (apply %2 x y z args)) [] fs)))))) + +(defn dorun + "When lazy sequences are produced via functions that have side + effects, any effects other than those needed to produce the first + element in the seq do not occur until the seq is consumed. dorun can + be used to force any effects. Walks through the successive nexts of + the seq, does not retain the head and returns nil." + ([coll] + (when-let [s (seq coll)] + (recur (next s)))) + ([n coll] + (when (and (seq coll) (pos? n)) + (recur (dec n) (next coll))))) + +(defn doall + "When lazy sequences are produced via functions that have side + effects, any effects other than those needed to produce the first + element in the seq do not occur until the seq is consumed. doall can + be used to force any effects. Walks through the successive nexts of + the seq, retains the head and returns it, thus causing the entire + seq to reside in memory at one time." + ([coll] + (dorun coll) + coll) + ([n coll] + (dorun n coll) + coll)) + +;;;;;;;;;;;;;;;;;;;;;;;;; Regular Expressions ;;;;;;;;;; + +(defn ^boolean regexp? + "Returns true if x is a JavaScript RegExp instance." + [x] + (instance? js/RegExp x)) + +(defn re-matches + "Returns the result of (re-find re s) if re fully matches s." + [re s] + (if (string? s) + (let [matches (.exec re s)] + (when (= (first matches) s) + (if (== (count matches) 1) + (first matches) + (vec matches)))) + (throw (js/TypeError. "re-matches must match against a string.")))) + + +(defn re-find + "Returns the first regex match, if any, of s to re, using + re.exec(s). Returns a vector, containing first the matching + substring, then any capturing groups if the regular expression contains + capturing groups." + [re s] + (if (string? s) + (let [matches (.exec re s)] + (when-not (nil? matches) + (if (== (count matches) 1) + (first matches) + (vec matches)))) + (throw (js/TypeError. "re-find must match against a string.")))) + +(defn re-seq + "Returns a lazy sequence of successive matches of re in s." + [re s] + (let [match-data (re-find re s) + match-idx (.search s re) + match-str (if (coll? match-data) (first match-data) match-data) + post-idx (+ match-idx (max 1 (count match-str))) + post-match (subs s post-idx)] + (when match-data (lazy-seq (cons match-data (when (<= post-idx (count s)) (re-seq re post-match))))))) + +(defn re-pattern + "Returns an instance of RegExp which has compiled the provided string." + [s] + (if (instance? js/RegExp s) + s + (let [[prefix flags] (re-find #"^\(\?([idmsux]*)\)" s) + pattern (subs s (count prefix))] + (js/RegExp. pattern (or flags ""))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Printing ;;;;;;;;;;;;;;;; + +(defn pr-sequential-writer [writer print-one begin sep end opts coll] + (binding [*print-level* (when-not (nil? *print-level*) (dec *print-level*))] + (if (and (not (nil? *print-level*)) (neg? *print-level*)) + (-write writer "#") + (do + (-write writer begin) + (if (zero? (:print-length opts)) + (when (seq coll) + (-write writer (or (:more-marker opts) "..."))) + (do + (when (seq coll) + (print-one (first coll) writer opts)) + (loop [coll (next coll) n (dec (:print-length opts))] + (if (and coll (or (nil? n) (not (zero? n)))) + (do + (-write writer sep) + (print-one (first coll) writer opts) + (recur (next coll) (dec n))) + (when (and (seq coll) (zero? n)) + (-write writer sep) + (-write writer (or (:more-marker opts) "..."))))))) + (-write writer end))))) + +(defn write-all [writer & ss] + (doseq [s ss] + (-write writer s))) + +(defn string-print [x] + (when (nil? *print-fn*) + (throw (js/Error. "No *print-fn* fn set for evaluation environment"))) + (*print-fn* x) + nil) + +(defn flush [] ;stub + nil) + +(def ^:private char-escapes + (js-obj + "\"" "\\\"" + "\\" "\\\\" + "\b" "\\b" + "\f" "\\f" + "\n" "\\n" + "\r" "\\r" + "\t" "\\t")) + +(defn ^:private quote-string + [s] + (str \" + (.replace s (js/RegExp "[\\\\\"\b\f\n\r\t]" "g") + (fn [match] (unchecked-get char-escapes match))) + \")) + +(declare print-map) + +(defn ^boolean print-meta? [opts obj] + (and (boolean (get opts :meta)) + (implements? IMeta obj) + (not (nil? (meta obj))))) + +(defn- pr-writer-impl + [obj writer opts] + (cond + (nil? obj) (-write writer "nil") + :else + (do + (when (print-meta? opts obj) + (-write writer "^") + (pr-writer (meta obj) writer opts) + (-write writer " ")) + (cond + ;; handle CLJS ctors + ^boolean (.-cljs$lang$type obj) + (.cljs$lang$ctorPrWriter obj obj writer opts) + + ; Use the new, more efficient, IPrintWithWriter interface when possible. + (implements? IPrintWithWriter obj) + (-pr-writer ^not-native obj writer opts) + + (or (true? obj) (false? obj)) + (-write writer (str obj)) + + (number? obj) + (-write writer + (cond + ^boolean (js/isNaN obj) "##NaN" + (identical? obj js/Number.POSITIVE_INFINITY) "##Inf" + (identical? obj js/Number.NEGATIVE_INFINITY) "##-Inf" + :else (str obj))) + + (object? obj) + (do + (-write writer "#js ") + (print-map + (map (fn [k] + (MapEntry. (cond-> k (some? (re-matches #"[A-Za-z_\*\+\?!\-'][\w\*\+\?!\-']*" k)) keyword) (unchecked-get obj k) nil)) + (js-keys obj)) + pr-writer writer opts)) + + (array? obj) + (pr-sequential-writer writer pr-writer "#js [" " " "]" opts obj) + + ^boolean (goog/isString obj) + (if (:readably opts) + (-write writer (quote-string obj)) + (-write writer obj)) + + ^boolean (goog/isFunction obj) + (let [name (.-name obj) + name (if (or (nil? name) (gstring/isEmpty name)) + "Function" + name)] + (write-all writer "#object[" name + (if *print-fn-bodies* + (str " \"" (str obj) "\"") + "") + "]")) + + (instance? js/Date obj) + (let [normalize (fn [n len] + (loop [ns (str n)] + (if (< (count ns) len) + (recur (str "0" ns)) + ns)))] + (write-all writer + "#inst \"" + (str (.getUTCFullYear obj)) "-" + (normalize (inc (.getUTCMonth obj)) 2) "-" + (normalize (.getUTCDate obj) 2) "T" + (normalize (.getUTCHours obj) 2) ":" + (normalize (.getUTCMinutes obj) 2) ":" + (normalize (.getUTCSeconds obj) 2) "." + (normalize (.getUTCMilliseconds obj) 3) "-" + "00:00\"")) + + (regexp? obj) (write-all writer "#\"" (.-source obj) "\"") + + :else + (if (some-> obj .-constructor .-cljs$lang$ctorStr) + (write-all writer + "#object[" (.replace (.. obj -constructor -cljs$lang$ctorStr) + (js/RegExp. "/" "g") ".") "]") + (let [name (some-> obj .-constructor .-name) + name (if (or (nil? name) (gstring/isEmpty name)) + "Object" + name)] + (if (nil? (. obj -constructor)) + (write-all writer "#object[" name "]") + (write-all writer "#object[" name " " (str obj) "]")))))))) + +(defn- pr-writer + "Prefer this to pr-seq, because it makes the printing function + configurable, allowing efficient implementations such as appending + to a StringBuffer." + [obj writer opts] + (if-let [alt-impl (:alt-impl opts)] + (alt-impl obj writer (assoc opts :fallback-impl pr-writer-impl)) + (pr-writer-impl obj writer opts))) + +(defn pr-seq-writer [objs writer opts] + (pr-writer (first objs) writer opts) + (doseq [obj (next objs)] + (-write writer " ") + (pr-writer obj writer opts))) + +(defn- pr-sb-with-opts [objs opts] + (let [sb (StringBuffer.) + writer (StringBufferWriter. sb)] + (pr-seq-writer objs writer opts) + (-flush writer) + sb)) + +(defn pr-str-with-opts + "Prints a sequence of objects to a string, observing all the + options given in opts" + [objs opts] + (if (empty? objs) + "" + (str (pr-sb-with-opts objs opts)))) + +(defn prn-str-with-opts + "Same as pr-str-with-opts followed by (newline)" + [objs opts] + (if (empty? objs) + "\n" + (let [sb (pr-sb-with-opts objs opts)] + (.append sb \newline) + (str sb)))) + +(defn- pr-with-opts + "Prints a sequence of objects using string-print, observing all + the options given in opts" + [objs opts] + (string-print (pr-str-with-opts objs opts))) + +(defn newline + "Prints a newline using *print-fn*" + ([] (newline nil)) + ([opts] + (string-print "\n") + (when (get opts :flush-on-newline) + (flush)))) + +(defn pr-str + "pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter." + [& objs] + (pr-str-with-opts objs (pr-opts))) + +(defn prn-str + "Same as pr-str followed by (newline)" + [& objs] + (prn-str-with-opts objs (pr-opts))) + +(defn pr + "Prints the object(s) using string-print. Prints the + object(s), separated by spaces if there is more than one. + By default, pr and prn print in a way that objects can be + read by the reader" + [& objs] + (pr-with-opts objs (pr-opts))) + +(def ^{:doc + "Prints the object(s) using string-print. + print and println produce output for human consumption."} + print + (fn cljs-core-print [& objs] + (pr-with-opts objs (assoc (pr-opts) :readably false)))) + +(defn print-str + "print to a string, returning it" + [& objs] + (pr-str-with-opts objs (assoc (pr-opts) :readably false))) + +(defn println + "Same as print followed by (newline)" + [& objs] + (pr-with-opts objs (assoc (pr-opts) :readably false)) + (when *print-newline* + (newline (pr-opts)))) + +(defn println-str + "println to a string, returning it" + [& objs] + (prn-str-with-opts objs (assoc (pr-opts) :readably false))) + +(defn prn + "Same as pr followed by (newline)." + [& objs] + (pr-with-opts objs (pr-opts)) + (when *print-newline* + (newline (pr-opts)))) + +(defn- strip-ns + [named] + (if (symbol? named) + (symbol nil (name named)) + (keyword nil (name named)))) + +(defn- lift-ns + "Returns [lifted-ns lifted-map] or nil if m can't be lifted." + [m] + (when *print-namespace-maps* + (loop [ns nil + [[k v :as entry] & entries] (seq m) + lm (empty m)] + (if entry + (when (or (keyword? k) (symbol? k)) + (if ns + (when (= ns (namespace k)) + (recur ns entries (assoc lm (strip-ns k) v))) + (when-let [new-ns (namespace k)] + (recur new-ns entries (assoc lm (strip-ns k) v))))) + [ns lm])))) + +(defn print-prefix-map [prefix m print-one writer opts] + (pr-sequential-writer + writer + (fn [e w opts] + (do (print-one (key e) w opts) + (-write w \space) + (print-one (val e) w opts))) + (str prefix "{") ", " "}" + opts (seq m))) + +(defn print-map [m print-one writer opts] + (let [[ns lift-map] (when (map? m) + (lift-ns m))] + (if ns + (print-prefix-map (str "#:" ns) lift-map print-one writer opts) + (print-prefix-map nil m print-one writer opts)))) + +(extend-protocol IPrintWithWriter + LazySeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + TransformerIterator + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + IndexedSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + RSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentQueue + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#queue [" " " "]" opts (seq coll))) + + PersistentQueueSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentTreeMapSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + NodeSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ArrayNodeSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + List + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Cons + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + EmptyList + (-pr-writer [coll writer opts] (-write writer "()")) + + PersistentVector + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + ChunkedCons + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ChunkedSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Subvec + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + BlackNode + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + RedNode + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + MapEntry + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + ObjMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + KeySeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ValSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentArrayMapSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentArrayMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentHashMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentTreeMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentHashSet + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#{" " " "}" opts coll)) + + PersistentTreeSet + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#{" " " "}" opts coll)) + + Range + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Cycle + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Repeat + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Iterate + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ES6IteratorSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Atom + (-pr-writer [a writer opts] + (-write writer "#object [cljs.core.Atom ") + (pr-writer {:val (.-state a)} writer opts) + (-write writer "]")) + + Volatile + (-pr-writer [a writer opts] + (-write writer "#object [cljs.core.Volatile ") + (pr-writer {:val (.-state a)} writer opts) + (-write writer "]")) + + Var + (-pr-writer [a writer opts] + (-write writer "#'") + (pr-writer (.-sym a) writer opts))) + +;; IComparable +(extend-protocol IComparable + Symbol + (-compare [x y] + (if (symbol? y) + (compare-symbols x y) + (throw (js/Error. (str "Cannot compare " x " to " y))))) + + Keyword + (-compare [x y] + (if (keyword? y) + (compare-keywords x y) + (throw (js/Error. (str "Cannot compare " x " to " y))))) + + Subvec + (-compare [x y] + (if (vector? y) + (compare-indexed x y) + (throw (js/Error. (str "Cannot compare " x " to " y))))) + + PersistentVector + (-compare [x y] + (if (vector? y) + (compare-indexed x y) + (throw (js/Error. (str "Cannot compare " x " to " y))))) + + MapEntry + (-compare [x y] + (if (vector? y) + (compare-indexed x y) + (throw (js/Error. (str "Cannot compare " x " to " y))))) + + BlackNode + (-compare [x y] + (if (vector? y) + (compare-indexed x y) + (throw (js/Error. (str "Cannot compare " x " to " y))))) + + RedNode + (-compare [x y] + (if (vector? y) + (compare-indexed x y) + (throw (js/Error. (str "Cannot compare " x " to " y)))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Reference Types ;;;;;;;;;;;;;;;; + +(defn alter-meta! + "Atomically sets the metadata for a namespace/var/ref/agent/atom to be: + + (apply f its-current-meta args) + + f must be free of side-effects" + [iref f & args] + (set! (.-meta iref) (apply f (.-meta iref) args))) + +(defn reset-meta! + "Atomically resets the metadata for an atom" + [iref m] + (set! (.-meta iref) m)) + +(defn add-watch + "Adds a watch function to an atom reference. The watch fn must be a + fn of 4 args: a key, the reference, its old-state, its + new-state. Whenever the reference's state might have been changed, + any registered watches will have their functions called. The watch + fn will be called synchronously. Note that an atom's state + may have changed again prior to the fn call, so use old/new-state + rather than derefing the reference. Keys must be unique per + reference, and can be used to remove the watch with remove-watch, + but are otherwise considered opaque by the watch mechanism. Bear in + mind that regardless of the result or action of the watch fns the + atom's value will change. Example: + + (def a (atom 0)) + (add-watch a :inc (fn [k r o n] (assert (== 0 n)))) + (swap! a inc) + ;; Assertion Error + (deref a) + ;=> 1" + [iref key f] + (-add-watch iref key f) + iref) + +(defn remove-watch + "Removes a watch (set by add-watch) from a reference" + [iref key] + (-remove-watch iref key) + iref) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; gensym ;;;;;;;;;;;;;;;; +;; Internal - do not use! +(def + ^{:jsdoc ["@type {*}"]} + gensym_counter nil) + +(defn gensym + "Returns a new symbol with a unique name. If a prefix string is + supplied, the name is prefix# where # is some unique number. If + prefix is not supplied, the prefix is 'G__'." + ([] (gensym "G__")) + ([prefix-string] + (when (nil? gensym_counter) + (set! gensym_counter (atom 0))) + (symbol (str prefix-string (swap! gensym_counter inc))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Delay ;;;;;;;;;;;;;;;;;;;; + +(deftype Delay [^:mutable f ^:mutable value] + IDeref + (-deref [_] + (when f + (set! value (f)) + (set! f nil)) + value) + + IPending + (-realized? [x] + (not f))) + +(defn ^boolean delay? + "returns true if x is a Delay created with delay" + [x] (instance? Delay x)) + +(defn force + "If x is a Delay, returns the (possibly cached) value of its expression, else returns x" + [x] + (if (delay? x) + (deref x) + x)) + +(defn ^boolean realized? + "Returns true if a value has been produced for a delay or lazy sequence." + [x] + (-realized? x)) + +(defn- preserving-reduced + [rf] + #(let [ret (rf %1 %2)] + (if (reduced? ret) + (reduced ret) + ret))) + +(defn cat + "A transducer which concatenates the contents of each input, which must be a + collection, into the reduction." + {:added "1.7"} + [rf] + (let [rf1 (preserving-reduced rf)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (reduce rf1 result input))))) + +(defn halt-when + "Returns a transducer that ends transduction when pred returns true + for an input. When retf is supplied it must be a fn of 2 arguments - + it will be passed the (completed) result so far and the input that + triggered the predicate, and its return value (if it does not throw + an exception) will be the return value of the transducer. If retf + is not supplied, the input that triggered the predicate will be + returned. If the predicate never returns true the transduction is + unaffected." + {:added "1.9"} + ([pred] (halt-when pred nil)) + ([pred retf] + (fn [rf] + (fn + ([] (rf)) + ([result] + (if (and (map? result) (contains? result ::halt)) + (::halt result) + (rf result))) + ([result input] + (if (pred input) + (reduced {::halt (if retf (retf (rf result) input) input)}) + (rf result input))))))) + +(defn dedupe + "Returns a lazy sequence removing consecutive duplicates in coll. + Returns a transducer when no collection is provided." + ([] + (fn [rf] + (let [pa (volatile! ::none)] + (fn + ([] (rf)) + ([result] (rf result)) + ([result input] + (let [prior @pa] + (vreset! pa input) + (if (= prior input) + result + (rf result input)))))))) + ([coll] (sequence (dedupe) coll))) + +(declare rand) + +(defn random-sample + "Returns items from coll with random probability of prob (0.0 - + 1.0). Returns a transducer when no collection is provided." + ([prob] + (filter (fn [_] (< (rand) prob)))) + ([prob coll] + (filter (fn [_] (< (rand) prob)) coll))) + +(deftype Eduction [xform coll] + Object + (indexOf [coll x] + (-indexOf coll x 0)) + (indexOf [coll x start] + (-indexOf coll x start)) + (lastIndexOf [coll x] + (-lastIndexOf coll x (count coll))) + (lastIndexOf [coll x start] + (-lastIndexOf coll x start)) + + ISequential + + IIterable + (-iterator [_] + (.create TransformerIterator xform (iter coll))) + + ISeqable + (-seq [_] (seq (sequence xform coll))) + + IReduce + (-reduce [_ f] (transduce xform (completing f) coll)) + (-reduce [_ f init] (transduce xform (completing f) init coll)) + + IPrintWithWriter + (-pr-writer [coll writer opts] + (pr-sequential-writer writer pr-writer "(" " " ")" opts coll))) + +(es6-iterable Eduction) + +(defn eduction + "Returns a reducible/iterable application of the transducers + to the items in coll. Transducers are applied in order as if + combined with comp. Note that these applications will be + performed every time reduce/iterator is called." + {:arglists '([xform* coll])} + [& xforms] + (Eduction. (apply comp (butlast xforms)) (last xforms))) + +(defn run! + "Runs the supplied procedure (via reduce), for purposes of side + effects, on successive items in the collection. Returns nil" + [proc coll] + (reduce #(proc %2) nil coll) + nil) + +(defprotocol IEncodeJS + (-clj->js [x] "Recursively transforms clj values to JavaScript") + (-key->js [x] "Transforms map keys to valid JavaScript keys. Arbitrary keys are + encoded to their string representation via (pr-str x)")) + +(declare clj->js) + +(defn key->js + ([k] (key->js k clj->js)) + ([k primitive-fn] + (cond + (satisfies? IEncodeJS k) (-clj->js k) + (or (string? k) + (number? k) + (keyword? k) + (symbol? k)) (primitive-fn k) + :default (pr-str k)))) + +(defn clj->js + "Recursively transforms ClojureScript values to JavaScript. + sets/vectors/lists become Arrays, Keywords and Symbol become Strings, + Maps become Objects. Arbitrary keys are encoded to by `key->js`. + Options is a key-value pair, where the only valid key is + :keyword-fn, which should point to a single-argument function to be + called on keyword keys. Default to `name`." + [x & {:keys [keyword-fn] + :or {keyword-fn name} + :as options}] + (letfn [(keyfn [k] (key->js k thisfn)) + (thisfn [x] (cond + (nil? x) nil + (satisfies? IEncodeJS x) (-clj->js x) + (keyword? x) (keyword-fn x) + (symbol? x) (str x) + (map? x) (let [m (js-obj)] + (doseq [[k v] x] + (gobject/set m (keyfn k) (thisfn v))) + m) + (coll? x) (let [arr (array)] + (doseq [x (map thisfn x)] + (.push arr x)) + arr) + :else x))] + (thisfn x))) + + +(defprotocol IEncodeClojure + (-js->clj [x options] "Transforms JavaScript values to Clojure")) + +(defn js->clj + "Recursively transforms JavaScript arrays into ClojureScript + vectors, and JavaScript objects into ClojureScript maps. With + option ':keywordize-keys true' will convert object fields from + strings to keywords." + ([x] (js->clj x :keywordize-keys false)) + ([x & opts] + (let [{:keys [keywordize-keys]} opts + keyfn (if keywordize-keys keyword str) + f (fn thisfn [x] + (cond + (satisfies? IEncodeClojure x) + (-js->clj x (apply array-map opts)) + + (seq? x) + (doall (map thisfn x)) + + (map-entry? x) + (MapEntry. (thisfn (key x)) (thisfn (val x)) nil) + + (coll? x) + (into (empty x) (map thisfn x)) + + (array? x) + (vec (map thisfn x)) + + (identical? (type x) js/Object) + (into {} (for [k (js-keys x)] + [(keyfn k) (thisfn (unchecked-get x k))])) + + :else x))] + (f x)))) + +(defn memoize + "Returns a memoized version of a referentially transparent function. The + memoized version of the function keeps a cache of the mapping from arguments + to results and, when calls with the same arguments are repeated often, has + higher performance at the expense of higher memory use." + [f] + (let [mem (atom {})] + (fn [& args] + (let [v (get @mem args lookup-sentinel)] + (if (identical? v lookup-sentinel) + (let [ret (apply f args)] + (swap! mem assoc args ret) + ret) + v))))) + +(defn trampoline + "trampoline can be used to convert algorithms requiring mutual + recursion without stack consumption. Calls f with supplied args, if + any. If f returns a fn, calls that fn with no arguments, and + continues to repeat, until the return value is not a fn, then + returns that non-fn value. Note that if you want to return a fn as a + final value, you must wrap it in some data structure and unpack it + after trampoline returns." + ([f] + (let [ret (f)] + (if (fn? ret) + (recur ret) + ret))) + ([f & args] + (trampoline #(apply f args)))) + +(defn rand + "Returns a random floating point number between 0 (inclusive) and + n (default 1) (exclusive)." + ([] (rand 1)) + ([n] (* (Math/random) n))) + +(defn rand-int + "Returns a random integer between 0 (inclusive) and n (exclusive)." + [n] (Math/floor (* (Math/random) n))) + +(defn rand-nth + "Return a random element of the (sequential) collection. Will have + the same performance characteristics as nth for the given + collection." + [coll] + (nth coll (rand-int (count coll)))) + +(defn group-by + "Returns a map of the elements of coll keyed by the result of + f on each element. The value at each key will be a vector of the + corresponding elements, in the order they appeared in coll." + [f coll] + (persistent! + (reduce + (fn [ret x] + (let [k (f x)] + (assoc! ret k (conj (get ret k []) x)))) + (transient {}) coll))) + +(defn make-hierarchy + "Creates a hierarchy object for use with derive, isa? etc." + [] {:parents {} :descendants {} :ancestors {}}) + +(def + ^{:private true + :jsdoc ["@type {*}"]} + -global-hierarchy nil) + +(defn- get-global-hierarchy [] + (when (nil? -global-hierarchy) + (set! -global-hierarchy (atom (make-hierarchy)))) + -global-hierarchy) + +(defn- swap-global-hierarchy! [f & args] + (apply swap! (get-global-hierarchy) f args)) + +(defn ^boolean isa? + "Returns true if (= child parent), or child is directly or indirectly derived from + parent, either via a JavaScript type inheritance relationship or a + relationship established via derive. h must be a hierarchy obtained + from make-hierarchy, if not supplied defaults to the global + hierarchy" + ([child parent] (isa? @(get-global-hierarchy) child parent)) + ([h child parent] + (or (= child parent) + ;; (and (class? parent) (class? child) + ;; (. ^Class parent isAssignableFrom child)) + (contains? ((:ancestors h) child) parent) + ;;(and (class? child) (some #(contains? ((:ancestors h) %) parent) (supers child))) + (and (vector? parent) (vector? child) + (== (count parent) (count child)) + (loop [ret true i 0] + (if (or (not ret) (== i (count parent))) + ret + (recur (isa? h (child i) (parent i)) (inc i)))))))) + +(defn parents + "Returns the immediate parents of tag, either via a JavaScript type + inheritance relationship or a relationship established via derive. h + must be a hierarchy obtained from make-hierarchy, if not supplied + defaults to the global hierarchy" + ([tag] (parents @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:parents h) tag)))) + +(defn ancestors + "Returns the immediate and indirect parents of tag, either via a JavaScript type + inheritance relationship or a relationship established via derive. h + must be a hierarchy obtained from make-hierarchy, if not supplied + defaults to the global hierarchy" + ([tag] (ancestors @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:ancestors h) tag)))) + +(defn descendants + "Returns the immediate and indirect children of tag, through a + relationship established via derive. h must be a hierarchy obtained + from make-hierarchy, if not supplied defaults to the global + hierarchy. Note: does not work on JavaScript type inheritance + relationships." + ([tag] (descendants @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:descendants h) tag)))) + +(defn derive + "Establishes a parent/child relationship between parent and + tag. Parent must be a namespace-qualified symbol or keyword and + child can be either a namespace-qualified symbol or keyword or a + class. h must be a hierarchy obtained from make-hierarchy, if not + supplied defaults to, and modifies, the global hierarchy." + ([tag parent] + (assert (namespace parent)) + ;; (assert (or (class? tag) (and (instance? cljs.core.Named tag) (namespace tag)))) + (swap-global-hierarchy! derive tag parent) nil) + ([h tag parent] + (assert (not= tag parent)) + ;; (assert (or (class? tag) (instance? clojure.lang.Named tag))) + ;; (assert (instance? clojure.lang.INamed tag)) + ;; (assert (instance? clojure.lang.INamed parent)) + (let [tp (:parents h) + td (:descendants h) + ta (:ancestors h) + tf (fn [m source sources target targets] + (reduce (fn [ret k] + (assoc ret k + (reduce conj (get targets k #{}) (cons target (targets target))))) + m (cons source (sources source))))] + (or + (when-not (contains? (tp tag) parent) + (when (contains? (ta tag) parent) + (throw (js/Error. (str tag "already has" parent "as ancestor")))) + (when (contains? (ta parent) tag) + (throw (js/Error. (str "Cyclic derivation:" parent "has" tag "as ancestor")))) + {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent)) + :ancestors (tf (:ancestors h) tag td parent ta) + :descendants (tf (:descendants h) parent ta tag td)}) + h)))) + +(defn underive + "Removes a parent/child relationship between parent and + tag. h must be a hierarchy obtained from make-hierarchy, if not + supplied defaults to, and modifies, the global hierarchy." + ([tag parent] + (swap-global-hierarchy! underive tag parent) + nil) + ([h tag parent] + (let [parentMap (:parents h) + childsParents (if (parentMap tag) + (disj (parentMap tag) parent) #{}) + newParents (if (not-empty childsParents) + (assoc parentMap tag childsParents) + (dissoc parentMap tag)) + deriv-seq (flatten (map #(cons (first %) (interpose (first %) (second %))) + (seq newParents)))] + (if (contains? (parentMap tag) parent) + (reduce #(apply derive %1 %2) (make-hierarchy) + (partition 2 deriv-seq)) + h)))) + +(defn- reset-cache + [method-cache method-table cached-hierarchy hierarchy] + (swap! method-cache (fn [_] (deref method-table))) + (swap! cached-hierarchy (fn [_] (deref hierarchy)))) + +(defn- prefers* + [x y prefer-table] + (let [xprefs (@prefer-table x)] + (or + (when (and xprefs (xprefs y)) + true) + (loop [ps (parents y)] + (when (pos? (count ps)) + (when (prefers* x (first ps) prefer-table) + true) + (recur (rest ps)))) + (loop [ps (parents x)] + (when (pos? (count ps)) + (when (prefers* (first ps) y prefer-table) + true) + (recur (rest ps)))) + false))) + +(defn- dominates + [x y prefer-table hierarchy] + (or (prefers* x y prefer-table) (isa? hierarchy x y))) + +(defn- find-and-cache-best-method + [name dispatch-val hierarchy method-table prefer-table method-cache cached-hierarchy default-dispatch-val] + (let [best-entry (reduce (fn [be [k _ :as e]] + (if (isa? @hierarchy dispatch-val k) + (let [be2 (if (or (nil? be) (dominates k (first be) prefer-table @hierarchy)) + e + be)] + (when-not (dominates (first be2) k prefer-table @hierarchy) + (throw (js/Error. + (str "Multiple methods in multimethod '" name + "' match dispatch value: " dispatch-val " -> " k + " and " (first be2) ", and neither is preferred")))) + be2) + be)) + nil @method-table) + best-entry (if-let [entry (and (nil? best-entry) (@method-table default-dispatch-val))] + [default-dispatch-val entry] + best-entry)] + (when best-entry + (if (= @cached-hierarchy @hierarchy) + (do + (swap! method-cache assoc dispatch-val (second best-entry)) + (second best-entry)) + (do + (reset-cache method-cache method-table cached-hierarchy hierarchy) + (find-and-cache-best-method name dispatch-val hierarchy method-table prefer-table + method-cache cached-hierarchy default-dispatch-val)))))) + +(defprotocol IMultiFn + (-reset [mf]) + (-add-method [mf dispatch-val method]) + (-remove-method [mf dispatch-val]) + (-prefer-method [mf dispatch-val dispatch-val-y]) + (-get-method [mf dispatch-val]) + (-methods [mf]) + (-prefers [mf]) + (-default-dispatch-val [mf]) + (-dispatch-fn [mf])) + +(defn- throw-no-method-error [name dispatch-val] + (throw (js/Error. (str "No method in multimethod '" name "' for dispatch value: " dispatch-val)))) + +(deftype MultiFn [name dispatch-fn default-dispatch-val hierarchy + method-table prefer-table method-cache cached-hierarchy] + IFn + (-invoke [mf] + (let [dispatch-val (dispatch-fn) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn))) + (-invoke [mf a] + (let [dispatch-val (dispatch-fn a) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a))) + (-invoke [mf a b] + (let [dispatch-val (dispatch-fn a b) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b))) + (-invoke [mf a b c] + (let [dispatch-val (dispatch-fn a b c) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c))) + (-invoke [mf a b c d] + (let [dispatch-val (dispatch-fn a b c d) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d))) + (-invoke [mf a b c d e] + (let [dispatch-val (dispatch-fn a b c d e) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e))) + (-invoke [mf a b c d e f] + (let [dispatch-val (dispatch-fn a b c d e f) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f))) + (-invoke [mf a b c d e f g] + (let [dispatch-val (dispatch-fn a b c d e f g) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g))) + (-invoke [mf a b c d e f g h] + (let [dispatch-val (dispatch-fn a b c d e f g h) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h))) + (-invoke [mf a b c d e f g h i] + (let [dispatch-val (dispatch-fn a b c d e f g h i) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i))) + (-invoke [mf a b c d e f g h i j] + (let [dispatch-val (dispatch-fn a b c d e f g h i j) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j))) + (-invoke [mf a b c d e f g h i j k] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k))) + (-invoke [mf a b c d e f g h i j k l] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l))) + (-invoke [mf a b c d e f g h i j k l m] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m))) + (-invoke [mf a b c d e f g h i j k l m n] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n))) + (-invoke [mf a b c d e f g h i j k l m n o] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n o) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n o))) + (-invoke [mf a b c d e f g h i j k l m n o p] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n o p) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n o p))) + (-invoke [mf a b c d e f g h i j k l m n o p q] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n o p q) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n o p q))) + (-invoke [mf a b c d e f g h i j k l m n o p q r] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n o p q r) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n o p q r))) + (-invoke [mf a b c d e f g h i j k l m n o p q r s] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n o p q r s) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n o p q r s))) + (-invoke [mf a b c d e f g h i j k l m n o p q r s t] + (let [dispatch-val (dispatch-fn a b c d e f g h i j k l m n o p q r s t) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (target-fn a b c d e f g h i j k l m n o p q r s t))) + (-invoke [mf a b c d e f g h i j k l m n o p q r s t rest] + (let [dispatch-val (apply dispatch-fn a b c d e f g h i j k l m n o p q r s t rest) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw-no-method-error name dispatch-val)) + (apply target-fn a b c d e f g h i j k l m n o p q r s t rest))) + + IMultiFn + (-reset [mf] + (swap! method-table (fn [mf] {})) + (swap! method-cache (fn [mf] {})) + (swap! prefer-table (fn [mf] {})) + (swap! cached-hierarchy (fn [mf] nil)) + mf) + + (-add-method [mf dispatch-val method] + (swap! method-table assoc dispatch-val method) + (reset-cache method-cache method-table cached-hierarchy hierarchy) + mf) + + (-remove-method [mf dispatch-val] + (swap! method-table dissoc dispatch-val) + (reset-cache method-cache method-table cached-hierarchy hierarchy) + mf) + + (-get-method [mf dispatch-val] + (when-not (= @cached-hierarchy @hierarchy) + (reset-cache method-cache method-table cached-hierarchy hierarchy)) + (if-let [target-fn (@method-cache dispatch-val)] + target-fn + (find-and-cache-best-method name dispatch-val hierarchy method-table + prefer-table method-cache cached-hierarchy default-dispatch-val))) + + (-prefer-method [mf dispatch-val-x dispatch-val-y] + (when (prefers* dispatch-val-x dispatch-val-y prefer-table) + (throw (js/Error. (str "Preference conflict in multimethod '" name "': " dispatch-val-y + " is already preferred to " dispatch-val-x)))) + (swap! prefer-table + (fn [old] + (assoc old dispatch-val-x + (conj (get old dispatch-val-x #{}) + dispatch-val-y)))) + (reset-cache method-cache method-table cached-hierarchy hierarchy)) + + (-methods [mf] @method-table) + (-prefers [mf] @prefer-table) + (-default-dispatch-val [mf] default-dispatch-val) + (-dispatch-fn [mf] dispatch-fn) + + INamed + (-name [this] (-name name)) + (-namespace [this] (-namespace name)) + + IHash + (-hash [this] (goog/getUid this))) + +(defn remove-all-methods + "Removes all of the methods of multimethod." + [multifn] + (-reset multifn)) + +(defn remove-method + "Removes the method of multimethod associated with dispatch-value." + [multifn dispatch-val] + (-remove-method multifn dispatch-val)) + +(defn prefer-method + "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y + when there is a conflict" + [multifn dispatch-val-x dispatch-val-y] + (-prefer-method multifn dispatch-val-x dispatch-val-y)) + +(defn methods + "Given a multimethod, returns a map of dispatch values -> dispatch fns" + [multifn] (-methods multifn)) + +(defn get-method + "Given a multimethod and a dispatch value, returns the dispatch fn + that would apply to that value, or nil if none apply and no default" + [multifn dispatch-val] (-get-method multifn dispatch-val)) + +(defn prefers + "Given a multimethod, returns a map of preferred value -> set of other values" + [multifn] (-prefers multifn)) + +(defn default-dispatch-val + "Given a multimethod, return it's default-dispatch-val." + [multifn] (-default-dispatch-val multifn)) + +(defn dispatch-fn + "Given a multimethod, return it's dispatch-fn." + [multifn] (-dispatch-fn multifn)) + +;; UUID +(defprotocol IUUID "A marker protocol for UUIDs") + +(deftype UUID [uuid ^:mutable __hash] + IUUID + + Object + (toString [_] uuid) + (equiv [this other] + (-equiv this other)) + + IEquiv + (-equiv [_ other] + (and (instance? UUID other) (identical? uuid (.-uuid other)))) + + IPrintWithWriter + (-pr-writer [_ writer _] + (-write writer (str "#uuid \"" uuid "\""))) + + IHash + (-hash [this] + (when (nil? __hash) + (set! __hash (hash uuid))) + __hash) + + IComparable + (-compare [_ other] + (garray/defaultCompare uuid (.-uuid other)))) + +(defn uuid [s] + (assert (string? s)) + (UUID. (.toLowerCase s) nil)) + +(defn random-uuid [] + (letfn [(hex [] (.toString (rand-int 16) 16))] + (let [rhex (.toString (bit-or 0x8 (bit-and 0x3 (rand-int 16))) 16)] + (uuid + (str (hex) (hex) (hex) (hex) + (hex) (hex) (hex) (hex) "-" + (hex) (hex) (hex) (hex) "-" + "4" (hex) (hex) (hex) "-" + rhex (hex) (hex) (hex) "-" + (hex) (hex) (hex) (hex) + (hex) (hex) (hex) (hex) + (hex) (hex) (hex) (hex)))))) + +(defn ^boolean uuid? + [x] (implements? IUUID x)) + +;;; ExceptionInfo + +(defn- pr-writer-ex-info [obj writer opts] + (-write writer "#error {:message ") + (pr-writer (.-message obj) writer opts) + (when (.-data obj) + (-write writer ", :data ") + (pr-writer (.-data obj) writer opts)) + (when (.-cause obj) + (-write writer ", :cause ") + (pr-writer (.-cause obj) writer opts)) + (-write writer "}")) + +(defn ^{:jsdoc ["@constructor"]} + ExceptionInfo [message data cause] + (let [e (js/Error. message)] + (this-as this + (set! (.-message this) message) + (set! (.-data this) data) + (set! (.-cause this) cause) + (do + (set! (.-name this) (.-name e)) + ;; non-standard + (set! (.-description this) (.-description e)) + (set! (.-number this) (.-number e)) + (set! (.-fileName this) (.-fileName e)) + (set! (.-lineNumber this) (.-lineNumber e)) + (set! (.-columnNumber this) (.-columnNumber e)) + (set! (.-stack this) (.-stack e))) + this))) + +(set! (.. ExceptionInfo -prototype -__proto__) js/Error.prototype) + +(extend-type ExceptionInfo + IPrintWithWriter + (-pr-writer [obj writer opts] + (pr-writer-ex-info obj writer opts))) + +(set! (.. ExceptionInfo -prototype -toString) + (fn [] + (this-as this (pr-str* this)))) + +(defn ex-info + "Create an instance of ExceptionInfo, an Error type that carries a + map of additional data." + ([msg data] (ex-info msg data nil)) + ([msg data cause] + (ExceptionInfo. msg data cause))) + +(defn ex-data + "Returns exception data (a map) if ex is an ExceptionInfo. + Otherwise returns nil." + [ex] + (when (instance? ExceptionInfo ex) + (.-data ex))) + +(defn ex-message + "Returns the message attached to the given Error / ExceptionInfo object. + For non-Errors returns nil." + [ex] + (when (instance? js/Error ex) + (.-message ex))) + +(defn ex-cause + "Returns exception cause (an Error / ExceptionInfo) if ex is an + ExceptionInfo. + Otherwise returns nil." + [ex] + (when (instance? ExceptionInfo ex) + (.-cause ex))) + +(defn comparator + "Returns an JavaScript compatible comparator based upon pred." + [pred] + (fn [x y] + (cond (pred x y) -1 (pred y x) 1 :else 0))) + +(defn ^boolean special-symbol? + "Returns true if x names a special form" + [x] + (contains? + '#{if def fn* do let* loop* letfn* throw try catch finally + recur new set! ns deftype* defrecord* . js* & quote case* var ns*} + x)) + +(defn test + "test [v] finds fn at key :test in var metadata and calls it, + presuming failure will throw exception" + [v] + (let [f (.-cljs$lang$test v)] + (if f + (do (f) :ok) + :no-test))) + + +(deftype TaggedLiteral [tag form] + Object + (toString [coll] + (pr-str* coll)) + + IEquiv + (-equiv [this other] + (and (instance? TaggedLiteral other) + (= tag (.-tag other)) + (= form (.-form other)))) + + IHash + (-hash [this] + (+ (* 31 (hash tag)) + (hash form))) + + ILookup + (-lookup [this v] + (-lookup this v nil)) + (-lookup [this v not-found] + (case v + :tag tag + :form form + not-found)) + + IPrintWithWriter + (-pr-writer [o writer opts] + (-write writer (str "#" tag " ")) + (pr-writer form writer opts))) + +(defn ^boolean tagged-literal? + "Return true if the value is the data representation of a tagged literal" + [value] + (instance? TaggedLiteral value)) + +(defn tagged-literal + "Construct a data representation of a tagged literal from a + tag symbol and a form." + [tag form] + {:pre [(symbol? tag)]} + (TaggedLiteral. tag form)) + +(def + ^{:private true + :jsdoc ["@type {*}"]} + js-reserved-arr + #js ["arguments" "abstract" "await" "boolean" "break" "byte" "case" + "catch" "char" "class" "const" "continue" + "debugger" "default" "delete" "do" "double" + "else" "enum" "export" "extends" "final" + "finally" "float" "for" "function" "goto" "if" + "implements" "import" "in" "instanceof" "int" + "interface" "let" "long" "native" "new" + "package" "private" "protected" "public" + "return" "short" "static" "super" "switch" + "synchronized" "this" "throw" "throws" + "transient" "try" "typeof" "var" "void" + "volatile" "while" "with" "yield" "methods" + "null" "constructor"]) + +(def + ^{:jsdoc ["@type {null|Object}"]} + js-reserved nil) + +(defn- js-reserved? [x] + (when (nil? js-reserved) + (set! js-reserved + (reduce #(do (gobject/set %1 %2 true) %1) + #js {} js-reserved-arr))) + (.hasOwnProperty js-reserved x)) + +(defn- demunge-pattern [] + (when-not DEMUNGE_PATTERN + (set! DEMUNGE_PATTERN + (let [ks (sort (fn [a b] (- (. b -length) (. a -length))) + (js-keys DEMUNGE_MAP))] + (loop [ks ks ret ""] + (if (seq ks) + (recur + (next ks) + (str + (cond-> ret + (not (identical? ret "")) (str "|")) + (first ks))) + (str ret "|\\$")))))) + DEMUNGE_PATTERN) + +(defn- munge-str [name] + (let [sb (StringBuffer.)] + (loop [i 0] + (if (< i (. name -length)) + (let [c (.charAt name i) + sub (gobject/get CHAR_MAP c)] + (if-not (nil? sub) + (.append sb sub) + (.append sb c)) + (recur (inc i))))) + (.toString sb))) + +(defn munge [name] + (let [name' (munge-str (str name)) + name' (cond + (identical? name' "..") "_DOT__DOT_" + (js-reserved? name') (str name' "$") + :else name')] + (if (symbol? name) + (symbol name') + name'))) + +(defn- demunge-str [munged-name] + (let [r (js/RegExp. (demunge-pattern) "g") + munged-name (if (gstring/endsWith munged-name "$") + (.substring munged-name 0 (dec (. munged-name -length))) + munged-name)] + (loop [ret "" last-match-end 0] + (if-let [match (.exec r munged-name)] + (let [[x] match] + (recur + (str ret + (.substring munged-name last-match-end + (- (. r -lastIndex) (. x -length))) + (if (identical? x "$") "/" (gobject/get DEMUNGE_MAP x))) + (. r -lastIndex))) + (str ret + (.substring munged-name last-match-end (.-length munged-name))))))) + +(defn demunge [name] + ((if (symbol? name) symbol str) + (let [name' (str name)] + (if (identical? name' "_DOT__DOT_") + ".." + (demunge-str name'))))) + +(defonce ^{:jsdoc ["@type {*}"] :private true} + tapset nil) + +(defn- maybe-init-tapset [] + (when (nil? tapset) + (set! tapset (atom #{})))) + +(defn add-tap + "Adds f, a fn of one argument, to the tap set. This function will be called with + anything sent via tap>. Remember f in order to remove-tap" + [f] + (maybe-init-tapset) + (swap! tapset conj f) + nil) + +(defn remove-tap + "Remove f from the tap set." + [f] + (maybe-init-tapset) + (swap! tapset disj f) + nil) + +(defn ^boolean tap> + "Sends x to any taps. Returns the result of *exec-tap-fn*, a Boolean value." + [x] + (maybe-init-tapset) + (*exec-tap-fn* + (fn [] + (doseq [tap @tapset] + (try + (tap x) + (catch js/Error ex)))))) + +;; ----------------------------------------------------------------------------- +;; Bootstrap helpers - incompatible with advanced compilation + +(defn- ns-lookup + "Bootstrap only." + [ns-obj k] + (fn [] (gobject/get ns-obj k))) + +;; Bootstrap only +(deftype Namespace [obj name] + Object + (findInternedVar [this sym] + (let [k (munge (str sym))] + (when ^boolean (gobject/containsKey obj k) + (let [var-sym (symbol (str name) (str sym)) + var-meta {:ns this}] + (Var. (ns-lookup obj k) var-sym var-meta))))) + (getName [_] name) + (toString [_] + (str name)) + IEquiv + (-equiv [_ other] + (if (instance? Namespace other) + (= name (.-name other)) + false)) + IHash + (-hash [_] + (hash name))) + +(def + ^{:doc "Bootstrap only." :jsdoc ["@type {*}"]} + NS_CACHE nil) + +(defn- find-ns-obj* + "Bootstrap only." + [ctxt xs] + (cond + (nil? ctxt) nil + (nil? xs) ctxt + :else (recur (gobject/get ctxt (first xs)) (next xs)))) + +(defn find-ns-obj + "Bootstrap only." + [ns] + (let [munged-ns (munge (str ns)) + segs (.split munged-ns ".")] + (case *target* + "nodejs" (if ^boolean js/COMPILED + ; Under simple optimizations on nodejs, namespaces will be in module + ; rather than global scope and must be accessed by a direct call to eval. + ; The first segment may refer to an undefined variable, so its evaluation + ; may throw ReferenceError. + (find-ns-obj* + (try + (let [ctxt (js/eval (first segs))] + (when (and ctxt (object? ctxt)) + ctxt)) + (catch js/ReferenceError e + nil)) + (next segs)) + (find-ns-obj* goog/global segs)) + ("default" "webworker") (find-ns-obj* goog/global segs) + (throw (js/Error. (str "find-ns-obj not supported for target " *target*)))))) + +(defn ns-interns* + "Returns a map of the intern mappings for the namespace. + Bootstrap only." + [sym] + (let [ns-obj (find-ns-obj sym) + ns (Namespace. ns-obj sym)] + (letfn [(step [ret k] + (let [var-sym (symbol (demunge k))] + (assoc ret + var-sym (Var. #(gobject/get ns-obj k) + (symbol (str sym) (str var-sym)) {:ns ns}))))] + (reduce step {} (js-keys ns-obj))))) + +(defn create-ns + "Create a new namespace named by the symbol. Bootstrap only." + ([sym] + (create-ns sym (find-ns-obj sym))) + ([sym ns-obj] + (Namespace. ns-obj sym))) + +(defn find-ns + "Returns the namespace named by the symbol or nil if it doesn't exist. + Bootstrap only." + [ns] + (when (nil? NS_CACHE) + (set! NS_CACHE (atom {}))) + (let [the-ns (get @NS_CACHE ns)] + (if-not (nil? the-ns) + the-ns + (let [ns-obj (find-ns-obj ns)] + (when-not (nil? ns-obj) + (let [new-ns (create-ns ns ns-obj)] + (swap! NS_CACHE assoc ns new-ns) + new-ns)))))) + +(defn find-macros-ns + "Returns the macros namespace named by the symbol or nil if it doesn't exist. + Bootstrap only." + [ns] + (when (nil? NS_CACHE) + (set! NS_CACHE (atom {}))) + (let [ns-str (str ns) + ns (if (not ^boolean (gstring/contains ns-str "$macros")) + (symbol (str ns-str "$macros")) + ns) + the-ns (get @NS_CACHE ns)] + (if-not (nil? the-ns) + the-ns + (let [ns-obj (find-ns-obj ns)] + (when-not (nil? ns-obj) + (let [new-ns (create-ns ns ns-obj)] + (swap! NS_CACHE assoc ns new-ns) + new-ns)))))) + +(defn ns-name + "Returns the name of the namespace, a Namespace object. + Bootstrap only." + [ns-obj] + (.-name ns-obj)) + +(defn uri? + "Returns true x is a goog.Uri instance." + {:added "1.9"} + [x] + (instance? goog.Uri x)) + +(defn- maybe-enable-print! [] + (cond + (exists? js/console) + (enable-console-print!) + + (identical? *target* "nashorn") + (let [system (.type js/Java "java.lang.System")] + (set! *print-newline* false) + (set-print-fn! + (fn [] + (let [xs (js-arguments) + s (.join (garray/clone xs) "")] + (.println (.-out system) s)))) + (set-print-err-fn! + (fn [] + (let [xs (js-arguments) + s (.join (garray/clone xs) "")] + (.println (.-error system) s))))))) + +(maybe-enable-print!) + +(defonce + ^{:doc "Runtime environments may provide a way to evaluate ClojureScript + forms. Whatever function *eval* is bound to will be passed any forms which + should be evaluated." :dynamic true} + *eval* + (fn [_] + (throw (js/Error. "cljs.core/*eval* not bound")))) + +(defn eval + "Evaluates the form data structure (not text!) and returns the result. + Delegates to cljs.core/*eval*. Intended for use in self-hosted ClojureScript, + which sets up an implementation of cljs.core/*eval* for that environment." + [form] + (*eval* form)) diff --git a/js/cljs/core.cljs.cache.json b/js/cljs/core.cljs.cache.json new file mode 100644 index 0000000..8b89980 --- /dev/null +++ b/js/cljs/core.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$console",["^ ","~$log",["^ ","~$apply",["^ "]],"~$error",["^ ","^5",["^ "]]],"~$ReferenceError",["^ "],"~$Error",["^ ","~$prototype",["^ ","~$name",["^ "],"~$description",["^ "],"~$number",["^ "],"~$fileName",["^ "],"~$lineNumber",["^ "],"~$columnNumber",["^ "],"~$stack",["^ "]]],"~$Object",["^ ","~$out",["^ ","~$println",["^ "]],"^6",["^ ","^C",["^ "]]],"~$isFinite",["^ "],"~$Symbol",["^ ","~$iterator",["^ "]],"~$Infinity",["^ "],"~$String",["^ ","~$fromCharCode",["^ "]],"~$eval",["^ "],"~$Array",["^ ","~$isArray",["^ "]],"~$parseInt",["^ "],"~$TypeError",["^ "],"~$isNaN",["^ "],"~$parseFloat",["^ "],"~$performance",["^ ","~$now",["^ "]],"~$process",["^ ","~$hrtime",["^ "]],"~$setTimeout",["^ "],"~$Number",["^ ","~$POSITIVE_INFINITY",["^ "],"~$NEGATIVE_INFINITY",["^ "],"~$MAX_VALUE",["^ "]],"~$RegExp",["^ ","^9",["^ ","~$exec",["^ "],"~$lastIndex",["^ "]]],"~$Date",["^ ","^9",["^ ","~$getTime",["^ "],"~$valueOf",["^ "]]],"~$Java",["^ ","~$type",["^ "]],"~$COMPILED",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",[]],"~:name","~$cljs.core","~:imports",["^ ","~$StringBuffer","~$goog.string.StringBuffer"],"~:requires",["^ ","~$gstring","~$goog.string","^1A","^1A","~$goog.Uri","^1B","~$garray","~$goog.array","~$goog.object","^1E","~$goog.math.Integer","^1F","^1=","^1>","~$gobject","^1E","^1D","^1D","~$goog.math.Long","^1H"],"~:cljs.spec/speced-vars",[],"~:uses",null,"~:defs",["^ ","~$->PersistentHashSet",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:protocols",["^19",["~$cljs.core/IEquiv","~$cljs.core/IHash","~$cljs.core/IFn","~$cljs.core/ICollection","~$cljs.core/IEditableCollection","~$cljs.core/Object","~$cljs.core/ISet","~$cljs.core/IEmptyableCollection","~$cljs.core/ICounted","~$cljs.core/ISeqable","~$cljs.core/IMeta","~$cljs.core/ICloneable","~$cljs.core/IIterable","~$cljs.core/IWithMeta","~$cljs.core/ILookup"]],"~:file","cljs/core.cljs","~:end-column",27,"~:column",10,"~:factory","~:positional","~:line",9042,"~:end-line",9042,"~:arglists",["~#list",["~$quote",["^2;",[["~$meta","~$hash-map","~$__hash"]]]]],"~:skip-protocol-flag",["^19",["^1P","^1Q","^1R","^1S","^1T","^1V","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^22"]],"~:doc","Positional factory function for cljs.core/PersistentHashSet."],"^1O",["^19",["^1P","^1Q","^1R","^1S","^1T","^1U","^1V","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^22"]],"^1:","~$cljs.core/->PersistentHashSet","~:variadic",false,"^23","cljs/core.cljs","^24",27,"~:method-params",["^2;",[["^2=","^2>","^2?"]]],"~:protocol-impl",null,"~:arglists-meta",["^2;",[null,null]],"^25",1,"^26","^27","^28",9042,"^29",9042,"~:max-fixed-arity",3,"~:fn-var",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^2>","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1R","^1S","^1T","^1V","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^22"]],"^2A","Positional factory function for cljs.core/PersistentHashSet."],"~$js->clj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10564,"^25",7,"^29",10564,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$&","~$opts"]]]]],"^2A","Recursively transforms JavaScript arrays into ClojureScript\n vectors, and JavaScript objects into ClojureScript maps. With\n option ':keywordize-keys true' will convert object fields from\n strings to keywords.","~:top-fn",["^ ","^2C",true,"^2G",1,"^2D",["^2;",[["~$x"]]],"^2:",["^2;",[["~$x"],["~$x","~$&","^2J"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/js->clj","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",1,"^2D",["^2;",[["~$x"]]],"^2:",["^2;",[["~$x"],["~$x","~$&","^2J"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10564,"^29",10564,"^2G",1,"^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$&","^2J"]]],"^2A","Recursively transforms JavaScript arrays into ClojureScript\n vectors, and JavaScript objects into ClojureScript maps. With\n option ':keywordize-keys true' will convert object fields from\n strings to keywords."],"~$sort-by",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2428,"^25",7,"^29",2428,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$keyfn","~$coll"],["^2N","~$comp","^2O"]]]]],"^2A","Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). Comp can be\n boolean-valued comparison function, or a -/0/+ valued comparator.\n Comp defaults to compare.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2N","^2O"],["^2N","^2P","^2O"]]],"^2:",["^2;",[["^2N","^2O"],["^2N","^2P","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/sort-by","^2C",false,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2N","^2O"],["^2N","^2P","^2O"]]],"^2:",["^2;",[["^2N","^2O"],["^2N","^2P","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2N","^2O"],["^2N","^2P","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2428,"^29",2428,"^2G",3,"^2H",true,"^2:",["^2;",[["^2N","^2O"],["^2N","^2P","^2O"]]],"^2A","Returns a sorted sequence of the items in coll, where the sort\n order is determined by comparing (keyfn item). Comp can be\n boolean-valued comparison function, or a -/0/+ valued comparator.\n Comp defaults to compare."],"~$ITransientAssociative",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",793,"^25",14,"^29",793,"^24",35,"^2A","Protocol for adding associativity to transient collections.","~:protocol-symbol",true,"~:jsdoc",["^2;",["@interface"]],"~:protocol-info",["^ ","~:methods",["^ ","~$-assoc!",[["~$tcoll","~$key","~$val"]]]]],"^2S",true,"^1:","~$cljs.core/ITransientAssociative","^23","cljs/core.cljs","^24",35,"^25",1,"^28",793,"^2U",["^ ","^2V",["^ ","^2W",[["^2X","^2Y","^2Z"]]]],"~:info",null,"^29",793,"~:tag","~$any","~:impls",["^19",["~$cljs.core/TransientVector","~$cljs.core/TransientHashMap","~$cljs.core/TransientArrayMap"]],"^2A","Protocol for adding associativity to transient collections.","^2T",["^2;",["@interface"]]],"~$chunk-first",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3596,"^25",7,"^29",3596,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"^1:","~$cljs.core/chunk-first","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3596,"^29",3596,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"~$print-meta?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9907,"^25",16,"^29",9907,"^24",27,"^31","~$boolean","^2:",["^2;",["^2<",["^2;",[["^2J","~$obj"]]]]]],"^1:","~$cljs.core/print-meta?","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2J","^3;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9907,"~:ret-tag","^3:","^29",9907,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2J","^3;"]]]]]],"~$m3-hash-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",929,"^25",15,"^29",929,"^24",26,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$in"]]]]]],"^1:","~$cljs.core/m3-hash-int","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["^3?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",929,"^3=","^<","^29",929,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3?"]]]]]],"~$pr-str*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",877,"^25",7,"^29",877,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^3;"]]]]],"^2A","Support so that collections can implement toString without\n loading all the printing machinery."],"^1:","~$cljs.core/pr-str*","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^3;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",877,"^29",877,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;"]]]]],"^2A","Support so that collections can implement toString without\n loading all the printing machinery."],"~$eduction",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10499,"^25",7,"^29",10499,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$xform*","^2O"]]]]],"^2A","Returns a reducible/iterable application of the transducers\n to the items in coll. Transducers are applied in order as if\n combined with comp. Note that these applications will be\n performed every time reduce/iterator is called.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["~$xforms"]]],"^2:",["^2;",[["~$&","^3E"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/eduction","^2C",true,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^3E"]]],"^2:",["^2;",[["~$&","^3E"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^3E"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10499,"^29",10499,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^3E"]]],"^2A","Returns a reducible/iterable application of the transducers\n to the items in coll. Transducers are applied in order as if\n combined with comp. Note that these applications will be\n performed every time reduce/iterator is called."],"~$tree-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5136,"^25",7,"^29",5136,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$branch?","~$children","~$root"]]]]],"^2A","Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree."],"^1:","~$cljs.core/tree-seq","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^3H","^3I","^3J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5136,"^29",5136,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3H","^3I","^3J"]]]]],"^2A","Returns a lazy sequence of the nodes in a tree, via a depth-first walk.\n branch? must be a fn of one arg that returns true if passed a node\n that can have children (but may not). children must be a fn of one\n arg that returns a sequence of the children. Will only be called on\n nodes for which branch? returns true. Root is the root node of the\n tree."],"~$unchecked-remainder-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2755,"^25",7,"^29",2755,"^24",30,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]]],"^1:","~$cljs.core/unchecked-remainder-int","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2755,"^29",2755,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]]],"~$uuid",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11094,"^25",7,"^29",11094,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"^1:","~$cljs.core/uuid","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11094,"^29",11094,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"~$seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1202,"^25",12,"^29",1202,"^24",15,"^31","^3P","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings."],"^1:","~$cljs.core/seq","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1202,"^3=","^3P","^29",1202,"^2G",1,"^31","^3P","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a seq on the collection. If the collection is\n empty, returns nil. (seq nil) returns nil. seq also works on\n Strings."],"~$Volatile",["^ ","~:num-fields",1,"^1O",["^19",["~$cljs.core/IVolatile","~$cljs.core/IDeref"]],"^1:","~$cljs.core/Volatile","^23","cljs/core.cljs","^24",18,"~:type",true,"^25",10,"^28",4518,"~:record",false,"^29",4518,"^31","~$function","^2@",["^19",["^3U"]]],"~$reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2485,"^25",7,"^29",2485,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]]]],"^2A","f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/reduce","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2485,"^29",2485,"^2G",3,"^2H",true,"^2:",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2A","f should be a function of 2 arguments. If val is not supplied,\n returns the result of applying f to the first 2 items in coll, then\n applying f to that result and the 3rd item, etc. If coll contains no\n items, f must accept no arguments as well, and reduce returns the\n result of calling f with no arguments. If coll has only 1 item, it\n is returned and f is not called. If val is supplied, returns the\n result of applying f to val and the first item in coll, then\n applying f to that result and the 2nd item, etc. If coll contains no\n items, returns val and f is not called."],"~$IUUID",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",11066,"^25",14,"^29",11066,"^24",19,"^2A","A marker protocol for UUIDs","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","~$cljs.core/IUUID","^23","cljs/core.cljs","^24",19,"^25",1,"^28",11066,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",11066,"^31","^32","^33",["^19",["~$cljs.core/UUID"]],"^2A","A marker protocol for UUIDs","^2T",["^2;",["@interface"]]],"~$INIT",["^ ","^1:","~$cljs.core/INIT","^23","cljs/core.cljs","^28",3991,"^25",1,"^29",3991,"^24",10,"^1N",["^ ","^23","cljs/core.cljs","^28",3991,"^25",6,"^29",3991,"^24",10],"^31","~$object"],"~$find-ns",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11459,"^25",7,"^29",11459,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$ns"]]]]],"^2A","Returns the namespace named by the symbol or nil if it doesn't exist.\n Bootstrap only."],"^1:","~$cljs.core/find-ns","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^47"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11459,"^29",11459,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^47"]]]]],"^2A","Returns the namespace named by the symbol or nil if it doesn't exist.\n Bootstrap only."],"~$contains?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2317,"^25",16,"^29",2317,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^2O","~$v"]]]]],"^2A","Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'."],"^1:","~$cljs.core/contains?","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^2O","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2317,"^3=","^3:","^29",2317,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$v"]]]]],"^2A","Returns true if key is present in the given collection, otherwise\n returns false. Note that for numerically indexed collections like\n vectors and arrays, this tests if the numeric key is within the\n range of indexes. 'contains?' operates constant or logarithmic time;\n it will not perform a linear search for a value. See also 'some'."],"~$every?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4178,"^25",16,"^29",4178,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$pred","^2O"]]]]],"^2A","Returns true if (pred x) is logical true for every x in coll, else\n false."],"^1:","~$cljs.core/every?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4178,"^3=","^3:","^29",4178,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns true if (pred x) is logical true for every x in coll, else\n false."],"~$->ES6IteratorSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["~$cljs.core/ISeq","^1Y"]],"^23","cljs/core.cljs","^24",24,"^25",10,"^26","^27","^28",1293,"^29",1293,"^2:",["^2;",["^2<",["^2;",[["~$value","~$iter","~$_rest"]]]]],"^2@",["^19",["^4?","^1Y"]],"^2A","Positional factory function for cljs.core/ES6IteratorSeq."],"^1O",["^19",["^4?","^1Y"]],"^1:","~$cljs.core/->ES6IteratorSeq","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^4@","^4A","^4B"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1293,"^29",1293,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4@","^4A","^4B"]]]]],"^2@",["^19",["^4?","^1Y"]],"^2A","Positional factory function for cljs.core/ES6IteratorSeq."],"~$Var",["^ ","^3S",3,"^1O",["^19",["^1P","^1Q","^1R","^1U","^1Z","~$cljs.core/Fn","^3U","^21"]],"^1:","~$cljs.core/Var","^23","cljs/core.cljs","^24",13,"^3W",true,"^25",10,"^28",1110,"^3X",false,"^29",1110,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1R","^1Z","^3U","^21"]]],"~$keep-indexed",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4540,"^25",7,"^29",4540,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$f","^2O"]]]]],"^2A","Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/keep-indexed","^2C",false,"^23","cljs/core.cljs","^24",19,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4540,"^29",4540,"^2G",2,"^2H",true,"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2A","Returns a lazy sequence of the non-nil results of (f index item). Note,\n this means false return values will be included. f must be free of\n side-effects. Returns a stateful transducer when no collection is\n provided."],"~$->PersistentQueueSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","~$cljs.core/INext","^1Y","^1Z","~$cljs.core/ISequential","^21"]],"^23","cljs/core.cljs","^24",28,"^25",10,"^26","^27","^28",6121,"^29",6121,"^2:",["^2;",["^2<",["^2;",[["^2=","~$front","~$rear","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21"]],"^2A","Positional factory function for cljs.core/PersistentQueueSeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21"]],"^1:","~$cljs.core/->PersistentQueueSeq","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["^2=","^4L","^4M","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6121,"^29",6121,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^4L","^4M","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21"]],"^2A","Positional factory function for cljs.core/PersistentQueueSeq."],"~$subs",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2951,"^25",7,"^29",2951,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$s","~$start"],["~$s","^4P","~$end"]]]]],"^2A","Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$s","^4P"],["~$s","^4P","^4Q"]]],"^2:",["^2;",[["~$s","^4P"],["~$s","^4P","^4Q"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/subs","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$s","^4P"],["~$s","^4P","^4Q"]]],"^2:",["^2;",[["~$s","^4P"],["~$s","^4P","^4Q"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$s","^4P"],["~$s","^4P","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2951,"^29",2951,"^2G",3,"^2H",true,"^2:",["^2;",[["~$s","^4P"],["~$s","^4P","^4Q"]]],"^2A","Returns the substring of s beginning at start inclusive, and ending\n at end (defaults to length of string), exclusive."],"~$IFind",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",634,"^25",14,"^29",634,"^24",19,"^2A","Protocol for implementing entry finding in collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-find",[["^2O","~$k"]]]]],"^2S",true,"^1:","~$cljs.core/IFind","^23","cljs/core.cljs","^24",19,"^25",1,"^28",634,"^2U",["^ ","^2V",["^ ","^4T",[["^2O","~$k"]]]],"^30",null,"^29",634,"^31","^32","^33",["^19",["~$cljs.core/PersistentHashMap","~$cljs.core/ObjMap","~$cljs.core/PersistentArrayMap","~$cljs.core/BlackNode","~$cljs.core/MapEntry","~$cljs.core/Subvec","~$cljs.core/PersistentVector","~$cljs.core/PersistentTreeMap","~$cljs.core/RedNode"]],"^2A","Protocol for implementing entry finding in collections.","^2T",["^2;",["@interface"]]],"~$set",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9304,"^25",7,"^29",9304,"^24",10,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a set of the distinct elements of coll."],"^1:","~$cljs.core/set","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9304,"^29",9304,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a set of the distinct elements of coll."],"~$MODULE_URIS",["^ ","^1:","~$cljs.core/MODULE_URIS","^23","cljs/core.cljs","^28",39,"^25",1,"^29",39,"^24",17,"^1N",["^ ","^23","cljs/core.cljs","^28",39,"^25",6,"^29",39,"^24",17],"^31","~$clj-nil"],"~$compare-indexed",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2382,"^25",17,"^29",2382,"^24",32,"~:private",true,"^2:",["^2;",["^2<",["^2;",[["~$xs","~$ys"],["^5:","^5;","~$len","~$n"]]]]],"^2A","Compare indexed collection.","^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^5:","^5;"],["^5:","^5;","^5<","~$n"]]],"^2:",["^2;",[["^5:","^5;"],["^5:","^5;","^5<","~$n"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/compare-indexed","^2C",false,"^23","cljs/core.cljs","^24",32,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^5:","^5;"],["^5:","^5;","^5<","~$n"]]],"^2:",["^2;",[["^5:","^5;"],["^5:","^5;","^5<","~$n"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^5:","^5;"],["^5:","^5;","^5<","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2382,"^29",2382,"^2G",4,"^2H",true,"^2:",["^2;",[["^5:","^5;"],["^5:","^5;","^5<","~$n"]]],"^2A","Compare indexed collection."],"~$take-last",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4758,"^25",7,"^29",4758,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"]]]]],"^2A","Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec."],"^1:","~$cljs.core/take-last","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4758,"^29",4758,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"]]]]],"^2A","Returns a seq of the last n items in coll. Depending on the type\n of coll may be no better than linear time. For vectors, see also subvec."],"~$IndexedSeq",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",1185,"^25",29,"^29",1185,"^24",39,"~:declared",true],"^3S",3,"^1O",["^19",["~$cljs.core/IIndexed","~$cljs.core/IReversible","^1P","^1Q","~$cljs.core/ASeq","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","~$cljs.core/IReduce"]],"^1:","~$cljs.core/IndexedSeq","^23","cljs/core.cljs","^24",20,"^3W",true,"^25",10,"^28",1568,"^3X",false,"^5A",true,"^29",1568,"^31","^3Y","^2@",["^19",["^5B","^5C","^1P","^1Q","^5D","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]]],"~$bit-set",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2866,"^25",7,"^29",2866,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Set bit at index n"],"^1:","~$cljs.core/bit-set","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2866,"^29",2866,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Set bit at index n"],"~$string-hash-cache-count",["^ ","^1:","~$cljs.core/string-hash-cache-count","^23","cljs/core.cljs","^28",956,"^25",1,"^29",956,"^24",29,"^1N",["^ ","^23","cljs/core.cljs","^28",956,"^25",6,"^29",956,"^24",29],"^31","^<"],"~$qualified-keyword?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3356,"^25",16,"^29",3356,"^24",34,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a keyword with a namespace"],"^1:","~$cljs.core/qualified-keyword?","^2C",false,"^23","cljs/core.cljs","^24",34,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3356,"^3=","^3:","^29",3356,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a keyword with a namespace"],"~$->Eduction",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U","^1Y","~$cljs.core/IPrintWithWriter","^20","^4K","^5E"]],"^23","cljs/core.cljs","^24",18,"^25",10,"^26","^27","^28",10469,"^29",10469,"^2:",["^2;",["^2<",["^2;",[["~$xform","^2O"]]]]],"^2@",["^19",["^1Y","^5N","^20","^4K","^5E"]],"^2A","Positional factory function for cljs.core/Eduction."],"^1O",["^19",["^1U","^1Y","^5N","^20","^4K","^5E"]],"^1:","~$cljs.core/->Eduction","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^5O","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",10469,"^29",10469,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^5O","^2O"]]]]],"^2@",["^19",["^1Y","^5N","^20","^4K","^5E"]],"^2A","Positional factory function for cljs.core/Eduction."],"~$tree-map-add",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8527,"^25",8,"^29",8527,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2P","~$tree","~$k","~$v","~$found"]]]]]],"^59",true,"^1:","~$cljs.core/tree-map-add","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^2P","^5R","~$k","~$v","^5S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8527,"^29",8527,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2P","^5R","~$k","~$v","^5S"]]]]]],"~$->ES6SetEntriesIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",31,"^25",10,"^26","^27","^28",6464,"^29",6464,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ES6SetEntriesIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->ES6SetEntriesIterator","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6464,"^29",6464,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ES6SetEntriesIterator."],"~$-with-meta",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",686,"^25",9,"^29",686,"^24",19,"^31","~$clj","~:protocol","^21","^2A","Returns a new object with value of o and metadata meta added to it.","^2:",["^2;",["^2<",["^2;",[["~$o","^2="]]]]]],"^5Y","^21","^1:","~$cljs.core/-with-meta","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$o","^2="]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",684,"^3=","^5X","^29",686,"^2G",2,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^2="]]]]],"^2A","Returns a new object with value of o and metadata meta added to it."],"~$reset-cache",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10774,"^25",8,"^29",10774,"^24",19,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$method-cache","~$method-table","~$cached-hierarchy","~$hierarchy"]]]]]],"^59",true,"^1:","~$cljs.core/reset-cache","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^60","^61","^62","^63"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10774,"^29",10774,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^60","^61","^62","^63"]]]]]],"~$->PersistentArrayMapIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",36,"^25",10,"^26","^27","^28",6724,"^29",6724,"^2:",["^2;",["^2<",["^2;",[["~$arr","~$i","~$cnt"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/PersistentArrayMapIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->PersistentArrayMapIterator","^2C",false,"^23","cljs/core.cljs","^24",36,"^2D",["^2;",[["^66","~$i","^67"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6724,"^29",6724,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^67"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/PersistentArrayMapIterator."],"~$PersistentArrayMapIterator",["^ ","^3S",3,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/PersistentArrayMapIterator","^23","cljs/core.cljs","^24",36,"^3W",true,"^25",10,"^28",6724,"^3X",false,"^29",6724,"^31","^3Y","^2@",null],"~$butlast",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9382,"^25",7,"^29",9382,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Return a seq of all but the last item in coll, in linear time"],"^1:","~$cljs.core/butlast","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9382,"^29",9382,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Return a seq of all but the last item in coll, in linear time"],"~$tail-off",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5309,"^25",8,"^29",5309,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$pv"]]]]]],"^59",true,"^1:","~$cljs.core/tail-off","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^6>"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5309,"^29",5309,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>"]]]]]],"~$unchecked-subtract-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2765,"^25",15,"^29",2765,"^24",37,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","~$more"]]]]],"^2A","If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/unchecked-subtract-int","^2C",true,"^23","cljs/core.cljs","^24",37,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2765,"^3=","^<","^29",2765,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result."],"~$-iterator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",867,"^25",4,"^29",867,"^24",13,"^5Y","^20","^2A","Returns an iterator for coll.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^20","^1:","~$cljs.core/-iterator","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",865,"^29",867,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns an iterator for coll."],"~$*print-namespace-maps*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",138,"^25",3,"^29",138,"^24",25,"~:dynamic",true,"^2A","*print-namespace-maps* controls whether the printer will print\n namespace map literal syntax.\n\n Defaults to false, but the REPL binds it to true."],"^1:","~$cljs.core/*print-namespace-maps*","^23","cljs/core.cljs","^24",25,"^25",1,"^6F",true,"^28",132,"^29",138,"^31","^3:","^2A","*print-namespace-maps* controls whether the printer will print\n namespace map literal syntax.\n\n Defaults to false, but the REPL binds it to true."],"~$take-nth",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9643,"^25",7,"^29",9643,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$n"],["~$n","^2O"]]]]],"^2A","Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/take-nth","^2C",false,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9643,"^29",9643,"^2G",2,"^2H",true,"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2A","Returns a lazy seq of every nth item in coll. Returns a stateful\n transducer when no collection is provided."],"~$first",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1225,"^25",7,"^29",1225,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil."],"^1:","~$cljs.core/first","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1225,"^29",1225,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the first item in the collection. Calls seq on its\n argument. If coll is nil, returns nil."],"~$native-satisfies?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",280,"^25",16,"^29",280,"^24",33,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$p","~$x"]]]]],"^2A","Internal - do not use!"],"^1:","~$cljs.core/native-satisfies?","^2C",false,"^23","cljs/core.cljs","^24",33,"^2D",["^2;",[["~$p","~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",280,"^3=","^3:","^29",280,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$p","~$x"]]]]],"^2A","Internal - do not use!"],"~$seq?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2212,"^25",16,"^29",2212,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Return true if s satisfies ISeq"],"^1:","~$cljs.core/seq?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2212,"^3=","^3:","^29",2212,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Return true if s satisfies ISeq"],"~$-global-hierarchy",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",10664,"^25",3,"^29",10664,"^24",20,"^59",true,"^2T",["@type {*}"]],"^59",true,"^1:","~$cljs.core/-global-hierarchy","^23","cljs/core.cljs","^24",20,"^25",1,"^28",10661,"^29",10664,"^31","^57","^2T",["@type {*}"]],"~$UUID",["^ ","^3S",2,"^1O",["^19",["^1P","^1Q","^1U","^5N","~$cljs.core/IComparable","^41"]],"^1:","^42","^23","cljs/core.cljs","^24",14,"^3W",true,"^25",10,"^28",11068,"^3X",false,"^29",11068,"^31","^3Y","^2@",["^19",["^1P","^1Q","^5N","^6S"]]],"~$-sorted-seq-from",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",738,"^25",9,"^29",738,"^24",25,"^31","^5X","^5Y","~$cljs.core/ISorted","^2A","Returns a sorted seq from coll in either ascending or descending order.\n If ascending is true, the result should contain all items which are > or >=\n than k. If ascending is false, the result should contain all items which\n are < or <= than k, e.g.\n (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 true) => (3 4 5)\n (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 false) => (3 2 1)","^2:",["^2;",["^2<",["^2;",[["^2O","~$k","~$ascending?"]]]]]],"^5Y","^6U","^1:","~$cljs.core/-sorted-seq-from","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^2O","~$k","^6V"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",733,"^3=","^5X","^29",738,"^2G",3,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k","^6V"]]]]],"^2A","Returns a sorted seq from coll in either ascending or descending order.\n If ascending is true, the result should contain all items which are > or >=\n than k. If ascending is false, the result should contain all items which\n are < or <= than k, e.g.\n (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 true) => (3 4 5)\n (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 false) => (3 2 1)"],"~$println-str",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10092,"^25",7,"^29",10092,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$&","~$objs"]]]]],"^2A","println to a string, returning it","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/println-str","^2C",true,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^6Y"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10092,"^29",10092,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^6Y"]]],"^2A","println to a string, returning it"],"~$inst-ms",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1384,"^25",7,"^29",1384,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$inst"]]]]],"^2A","Return the number of milliseconds since January 1, 1970, 00:00:00 GMT"],"^1:","~$cljs.core/inst-ms","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^70"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1384,"^29",1384,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^70"]]]]],"^2A","Return the number of milliseconds since January 1, 1970, 00:00:00 GMT"],"~$linear-traversal-nth",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1821,"^25",8,"^29",1821,"^24",28,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$n"],["^2O","~$n","~$not-found"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/linear-traversal-nth","^2C",false,"^23","cljs/core.cljs","^24",28,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1821,"^29",1821,"^2G",3,"^2H",true,"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]]],"~$iterate",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5032,"^25",7,"^29",5032,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$f","~$x"]]]]],"^2A","Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects","~:added","1.0"],"^76","1.0","^1:","~$cljs.core/iterate","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$f","~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5032,"^29",5032,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f","~$x"]]]]],"^2A","Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects"],"~$checked-aget'",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",480,"^25",8,"^29",480,"^24",21,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$array","~$idx"],["^79","^7:","~$&","~$idxs"]]]]],"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^79","^7:"]]],"^2:",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/checked-aget'","^2C",true,"^23","cljs/core.cljs","^24",21,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^79","^7:"]]],"^2:",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^79","^7:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",480,"^29",480,"^2G",2,"^2H",true,"^2:",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]]],"~$-empty",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",577,"^25",4,"^29",577,"^24",10,"^5Y","^1W","^2A","Returns an empty collection of the same category as coll. Used\n by cljs.core/empty.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^1W","^1:","~$cljs.core/-empty","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",575,"^29",577,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns an empty collection of the same category as coll. Used\n by cljs.core/empty."],"~$newline",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10047,"^25",7,"^29",10047,"^24",14,"^2:",["^2;",["^2<",["^2;",[[],["^2J"]]]]],"^2A","Prints a newline using *print-fn*","^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^2J"]]],"^2:",["^2;",[[],["^2J"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/newline","^2C",false,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^2J"]]],"^2:",["^2;",[[],["^2J"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[],["^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10047,"^29",10047,"^2G",1,"^2H",true,"^2:",["^2;",[[],["^2J"]]],"^2A","Prints a newline using *print-fn*"],"~$ILookup",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",619,"^25",14,"^29",619,"^24",21,"^2A","Protocol for looking up a value in a data structure.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-lookup",[["~$o","~$k"],["~$o","~$k","^73"]]]]],"^2S",true,"^1:","^22","^23","cljs/core.cljs","^24",21,"^25",1,"^28",619,"^2U",["^ ","^2V",["^ ","^7B",[["~$o","~$k"],["~$o","~$k","^73"]]]],"^30",null,"^29",619,"^31","^32","^33",["^19",["^4V","^4W","^34","^4X","^4Y","^4Z","^4[","^35","~$cljs.core/TaggedLiteral","^50","^36","~$cljs.core/TransientHashSet","~$cljs.core/PersistentHashSet","^51","~$cljs.core/PersistentTreeSet","^52"]],"^2A","Protocol for looking up a value in a data structure.","^2T",["^2;",["@interface"]]],"~$-chunked-rest",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",831,"^25",4,"^29",831,"^24",17,"^5Y","~$cljs.core/IChunkedSeq","^2A","Return a new collection of coll with the first chunk removed.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^7H","^1:","~$cljs.core/-chunked-rest","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",827,"^29",831,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Return a new collection of coll with the first chunk removed."],"~$write-all",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9875,"^25",7,"^29",9875,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$writer","~$&","~$ss"]]]]],"^2K",["^ ","^2C",true,"^2G",1,"^2D",[["^2;",["^7K","^7L"]]],"^2:",["^2;",[["^7K","~$&","^7L"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/write-all","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",1,"^2D",[["^2;",["^7K","^7L"]]],"^2:",["^2;",[["^7K","~$&","^7L"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^7K","^7L"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",9875,"^29",9875,"^2G",1,"^2H",true,"^2:",["^2;",[["^7K","~$&","^7L"]]]],"~$fn?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1990,"^25",16,"^29",1990,"^24",19,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Return true if f is a JavaScript function or satisfies the Fn protocol."],"^1:","~$cljs.core/fn?","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1990,"^3=","^3:","^29",1990,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Return true if f is a JavaScript function or satisfies the Fn protocol."],"~$-prefer-method",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10833,"^25",4,"^29",10833,"^24",18,"^5Y","~$cljs.core/IMultiFn","^2A",null,"^2:",["^2;",["^2<",["^2;",[["~$mf","~$dispatch-val","~$dispatch-val-y"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-prefer-method","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^7R","^7S","^7T"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10833,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S","^7T"]]]]],"^2A",null],"~$-assoc",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",630,"^25",9,"^29",630,"^24",15,"^31","^5X","^5Y","~$cljs.core/IAssociative","^2A","Returns a new collection of coll with a mapping from key k to\n value v added to it.","^2:",["^2;",["^2<",["^2;",[["^2O","~$k","~$v"]]]]]],"^5Y","^7W","^1:","~$cljs.core/-assoc","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2O","~$k","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",625,"^3=","^5X","^29",630,"^2G",3,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k","~$v"]]]]],"^2A","Returns a new collection of coll with a mapping from key k to\n value v added to it."],"~$doall",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9784,"^25",7,"^29",9784,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2O"],["~$n","^2O"]]]]],"^2A","When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^2O"],["~$n","^2O"]]],"^2:",["^2;",[["^2O"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/doall","^2C",false,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^2O"],["~$n","^2O"]]],"^2:",["^2;",[["^2O"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O"],["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9784,"^29",9784,"^2G",2,"^2H",true,"^2:",["^2;",[["^2O"],["~$n","^2O"]]],"^2A","When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. doall can\n be used to force any effects. Walks through the successive nexts of\n the seq, retains the head and returns it, thus causing the entire\n seq to reside in memory at one time."],"~$keyword-identical?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3307,"^25",16,"^29",3307,"^24",34,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Efficient test to determine that two keywords are identical."],"^1:","~$cljs.core/keyword-identical?","^2C",false,"^23","cljs/core.cljs","^24",34,"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3307,"^3=","^3:","^29",3307,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Efficient test to determine that two keywords are identical."],"~$*print-err-fn*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",84,"^25",3,"^29",84,"^24",17,"^2A","Each runtime environment provides a different way to print error output.\n Whatever function *print-err-fn* is bound to will be passed any\n Strings which should be printed.","^6F",true],"^1:","~$cljs.core/*print-err-fn*","^23","cljs/core.cljs","^24",17,"^25",1,"^6F",true,"^28",80,"^29",84,"^31","^57","^2A","Each runtime environment provides a different way to print error output.\n Whatever function *print-err-fn* is bound to will be passed any\n Strings which should be printed."],"~$pv-aset",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5303,"^25",8,"^29",5303,"^24",15,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$node","^7:","^2Z"]]]]]],"^59",true,"^1:","~$cljs.core/pv-aset","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^84","^7:","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5303,"^29",5303,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^84","^7:","^2Z"]]]]]],"~$prefers",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11053,"^25",7,"^29",11053,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$multifn"]]]]],"^2A","Given a multimethod, returns a map of preferred value -> set of other values"],"^1:","~$cljs.core/prefers","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^87"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11053,"^29",11053,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, returns a map of preferred value -> set of other values"],"~$-js->clj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10562,"^25",4,"^29",10562,"^24",12,"^5Y","~$cljs.core/IEncodeClojure","^2A","Transforms JavaScript values to Clojure","^2:",["^2;",["^2<",["^2;",[["~$x","~$options"]]]]]],"^5Y","^8:","^1:","~$cljs.core/-js->clj","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$x","^8;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10561,"^29",10562,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","^8;"]]]]],"^2A","Transforms JavaScript values to Clojure"],"~$LazySeq",["^ ","^3S",4,"^1O",["^19",["^1P","^1Q","^1S","^1U","~$cljs.core/IPending","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/LazySeq","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",3384,"^3X",false,"^29",3384,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$dedupe",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10442,"^25",7,"^29",10442,"^24",13,"^2:",["^2;",["^2<",["^2;",[[],["^2O"]]]]],"^2A","Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^2O"]]],"^2:",["^2;",[[],["^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/dedupe","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^2O"]]],"^2:",["^2;",[[],["^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[],["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10442,"^29",10442,"^2G",1,"^2H",true,"^2:",["^2;",[[],["^2O"]]],"^2A","Returns a lazy sequence removing consecutive duplicates in coll.\n Returns a transducer when no collection is provided."],"~$unchecked-editable-array-for",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5957,"^25",8,"^29",5957,"^24",36,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$tv","~$i"]]]]]],"^59",true,"^1:","~$cljs.core/unchecked-editable-array-for","^2C",false,"^23","cljs/core.cljs","^24",36,"^2D",["^2;",[["^8C","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5957,"^29",5957,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^8C","~$i"]]]]]],"~$->ES6Iterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",21,"^25",10,"^26","^27","^28",1277,"^29",1277,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ES6Iterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->ES6Iterator","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1277,"^29",1277,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ES6Iterator."],"~$VectorNode",["^ ","^3S",2,"^1O",["^19",[]],"^1:","~$cljs.core/VectorNode","^23","cljs/core.cljs","^24",20,"^3W",true,"^25",10,"^28",5295,"^3X",false,"^29",5295,"^31","^3Y","^2@",null],"~$dissoc",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1976,"^25",7,"^29",1976,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","~$ks"]]]]],"^2A","dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s).","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2O"],["^2O","~$k"]]],"^2:",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/dissoc","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2O"],["^2O","~$k"]]],"^2:",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["^2O"],["^2O","~$k"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",1976,"^29",1976,"^2G",2,"^2H",true,"^2:",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]],"^2A","dissoc[iate]. Returns a new map of the same (hashed/sorted) type,\n that does not contain a mapping for key(s)."],"~$atom",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4404,"^25",7,"^29",4404,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$&",["^ ","~:keys",["^2=","~$validator"]]]]]]],"^2A","Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will be come the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an Error. If either of these error conditions\n occur, then the value of the atom will not change.","^2K",["^ ","^2C",true,"^2G",1,"^2D",["^2;",[["~$x"]]],"^2:",["^2;",[["~$x"],["~$x","~$&",["^ ","^8M",["^2=","^8N"]]]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/atom","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",1,"^2D",["^2;",[["~$x"]]],"^2:",["^2;",[["~$x"],["~$x","~$&",["^ ","^8M",["^2=","^8N"]]]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4404,"^29",4404,"^2G",1,"^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$&",["^ ","^8M",["^2=","^8N"]]]]],"^2A","Creates and returns an Atom with an initial value of x and zero or\n more options (in any order):\n\n :meta metadata-map\n\n :validator validate-fn\n\n If metadata-map is supplied, it will be come the metadata on the\n atom. validate-fn must be nil or a side-effect-free fn of one\n argument, which will be passed the intended new state on any state\n change. If the new state is unacceptable, the validate-fn should\n return false or throw an Error. If either of these error conditions\n occur, then the value of the atom will not change."],"~$bit-shift-right",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2880,"^25",7,"^29",2880,"^24",22,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Bitwise shift right"],"^1:","~$cljs.core/bit-shift-right","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2880,"^29",2880,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Bitwise shift right"],"~$MapEntry",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",1959,"^25",47,"^29",1959,"^24",55,"^5A",true],"^3S",3,"^1O",["^19",["^5B","~$cljs.core/IVector","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","~$cljs.core/IStack","~$cljs.core/IMapEntry","^4K","^21","^7W","^22","^5E"]],"^1:","^4Z","^23","cljs/core.cljs","^24",18,"^3W",true,"^25",10,"^28",6555,"^3X",false,"^5A",true,"^29",6555,"^31","^3Y","^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]]],"~$->t_cljs$core1500",["^ ","^1M",null,"^1N",["^ ","~:anonymous",true,"^1O",["^19",["^1U","^1Z","^21"]],"^2@",["^19",["^1Z","^21"]],"^26","^27","^2:",["^2;",["^2<",["^2;",[["~$meta1501"]]]]],"^2A","Positional factory function for cljs.core/t_cljs$core1500.","^23","cljs/core.cljs"],"^1O",["^19",["^1U","^1Z","^21"]],"^1:","~$cljs.core/->t_cljs$core1500","^2C",false,"^23","cljs/core.cljs","^2D",["^2;",[["^8X"]]],"^2E",null,"^2F",["^2;",[null,null]],"^8W",true,"^25",3,"^26","^27","^28",3961,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^8X"]]]]],"^2@",["^19",["^1Z","^21"]],"^2A","Positional factory function for cljs.core/t_cljs$core1500."],"~$*clojurescript-version*",["^ ","^1:","~$cljs.core/*clojurescript-version*","^23","cljs/core.cljs","^28",19,"^25",1,"^29",19,"^24",29,"^1N",["^ ","^23","cljs/core.cljs","^28",19,"^25",6,"^29",19,"^24",29],"^31","~$string"],"~$-first",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",603,"^25",4,"^29",603,"^24",10,"^5Y","^4?","^2A","Returns the first item in the collection coll. Used by cljs.core/first.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^4?","^1:","~$cljs.core/-first","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",601,"^29",603,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the first item in the collection coll. Used by cljs.core/first."],"~$peek",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2064,"^25",7,"^29",2064,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil."],"^1:","~$cljs.core/peek","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2064,"^29",2064,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","For a list or queue, same as first, for a vector, same as, but much\n more efficient than, last. If the collection is empty, returns nil."],"~$IKVReduce",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",697,"^25",14,"^29",697,"^24",23,"^2A","Protocol for associative types that can reduce themselves\n via a function of key and val. Called by cljs.core/reduce-kv.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-kv-reduce",[["^2O","~$f","~$init"]]]]],"^2S",true,"^1:","~$cljs.core/IKVReduce","^23","cljs/core.cljs","^24",23,"^25",1,"^28",697,"^2U",["^ ","^2V",["^ ","^96",[["^2O","~$f","^97"]]]],"^30",null,"^29",697,"^31","^32","^33",["^19",["^4V","^4W","^4X","^4[","^50","^51"]],"^2A","Protocol for associative types that can reduce themselves\n via a function of key and val. Called by cljs.core/reduce-kv.","^2T",["^2;",["@interface"]]],"~$iter-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2462,"^25",8,"^29",2462,"^24",19,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]],"^2:",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/iter-reduce","^2C",false,"^23","cljs/core.cljs","^24",19,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]],"^2:",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2462,"^29",2462,"^2G",3,"^2H",true,"^2:",["^2;",[["^2O","~$f"],["^2O","~$f","^97"]]]],"~$aget",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",496,"^25",7,"^29",496,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]]]],"^2A","Returns the value at the index/indices. Works on JavaScript arrays.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^79","^7:"]]],"^2:",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/aget","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^79","^7:"]]],"^2:",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^79","^7:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",496,"^29",496,"^2G",2,"^2H",true,"^2:",["^2;",[["^79","^7:"],["^79","^7:","~$&","^7;"]]],"^2A","Returns the value at the index/indices. Works on JavaScript arrays."],"~$PersistentTreeMapSeq",["^ ","^3S",5,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/PersistentTreeMapSeq","^23","cljs/core.cljs","^24",30,"^3W",true,"^25",10,"^28",8066,"^3X",false,"^29",8066,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$-write",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",752,"^25",4,"^29",752,"^24",10,"^5Y","~$cljs.core/IWriter","^2A","Writes s with writer and returns the result.","^2:",["^2;",["^2<",["^2;",[["^7K","~$s"]]]]]],"^5Y","^9@","^1:","~$cljs.core/-write","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^7K","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",750,"^29",752,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7K","~$s"]]]]],"^2A","Writes s with writer and returns the result."],"^4A",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4015,"^25",7,"^29",4015,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^1:","~$cljs.core/iter","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4015,"^29",4015,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"~$mk-bound-fn",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9490,"^25",7,"^29",9490,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$sc","~$test","^2Y"]]]]]],"^1:","~$cljs.core/mk-bound-fn","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^9D","^9E","^2Y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9490,"^29",9490,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^9D","^9E","^2Y"]]]]]],"~$last",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1761,"^25",7,"^29",1761,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Return the last item in coll, in linear time"],"^1:","~$cljs.core/last","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1761,"^29",1761,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Return the last item in coll, in linear time"],"~$-default-dispatch-val",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10837,"^25",4,"^29",10837,"^24",25,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-default-dispatch-val","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^7R"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10837,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]],"^2A",null],"~$pr",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10065,"^25",7,"^29",10065,"^24",9,"^2:",["^2;",["^2<",["^2;",[["~$&","^6Y"]]]]],"^2A","Prints the object(s) using string-print. Prints the\n object(s), separated by spaces if there is more than one.\n By default, pr and prn print in a way that objects can be\n read by the reader","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/pr","^2C",true,"^23","cljs/core.cljs","^24",9,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^6Y"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10065,"^29",10065,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^6Y"]]],"^2A","Prints the object(s) using string-print. Prints the\n object(s), separated by spaces if there is more than one.\n By default, pr and prn print in a way that objects can be\n read by the reader"],"~$tree-map-seq-push",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8059,"^25",8,"^29",8059,"^24",25,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^84","^@","^6V"]]]]]],"^59",true,"^1:","~$cljs.core/tree-map-seq-push","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^84","^@","^6V"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8059,"^29",8059,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^84","^@","^6V"]]]]]],"~$namespace",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3325,"^25",7,"^29",3325,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns the namespace String of a symbol or keyword, or nil if not present."],"^1:","~$cljs.core/namespace","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3325,"^29",3325,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns the namespace String of a symbol or keyword, or nil if not present."],"~$empty-unordered-hash",["^ ","^1:","~$cljs.core/empty-unordered-hash","^23","cljs/core.cljs","^28",1351,"^25",1,"^29",1351,"^24",36,"^59",true,"^1N",["^ ","^23","cljs/core.cljs","^28",1351,"^25",16,"^29",1351,"^24",36,"^59",true],"^31","^<"],"~$obj-map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8806,"^25",7,"^29",8806,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$&","~$keyvals"]]]]],"^2A","keyval => key val\n Returns a new object map with supplied mappings.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^9T"]]],"^2:",["^2;",[["~$&","^9T"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/obj-map","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^9T"]]],"^2:",["^2;",[["~$&","^9T"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^9T"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",8806,"^29",8806,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^9T"]]],"^2A","keyval => key val\n Returns a new object map with supplied mappings."],"~$Reduced",["^ ","^3S",1,"^1O",["^19",["^3U"]],"^1:","~$cljs.core/Reduced","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",1417,"^3X",false,"^29",1417,"^31","^3Y","^2@",["^19",["^3U"]]],"~$-conj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",583,"^25",9,"^29",583,"^24",14,"^31","^5X","^5Y","^1S","^2A","Returns a new collection of coll with o added to it. The new item\n should be added to the most efficient place, e.g.\n (conj [1 2 3 4] 5) => [1 2 3 4 5]\n (conj '(2 3 4 5) 1) => '(1 2 3 4 5)","^2:",["^2;",["^2<",["^2;",[["^2O","~$o"]]]]]],"^5Y","^1S","^1:","~$cljs.core/-conj","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O","~$o"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",581,"^3=","^5X","^29",583,"^2G",2,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$o"]]]]],"^2A","Returns a new collection of coll with o added to it. The new item\n should be added to the most efficient place, e.g.\n (conj [1 2 3 4] 5) => [1 2 3 4 5]\n (conj '(2 3 4 5) 1) => '(1 2 3 4 5)"],"~$NodeSeq",["^ ","^3S",5,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/NodeSeq","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",7610,"^3X",false,"^29",7610,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$=",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1258,"^25",16,"^29",1258,"^24",17,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Equality. Returns true if x equals y, false if not. Compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define -equiv (and thus =) as a value, not an identity,\n comparison.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/=","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",1258,"^3=","^3:","^29",1258,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Equality. Returns true if x equals y, false if not. Compares\n numbers and collections in a type-independent manner. Clojure's immutable data\n structures define -equiv (and thus =) as a value, not an identity,\n comparison."],"~$ITransientMap",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",799,"^25",14,"^29",799,"^24",27,"^2A","Protocol for adding mapping functionality to transient collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-dissoc!",[["^2X","^2Y"]]]]],"^2S",true,"^1:","~$cljs.core/ITransientMap","^23","cljs/core.cljs","^24",27,"^25",1,"^28",799,"^2U",["^ ","^2V",["^ ","^:2",[["^2X","^2Y"]]]],"^30",null,"^29",799,"^31","^32","^33",["^19",["^35","^36"]],"^2A","Protocol for adding mapping functionality to transient collections.","^2T",["^2;",["@interface"]]],"~$push-tail",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5325,"^25",8,"^29",5325,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>","~$level","~$parent","~$tailnode"]]]]]],"^59",true,"^1:","~$cljs.core/push-tail","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^6>","^:5","^:6","^:7"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5325,"^29",5325,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>","^:5","^:6","^:7"]]]]]],"~$take",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4701,"^25",7,"^29",4701,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$n"],["~$n","^2O"]]]]],"^2A","Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/take","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4701,"^29",4701,"^2G",2,"^2H",true,"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2A","Returns a lazy sequence of the first n items in coll, or all items if\n there are fewer than n. Returns a stateful transducer when\n no collection is provided."],"~$vector?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2145,"^25",16,"^29",2145,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies IVector"],"^1:","~$cljs.core/vector?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2145,"^3=","^3:","^29",2145,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies IVector"],"~$array-index-of-equiv?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6514,"^25",8,"^29",6514,"^24",29,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"^59",true,"^1:","~$cljs.core/array-index-of-equiv?","^2C",false,"^23","cljs/core.cljs","^24",29,"^2D",["^2;",[["^66","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6514,"^29",6514,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"~$bitmap-indexed-node-index",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7072,"^25",8,"^29",7072,"^24",33,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$bitmap","~$bit"]]]]]],"^59",true,"^1:","~$cljs.core/bitmap-indexed-node-index","^2C",false,"^23","cljs/core.cljs","^24",33,"^2D",["^2;",[["^:@","^:A"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7072,"^29",7072,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:@","^:A"]]]]]],"^3:",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2227,"^25",16,"^29",2227,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Coerce to boolean"],"^1:","~$cljs.core/boolean","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2227,"^3=","^3:","^29",2227,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Coerce to boolean"],"~$IChunk",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",822,"^25",14,"^29",822,"^24",20,"^2A","Protocol for accessing the items of a chunk.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-drop-first",[["^2O"]]]]],"^2S",true,"^1:","~$cljs.core/IChunk","^23","cljs/core.cljs","^24",20,"^25",1,"^28",822,"^2U",["^ ","^2V",["^ ","^:E",[["^2O"]]]],"^30",null,"^29",822,"^31","^32","^33",["^19",["~$cljs.core/ArrayChunk"]],"^2A","Protocol for accessing the items of a chunk.","^2T",["^2;",["@interface"]]],"~$bit-shift-left",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2876,"^25",7,"^29",2876,"^24",21,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Bitwise shift left"],"^1:","~$cljs.core/bit-shift-left","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2876,"^29",2876,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Bitwise shift left"],"~$random-uuid",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11098,"^25",7,"^29",11098,"^24",18,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"^1:","~$cljs.core/random-uuid","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11098,"^29",11098,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"~$any?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",275,"^25",16,"^29",275,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if given any argument."],"^1:","~$cljs.core/any?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",275,"^3=","^3:","^29",275,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if given any argument."],"~$rand-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10634,"^25",7,"^29",10634,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns a random integer between 0 (inclusive) and n (exclusive)."],"^1:","~$cljs.core/rand-int","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10634,"^29",10634,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns a random integer between 0 (inclusive) and n (exclusive)."],"~$aclone",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",426,"^25",7,"^29",426,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^66"]]]]],"^2A","Returns a javascript array, cloned from the passed in array"],"^1:","~$cljs.core/aclone","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",426,"^29",426,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66"]]]]],"^2A","Returns a javascript array, cloned from the passed in array"],"~$BlackNode",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",8138,"^25",18,"^29",8138,"^24",27,"^5A",true],"^3S",5,"^1O",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^1:","^4Y","^23","cljs/core.cljs","^24",19,"^3W",true,"^25",10,"^28",8238,"^3X",false,"^5A",true,"^29",8238,"^31","^3Y","^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]]],"~$vreset!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4535,"^25",7,"^29",4535,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$vol","~$newval"]]]]],"^2A","Sets the value of volatile to newval without regard for the\n current value. Returns newval."],"^1:","~$cljs.core/vreset!","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^:T","^:U"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4535,"^29",4535,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:T","^:U"]]]]],"^2A","Sets the value of volatile to newval without regard for the\n current value. Returns newval."],"~$chunk",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3593,"^25",7,"^29",3593,"^24",12,"^2:",["^2;",["^2<",["^2;",[["~$b"]]]]]],"^1:","~$cljs.core/chunk","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$b"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3593,"^29",3593,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$b"]]]]]],"~$UNREALIZED-SEED",["^ ","^1:","~$cljs.core/UNREALIZED-SEED","^23","cljs/core.cljs","^28",4974,"^25",1,"^29",4974,"^24",31,"^59",true,"^1N",["^ ","^23","cljs/core.cljs","^28",4974,"^25",16,"^29",4974,"^24",31,"^59",true],"^31","^45"],"~$dec",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2658,"^25",7,"^29",2658,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one less than num."],"^1:","~$cljs.core/dec","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2658,"^29",2658,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one less than num."],"~$->TransformerIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",29,"^25",10,"^26","^27","^28",4097,"^29",4097,"^2:",["^2;",["^2<",["^2;",[["~$buffer","~$_next","~$completed","~$xf","~$sourceIter","~$multi"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/TransformerIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->TransformerIterator","^2C",false,"^23","cljs/core.cljs","^24",29,"^2D",["^2;",[["^;2","^;3","^;4","^;5","^;6","^;7"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4097,"^29",4097,"^2G",6,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;2","^;3","^;4","^;5","^;6","^;7"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/TransformerIterator."],"~$APersistentVector",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",5430,"^25",14,"^29",5430,"^24",31,"^2A","Marker protocol","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","~$cljs.core/APersistentVector","^23","cljs/core.cljs","^24",31,"^25",1,"^28",5430,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",5430,"^31","^32","^33",["^19",["^50"]],"^2A","Marker protocol","^2T",["^2;",["@interface"]]],"~$map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4654,"^25",7,"^29",4654,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$f","^2O"],["~$f","~$c1","~$c2"],["~$f","^;<","^;=","~$c3"],["~$f","^;<","^;=","^;>","~$&","~$colls"]]]]],"^2A","Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided.","^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$f"],["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]],"^2F",["^2;",[null,null,null,null,null]]]],"^1:","~$cljs.core/map","^2C",true,"^23","cljs/core.cljs","^24",10,"^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$f"],["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]],"^2F",["^2;",[null,null,null,null,null]]],"^2D",["^2;",[["~$f"],["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null]],"^25",1,"^28",4654,"^29",4654,"^2G",4,"^2H",true,"^2:",["^2;",[["~$f"],["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]],"^2A","Returns a lazy sequence consisting of the result of applying f to\n the set of first items of each coll, followed by applying f to the\n set of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments. Returns a transducer when\n no collection is provided."],"~$juxt",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9735,"^25",7,"^29",9735,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["~$f","~$g","~$h","~$&","~$fs"]]]]],"^2A","Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]","^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"]]],"^2:",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["~$f","~$g","~$h","~$&","^;B"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/juxt","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"]]],"^2:",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["~$f","~$g","~$h","~$&","^;B"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",9735,"^29",9735,"^2G",3,"^2H",true,"^2:",["^2;",[["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["~$f","~$g","~$h","~$&","^;B"]]],"^2A","Takes a set of functions and returns a fn that is the juxtaposition\n of those fns. The returned fn takes a variable number of args, and\n returns a vector containing the result of applying each fn to the\n args (left-to-right).\n ((juxt a b c) x) => [(a x) (b x) (c x)]"],"~$->PersistentQueueIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",29,"^25",10,"^26","^27","^28",6106,"^29",6106,"^2:",["^2;",["^2<",["^2;",[["~$fseq","~$riter"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/PersistentQueueIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->PersistentQueueIter","^2C",false,"^23","cljs/core.cljs","^24",29,"^2D",["^2;",[["^;E","^;F"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6106,"^29",6106,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;E","^;F"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/PersistentQueueIter."],"~$<",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2610,"^25",16,"^29",2610,"^24",17,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns non-nil if nums are in monotonically increasing order,\n otherwise false.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/<","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2610,"^3=","^3:","^29",2610,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns non-nil if nums are in monotonically increasing order,\n otherwise false."],"~$*eval*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11530,"^25",3,"^29",11530,"^24",9,"^2A","Runtime environments may provide a way to evaluate ClojureScript\n forms. Whatever function *eval* is bound to will be passed any forms which\n should be evaluated.","^6F",true],"^1:","~$cljs.core/*eval*","^2C",false,"^23","cljs/core.cljs","^24",9,"^2D",["^2;",[["~$_"]]],"^2E",null,"^2F",["^2;",[]],"^25",1,"^6F",true,"^28",11526,"^29",11530,"^2G",1,"^2H",true,"^2:",null,"^2A","Runtime environments may provide a way to evaluate ClojureScript\n forms. Whatever function *eval* is bound to will be passed any forms which\n should be evaluated."],"~$inode-kv-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7089,"^25",8,"^29",7089,"^24",23,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$f","^97"]]]]]],"^59",true,"^1:","~$cljs.core/inode-kv-reduce","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^66","~$f","^97"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7089,"^29",7089,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$f","^97"]]]]]],"~$obj-map->hash-map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6297,"^25",8,"^29",6297,"^24",25,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k","~$v"]]]]]],"^59",true,"^1:","~$cljs.core/obj-map->hash-map","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["~$m","~$k","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6297,"^29",6297,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k","~$v"]]]]]],"^9E",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11199,"^25",7,"^29",11199,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$v"]]]]],"^2A","test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception"],"^1:","~$cljs.core/test","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11199,"^29",11199,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$v"]]]]],"^2A","test [v] finds fn at key :test in var metadata and calls it,\n presuming failure will throw exception"],"~$rest",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1236,"^25",12,"^29",1236,"^24",16,"^31","^3P","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a possibly empty seq of the items after the first. Calls seq on its\n argument."],"^1:","~$cljs.core/rest","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1236,"^3=","^3P","^29",1236,"^2G",1,"^31","^3P","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a possibly empty seq of the items after the first. Calls seq on its\n argument."],"~$ex-data",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11163,"^25",7,"^29",11163,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$ex"]]]]],"^2A","Returns exception data (a map) if ex is an ExceptionInfo.\n Otherwise returns nil."],"^1:","~$cljs.core/ex-data","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^;S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11163,"^29",11163,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;S"]]]]],"^2A","Returns exception data (a map) if ex is an ExceptionInfo.\n Otherwise returns nil."],"~$PersistentArrayMapSeq",["^ ","^3S",3,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/PersistentArrayMapSeq","^23","cljs/core.cljs","^24",31,"^3W",true,"^25",10,"^28",6655,"^3X",false,"^29",6655,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"^:E",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",824,"^25",4,"^29",824,"^24",15,"^5Y","^:F","^2A","Return a new chunk of coll with the first item removed.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^:F","^1:","~$cljs.core/-drop-first","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",822,"^29",824,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Return a new chunk of coll with the first item removed."],"~$isa?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10674,"^25",16,"^29",10674,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$child","^:6"],["~$h","^;Y","^:6"]]]]],"^2A","Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a JavaScript type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^;Y","^:6"],["~$h","^;Y","^:6"]]],"^2:",["^2;",[["^;Y","^:6"],["~$h","^;Y","^:6"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/isa?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^;Y","^:6"],["~$h","^;Y","^:6"]]],"^2:",["^2;",[["^;Y","^:6"],["~$h","^;Y","^:6"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^;Y","^:6"],["~$h","^;Y","^:6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10674,"^3=","^3:","^29",10674,"^2G",3,"^31","^3:","^2H",true,"^2:",["^2;",[["^;Y","^:6"],["~$h","^;Y","^:6"]]],"^2A","Returns true if (= child parent), or child is directly or indirectly derived from\n parent, either via a JavaScript type inheritance relationship or a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy"],"~$boolean?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2203,"^25",16,"^29",2203,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a Boolean"],"^1:","~$cljs.core/boolean?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2203,"^3=","^3:","^29",2203,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a Boolean"],"~$-clone",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",567,"^25",9,"^29",567,"^24",15,"^31","^5X","^5Y","^1[","^2A","Creates a clone of value.","^2:",["^2;",["^2<",["^2;",[["^4@"]]]]]],"^5Y","^1[","^1:","~$cljs.core/-clone","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^4@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",565,"^3=","^5X","^29",567,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4@"]]]]],"^2A","Creates a clone of value."],"~$munge",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11308,"^25",7,"^29",11308,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^:"]]]]]],"^1:","~$cljs.core/munge","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11308,"^29",11308,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:"]]]]]],"~$empty-ordered-hash",["^ ","^1:","~$cljs.core/empty-ordered-hash","^23","cljs/core.cljs","^28",1336,"^25",1,"^29",1336,"^24",34,"^59",true,"^1N",["^ ","^23","cljs/core.cljs","^28",1336,"^25",16,"^29",1336,"^24",34,"^59",true],"^31","^<"],"~$DEMUNGE_MAP",["^ ","^1:","~$cljs.core/DEMUNGE_MAP","^23","cljs/core.cljs","^28",362,"^25",1,"^29",363,"^24",14,"^2T",["@enum {string}"],"^1N",["^ ","^23","cljs/core.cljs","^28",363,"^25",3,"^29",363,"^24",14,"^2T",["@enum {string}"]],"^31","^45"],"~$ES6IteratorSeq",["^ ","^3S",3,"^1O",["^19",["^4?","^1Y"]],"^1:","~$cljs.core/ES6IteratorSeq","^23","cljs/core.cljs","^24",24,"^3W",true,"^25",10,"^28",1293,"^3X",false,"^29",1293,"^31","^3Y","^2@",["^19",["^4?","^1Y"]]],"~$->NeverEquiv",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1U"]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",6246,"^29",6246,"^2:",["^2;",["^2<",["^2;",[[]]]]],"^2@",["^19",["^1P"]],"^2A","Positional factory function for cljs.core/NeverEquiv."],"^1O",["^19",["^1P","^1U"]],"^1:","~$cljs.core/->NeverEquiv","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6246,"^29",6246,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]],"^2@",["^19",["^1P"]],"^2A","Positional factory function for cljs.core/NeverEquiv."],"~$re-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9831,"^25",7,"^29",9831,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$re","~$s"]]]]],"^2A","Returns a lazy sequence of successive matches of re in s."],"^1:","~$cljs.core/re-seq","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^<>","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9831,"^29",9831,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^<>","~$s"]]]]],"^2A","Returns a lazy sequence of successive matches of re in s."],"~$char?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",270,"^25",16,"^29",270,"^24",21,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a JavaScript string of length one."],"^1:","~$cljs.core/char?","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",270,"^3=","^3:","^29",270,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a JavaScript string of length one."],"~$make-hierarchy",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10657,"^25",7,"^29",10657,"^24",21,"^2:",["^2;",["^2<",["^2;",[[]]]]],"^2A","Creates a hierarchy object for use with derive, isa? etc."],"^1:","~$cljs.core/make-hierarchy","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10657,"^29",10657,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]],"^2A","Creates a hierarchy object for use with derive, isa? etc."],"^E",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",952,"^25",15,"^29",952,"^24",21,"^5A",true],"^3S",5,"^1O",["^19",["^1P","^1Q","^1R","^1U","~$cljs.core/INamed","^1Z","^5N","^21"]],"^1:","~$cljs.core/Symbol","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",1060,"^3X",false,"^5A",true,"^29",1060,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1R","^MetaFn",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1R","^1Z","^4E","^21"]],"^23","cljs/core.cljs","^24",16,"^25",10,"^26","^27","^28",1995,"^29",1995,"^2:",["^2;",["^2<",["^2;",[["~$afn","^2="]]]]],"^2@",["^19",["^1R","^1Z","^21"]],"^2A","Positional factory function for cljs.core/MetaFn."],"^1O",["^19",["^1R","^1Z","^4E","^21"]],"^1:","~$cljs.core/->MetaFn","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^=O","^2="]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1995,"^29",1995,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=O","^2="]]]]],"^2@",["^19",["^1R","^1Z","^21"]],"^2A","Positional factory function for cljs.core/MetaFn."],"~$unchecked-inc-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2730,"^25",7,"^29",2730,"^24",24,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/unchecked-inc-int","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2730,"^29",2730,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$-compare",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",818,"^25",12,"^29",818,"^24",20,"^31","^<","^5Y","^6S","^2A","Returns a negative number, zero, or a positive number when x is logically\n 'less than', 'equal to', or 'greater than' y.","^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]]],"^5Y","^6S","^1:","~$cljs.core/-compare","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",816,"^3=","^<","^29",818,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Returns a negative number, zero, or a positive number when x is logically\n 'less than', 'equal to', or 'greater than' y."],"~$map-indexed",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4313,"^25",7,"^29",4313,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$f","^2O"]]]]],"^2A","Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/map-indexed","^2C",false,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4313,"^29",4313,"^2G",2,"^2H",true,"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2A","Returns a lazy sequence consisting of the result of applying f to 0\n and the first item of coll, followed by applying f to 1 and the second\n item in coll, etc, until coll is exhausted. Thus function f should\n accept 2 arguments, index and item. Returns a stateful transducer when\n no collection is provided."],"~$array-list",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9437,"^25",7,"^29",9437,"^24",17,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"^1:","~$cljs.core/array-list","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9437,"^29",9437,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"~$rand-nth",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10638,"^25",7,"^29",10638,"^24",15,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection."],"^1:","~$cljs.core/rand-nth","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10638,"^29",10638,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Return a random element of the (sequential) collection. Will have\n the same performance characteristics as nth for the given\n collection."],"^2P",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4230,"^25",7,"^29",4230,"^24",11,"^2:",["^2;",["^2<",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["~$f1","~$f2","~$f3","~$&","^;B"]]]]],"^2A","Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc.","^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"]]],"^2:",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["^=[","^>0","^>1","~$&","^;B"]]],"^2F",["^2;",[null,null,null,null,null]]]],"^1:","~$cljs.core/comp","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"]]],"^2:",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["^=[","^>0","^>1","~$&","^;B"]]],"^2F",["^2;",[null,null,null,null,null]]],"^2D",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null]],"^25",1,"^28",4230,"^29",4230,"^2G",3,"^2H",true,"^2:",["^2;",[[],["~$f"],["~$f","~$g"],["~$f","~$g","~$h"],["^=[","^>0","^>1","~$&","^;B"]]],"^2A","Takes a set of functions and returns a fn that is the composition\n of those fns. The returned fn takes a variable number of args,\n applies the rightmost of fns to the args, the next\n fn (right-to-left) to the result, etc."],"~$array-chunk",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3505,"^25",7,"^29",3505,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^66"],["^66","~$off"],["^66","^>4","^4Q"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^66"],["^66","^>4"],["^66","^>4","^4Q"]]],"^2:",["^2;",[["^66"],["^66","^>4"],["^66","^>4","^4Q"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/array-chunk","^2C",false,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^66"],["^66","^>4"],["^66","^>4","^4Q"]]],"^2:",["^2;",[["^66"],["^66","^>4"],["^66","^>4","^4Q"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["^66"],["^66","^>4"],["^66","^>4","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",3505,"^29",3505,"^2G",3,"^2H",true,"^2:",["^2;",[["^66"],["^66","^>4"],["^66","^>4","^4Q"]]]],"~$dispatch-fn",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11061,"^25",7,"^29",11061,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, return it's dispatch-fn."],"^1:","~$cljs.core/dispatch-fn","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^87"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11061,"^29",11061,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, return it's dispatch-fn."],"~$bit-shift-right-zero-fill",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2884,"^25",7,"^29",2884,"^24",32,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","DEPRECATED: Bitwise shift right with zero fill"],"^1:","~$cljs.core/bit-shift-right-zero-fill","^2C",false,"^23","cljs/core.cljs","^24",32,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2884,"^29",2884,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","DEPRECATED: Bitwise shift right with zero fill"],"~$js-reserved?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11273,"^25",8,"^29",11273,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^59",true,"^1:","~$cljs.core/js-reserved?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11273,"^29",11273,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$-as-transient",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",783,"^25",9,"^29",783,"^24",22,"^31","^5X","^5Y","^1T","^2A","Returns a new, transient version of the collection, in constant time.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^1T","^1:","~$cljs.core/-as-transient","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",781,"^3=","^5X","^29",783,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a new, transient version of the collection, in constant time."],"~$dorun",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9771,"^25",7,"^29",9771,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2O"],["~$n","^2O"]]]]],"^2A","When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^2O"],["~$n","^2O"]]],"^2:",["^2;",[["^2O"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/dorun","^2C",false,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^2O"],["~$n","^2O"]]],"^2:",["^2;",[["^2O"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O"],["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9771,"^29",9771,"^2G",2,"^2H",true,"^2:",["^2;",[["^2O"],["~$n","^2O"]]],"^2A","When lazy sequences are produced via functions that have side\n effects, any effects other than those needed to produce the first\n element in the seq do not occur until the seq is consumed. dorun can\n be used to force any effects. Walks through the successive nexts of\n the seq, does not retain the head and returns nil."],"~$pr-sequential-writer",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9852,"^25",7,"^29",9852,"^24",27,"^2:",["^2;",["^2<",["^2;",[["^7K","~$print-one","~$begin","~$sep","^4Q","^2J","^2O"]]]]]],"^1:","~$cljs.core/pr-sequential-writer","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^7K","^>A","^>B","^>C","^4Q","^2J","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9852,"^29",9852,"^2G",7,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7K","^>A","^>B","^>C","^4Q","^2J","^2O"]]]]]],"~$simple-symbol?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3344,"^25",16,"^29",3344,"^24",30,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a symbol without a namespace"],"^1:","~$cljs.core/simple-symbol?","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3344,"^3=","^3:","^29",3344,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a symbol without a namespace"],"~$accumulating-seq-count",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1794,"^25",8,"^29",1794,"^24",30,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^59",true,"^1:","~$cljs.core/accumulating-seq-count","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1794,"^29",1794,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"~$IIndexed",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",592,"^25",14,"^29",592,"^24",22,"^2A","Protocol for collections to provide indexed-based access to their items.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-nth",[["^2O","~$n"],["^2O","~$n","^73"]]]]],"^2S",true,"^1:","^5B","^23","cljs/core.cljs","^24",22,"^25",1,"^28",592,"^2U",["^ ","^2V",["^ ","^>J",[["^2O","~$n"],["^2O","~$n","^73"]]]],"^30",null,"^29",592,"^31","^32","^33",["^19",["^34","^5F","^4Y","^4Z","^4[","^50","^:G","~$cljs.core/Range","^52"]],"^2A","Protocol for collections to provide indexed-based access to their items.","^2T",["^2;",["@interface"]]],"~$disj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2079,"^25",7,"^29",2079,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]]]],"^2A","disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s).","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2O"],["^2O","~$k"]]],"^2:",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/disj","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2O"],["^2O","~$k"]]],"^2:",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["^2O"],["^2O","~$k"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2079,"^29",2079,"^2G",2,"^2H",true,"^2:",["^2;",[["^2O"],["^2O","~$k"],["^2O","~$k","~$&","^8J"]]],"^2A","disj[oin]. Returns a new set of the same (hashed/sorted) type, that\n does not contain key(s)."],"~$MultiIterator",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/MultiIterator","^23","cljs/core.cljs","^24",23,"^3W",true,"^25",10,"^28",4070,"^3X",false,"^29",4070,"^31","^3Y","^2@",null],"~$IPrintWithWriter",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",757,"^25",14,"^29",757,"^24",30,"^2A","The old IPrintable protocol's implementation consisted of building a giant\n list of strings to concatenate. This involved lots of concat calls,\n intermediate vectors, and lazy-seqs, and was very slow in some older JS\n engines. IPrintWithWriter implements printing via the IWriter protocol, so it\n be implemented efficiently in terms of e.g. a StringBuffer append.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-pr-writer",[["~$o","^7K","^2J"]]]]],"^2S",true,"^1:","^5N","^23","cljs/core.cljs","^24",30,"^25",1,"^28",757,"^2U",["^ ","^2V",["^ ","^>Q",[["~$o","^7K","^2J"]]]],"^30",null,"^29",757,"^31","^32","^33",["^19",["^4V","^4W","~$cljs.core/Cons","~$cljs.core/Eduction","^4X","^9[","~$cljs.core/PersistentQueue","^5F","^3V","~$cljs.core/Keyword","^4Y","^4Z","~$cljs.core/EmptyList","^8?","^4[","~$cljs.core/PersistentQueueSeq","~$cljs.core/ExceptionInfo","^4F","~$cljs.core/ArrayNodeSeq","~$cljs.core/ValSeq","^7C","~$cljs.core/Cycle","^<:","^;V","^50","~$cljs.core/List","~$cljs.core/Repeat","~$cljs.core/TransformerIterator","~$cljs.core/RSeq","~$cljs.core/Iterate","^7E","^51","~$cljs.core/KeySeq","~$cljs.core/ChunkedSeq","~$cljs.core/Atom","^7F","~$cljs.core/ChunkedCons","^K","^9>","^52"]],"^2A","The old IPrintable protocol's implementation consisted of building a giant\n list of strings to concatenate. This involved lots of concat calls,\n intermediate vectors, and lazy-seqs, and was very slow in some older JS\n engines. IPrintWithWriter implements printing via the IWriter protocol, so it\n be implemented efficiently in terms of e.g. a StringBuffer append.","^2T",["^2;",["@interface"]]],"~$->UUID",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1U","^5N","^6S","^41"]],"^23","cljs/core.cljs","^24",14,"^25",10,"^26","^27","^28",11068,"^29",11068,"^2:",["^2;",["^2<",["^2;",[["^3N","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^5N","^6S"]],"^2A","Positional factory function for cljs.core/UUID."],"^1O",["^19",["^1P","^1Q","^1U","^5N","^6S","^41"]],"^1:","~$cljs.core/->UUID","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^3N","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",11068,"^29",11068,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3N","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^5N","^6S"]],"^2A","Positional factory function for cljs.core/UUID."],"~$IVector",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",666,"^25",14,"^29",666,"^24",21,"^2A","Protocol for adding vector functionality to collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-assoc-n",[["^2O","~$n","^2Z"]]]]],"^2S",true,"^1:","^8S","^23","cljs/core.cljs","^24",21,"^25",1,"^28",666,"^2U",["^ ","^2V",["^ ","^?<",[["^2O","~$n","^2Z"]]]],"^30",null,"^29",666,"^31","^32","^33",["^19",["^4Y","^4Z","^4[","^50","^52"]],"^2A","Protocol for adding vector functionality to collections.","^2T",["^2;",["@interface"]]],"~$IIterable",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",865,"^25",14,"^29",865,"^24",23,"^2A","Protocol for iterating over a collection.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^6C",[["^2O"]]]]],"^2S",true,"^1:","^20","^23","cljs/core.cljs","^24",23,"^25",1,"^28",865,"^2U",["^ ","^2V",["^ ","^6C",[["^2O"]]]],"^30",null,"^29",865,"^31","^32","^33",["^19",["^4V","^>S","^4X","^>T","^5F","^4[","^50","~$cljs.core/ArrayNode","^7E","~$cljs.core/HashCollisionNode","^>K","~$cljs.core/BitmapIndexedNode"]],"^2A","Protocol for iterating over a collection.","^2T",["^2;",["@interface"]]],"~$->MultiIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",23,"^25",10,"^26","^27","^28",4070,"^29",4070,"^2:",["^2;",["^2<",["^2;",[["~$iters"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/MultiIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->MultiIterator","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^?B"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4070,"^29",4070,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^?B"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/MultiIterator."],"~$*2",["^ ","^1:","~$cljs.core/*2","^23","cljs/core.cljs","^28",203,"^25",1,"^29",205,"^24",5,"^2A","bound in a repl thread to the second most recent value printed","^1N",["^ ","^23","cljs/core.cljs","^28",205,"^25",3,"^29",205,"^24",5,"^2A","bound in a repl thread to the second most recent value printed"]],"^J",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11534,"^25",7,"^29",11534,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$form"]]]]],"^2A","Evaluates the form data structure (not text!) and returns the result.\n Delegates to cljs.core/*eval*. Intended for use in self-hosted ClojureScript,\n which sets up an implementation of cljs.core/*eval* for that environment."],"^1:","~$cljs.core/eval","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^?F"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11534,"^29",11534,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^?F"]]]]],"^2A","Evaluates the form data structure (not text!) and returns the result.\n Delegates to cljs.core/*eval*. Intended for use in self-hosted ClojureScript,\n which sets up an implementation of cljs.core/*eval* for that environment."],"~$Eduction",["^ ","^3S",2,"^1O",["^19",["^1U","^1Y","^5N","^20","^4K","^5E"]],"^1:","^>S","^23","cljs/core.cljs","^24",18,"^3W",true,"^25",10,"^28",10469,"^3X",false,"^29",10469,"^31","^3Y","^2@",["^19",["^1Y","^5N","^20","^4K","^5E"]]],"~$pv-clone-node",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5306,"^25",8,"^29",5306,"^24",21,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^84"]]]]]],"^59",true,"^1:","~$cljs.core/pv-clone-node","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^84"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5306,"^29",5306,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^84"]]]]]],"~$cons",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3251,"^25",7,"^29",3251,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$x","^2O"]]]]],"^2A","Returns a new seq where x is the first element and coll is the rest."],"^1:","~$cljs.core/cons","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$x","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3251,"^29",3251,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","^2O"]]]]],"^2A","Returns a new seq where x is the first element and coll is the rest."],"~$PersistentTreeSet",["^ ","^3S",3,"^1O",["^19",["^5C","^1P","^1Q","^1R","^1S","^1U","^1V","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^22"]],"^1:","^7F","^23","cljs/core.cljs","^24",27,"^3W",true,"^25",10,"^28",9200,"^3X",false,"^29",9200,"^31","^3Y","^2@",["^19",["^5C","^1P","^1Q","^1R","^1S","^1V","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^22"]]],"~$->HashSetIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",21,"^25",10,"^26","^27","^28",9032,"^29",9032,"^2:",["^2;",["^2<",["^2;",[["^4A"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/HashSetIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->HashSetIter","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^4A"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",9032,"^29",9032,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4A"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/HashSetIter."],"~$ns-lookup",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11378,"^25",8,"^29",11378,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$ns-obj","~$k"]]]]],"^2A","Bootstrap only."],"^59",true,"^1:","~$cljs.core/ns-lookup","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^?Q","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11378,"^29",11378,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^?Q","~$k"]]]]],"^2A","Bootstrap only."],"~$floats",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2802,"^25",7,"^29",2802,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/floats","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2802,"^29",2802,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$TransientVector",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",5427,"^25",44,"^29",5427,"^24",59,"^5A",true],"^3S",4,"^1O",["^19",["^5B","^1R","^1X","~$cljs.core/ITransientCollection","~$cljs.core/ITransientVector","^2[","^22"]],"^1:","^34","^23","cljs/core.cljs","^24",25,"^3W",true,"^25",10,"^28",5973,"^3X",false,"^5A",true,"^29",5973,"^31","^3Y","^2@",["^19",["^5B","^1R","^1X","^?V","^?W","^2[","^22"]]],"~$pos?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2912,"^25",16,"^29",2912,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if num is greater than zero, else false"],"^1:","~$cljs.core/pos?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2912,"^3=","^3:","^29",2912,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if num is greater than zero, else false"],"~$fnil",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4288,"^25",7,"^29",4288,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]]]],"^2A","Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched.","^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]],"^2:",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/fnil","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]],"^2:",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",4288,"^29",4288,"^2G",4,"^2H",true,"^2:",["^2;",[["~$f","~$x"],["~$f","~$x","~$y"],["~$f","~$x","~$y","~$z"]]],"^2A","Takes a function f, and returns a function that calls f, replacing\n a nil first argument to f with the supplied value x. Higher arity\n versions can replace arguments in the second and third\n positions (y, z). Note that the function f can take any number of\n arguments, not just the one(s) being nil-patched."],"~$merge-with",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8998,"^25",7,"^29",8998,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$f","~$&","~$maps"]]]]],"^2A","Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter).","^2K",["^ ","^2C",true,"^2G",1,"^2D",[["^2;",["~$f","^@1"]]],"^2:",["^2;",[["~$f","~$&","^@1"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/merge-with","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",1,"^2D",[["^2;",["~$f","^@1"]]],"^2:",["^2;",[["~$f","~$&","^@1"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["~$f","^@1"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",8998,"^29",8998,"^2G",1,"^2H",true,"^2:",["^2;",[["~$f","~$&","^@1"]]],"^2A","Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping(s)\n from the latter (left-to-right) will be combined with the mapping in\n the result by calling (f val-in-result val-in-latter)."],"~$nthrest",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1909,"^25",7,"^29",1909,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^2O","~$n"]]]]],"^2A","Returns the nth rest of coll, coll when n is 0."],"^1:","~$cljs.core/nthrest","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1909,"^29",1909,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$n"]]]]],"^2A","Returns the nth rest of coll, coll when n is 0."],"~$*warn-on-infer*",["^ ","^1:","~$cljs.core/*warn-on-infer*","^23","cljs/core.cljs","^28",33,"^25",1,"^29",33,"^24",21,"^1N",["^ ","^23","cljs/core.cljs","^28",33,"^25",6,"^29",33,"^24",21],"^31","^3:"],"^4T",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",636,"^25",4,"^29",636,"^24",9,"^5Y","^4U","^2A","Returns the map entry for key, or nil if key not present.","^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]]],"^5Y","^4U","^1:","~$cljs.core/-find","^2C",false,"^23","cljs/core.cljs","^24",9,"^2D",["^2;",[["^2O","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",634,"^29",636,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]],"^2A","Returns the map entry for key, or nil if key not present."],"~$sequential?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2121,"^25",16,"^29",2121,"^24",27,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll satisfies ISequential"],"^1:","~$cljs.core/sequential?","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2121,"^3=","^3:","^29",2121,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll satisfies ISequential"],"~$tree-map-replace",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8625,"^25",8,"^29",8625,"^24",24,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2P","^5R","~$k","~$v"]]]]]],"^59",true,"^1:","~$cljs.core/tree-map-replace","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^2P","^5R","~$k","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8625,"^29",8625,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2P","^5R","~$k","~$v"]]]]]],"~$checked-aset'",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",488,"^25",8,"^29",488,"^24",21,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^79","^7:","^2Z"],["^79","^7:","~$idx2","~$&","~$idxv"]]]]],"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/checked-aset'","^2C",true,"^23","cljs/core.cljs","^24",21,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",488,"^29",488,"^2G",3,"^2H",true,"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]]],"~$m3-mix-H1",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",917,"^25",15,"^29",917,"^24",24,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$h1","~$k1"]]]]]],"^1:","~$cljs.core/m3-mix-H1","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^@A","^@B"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",917,"^3=","^<","^29",917,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^@A","^@B"]]]]]],"~$RecordIter",["^ ","^3S",5,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/RecordIter","^23","cljs/core.cljs","^24",20,"^3W",true,"^25",10,"^28",6438,"^3X",false,"^29",6438,"^31","^3Y","^2@",null],"~$->TransientArrayMap",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1R","^:3","^1X","^?V","^2[","^22"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",6953,"^29",6953,"^2:",["^2;",["^2<",["^2;",[["~$editable?","^5<","^66"]]]]],"^2@",["^19",["^1R","^:3","^1X","^?V","^2[","^22"]],"^2A","Positional factory function for cljs.core/TransientArrayMap."],"^1O",["^19",["^1R","^:3","^1X","^?V","^2[","^22"]],"^1:","~$cljs.core/->TransientArrayMap","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^@G","^5<","^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6953,"^29",6953,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^@G","^5<","^66"]]]]],"^2@",["^19",["^1R","^:3","^1X","^?V","^2[","^22"]],"^2A","Positional factory function for cljs.core/TransientArrayMap."],"~$t_cljs$core10805",["^ ","^3S",1,"^1O",["^19",["^1U","^1Z","^21"]],"^1:","~$cljs.core/t_cljs$core10805","^23","cljs/core.cljs","^3W",true,"^8W",true,"^25",3,"^28",3961,"^3X",false,"^31","^3Y","^2@",["^19",["^1Z","^21"]]],"~$prim-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1656,"^25",7,"^29",1656,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$prim"],["^@L","~$i"]]]]],"^2A","Create seq from a primitive JavaScript Array-like.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^@L"],["^@L","~$i"]]],"^2:",["^2;",[["^@L"],["^@L","~$i"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/prim-seq","^2C",false,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^@L"],["^@L","~$i"]]],"^2:",["^2;",[["^@L"],["^@L","~$i"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^@L"],["^@L","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1656,"^29",1656,"^2G",2,"^2H",true,"^2:",["^2;",[["^@L"],["^@L","~$i"]]],"^2A","Create seq from a primitive JavaScript Array-like."],"~$*print-level*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",163,"^25",3,"^29",163,"^24",16,"^6F",true,"^2A","*print-level* controls how many levels deep the printer will\n print nested objects. If it is bound to logical false, there is no\n limit. Otherwise, it must be bound to an integer indicating the maximum\n level to print. Each argument to print is at level 0; if an argument is a\n collection, its items are at level 1; and so on. If an object is a\n collection and is at a level greater than or equal to the value bound to\n *print-level*, the printer prints '#' to represent it. The root binding\n is nil indicating no limit.","^2T",["@type {null|number}"]],"^1:","~$cljs.core/*print-level*","^23","cljs/core.cljs","^24",16,"^25",1,"^6F",true,"^28",152,"^29",163,"^31","^57","^2A","*print-level* controls how many levels deep the printer will\n print nested objects. If it is bound to logical false, there is no\n limit. Otherwise, it must be bound to an integer indicating the maximum\n level to print. Each argument to print is at level 0; if an argument is a\n collection, its items are at level 1; and so on. If an object is a\n collection and is at a level greater than or equal to the value bound to\n *print-level*, the printer prints '#' to represent it. The root binding\n is nil indicating no limit.","^2T",["@type {null|number}"]],"~$shuffle",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2455,"^25",7,"^29",2455,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Return a random permutation of coll"],"^1:","~$cljs.core/shuffle","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2455,"^29",2455,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Return a random permutation of coll"],"~$ChunkedSeq",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",2149,"^25",22,"^29",2149,"^24",32,"^5A",true],"^3S",6,"^1O",["^19",["^1P","^1Q","^5D","^1S","~$cljs.core/IChunkedNext","^1U","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21","^5E"]],"^1:","^?6","^23","cljs/core.cljs","^24",20,"^3W",true,"^25",10,"^28",5667,"^3X",false,"^5A",true,"^29",5667,"^31","^3Y","^2@",["^19",["^1P","^1Q","^5D","^1S","^@S","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21","^5E"]]],"~$hash-keyword",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3259,"^25",7,"^29",3259,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$k"]]]]]],"^1:","~$cljs.core/hash-keyword","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3259,"^29",3259,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$k"]]]]]],"~$find",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2328,"^25",7,"^29",2328,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]],"^2A","Returns the map entry for key, or nil if key not present."],"^1:","~$cljs.core/find","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^2O","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2328,"^29",2328,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]],"^2A","Returns the map entry for key, or nil if key not present."],"~$alength",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",511,"^25",15,"^29",511,"^24",22,"^31","^<","^2:",["^2;",["^2<",["^2;",[["^79"]]]]],"^2A","Returns the length of the array. Works on arrays of all types."],"^1:","~$cljs.core/alength","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^79"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",511,"^3=","^<","^29",511,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^79"]]]]],"^2A","Returns the length of the array. Works on arrays of all types."],"~$bit-xor",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2828,"^25",7,"^29",2828,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Bitwise exclusive or","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/bit-xor","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2828,"^29",2828,"^2G",2,"^2H",true,"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Bitwise exclusive or"],"~$->IndexedSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5B","^5C","^1P","^1Q","^5D","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",1568,"^29",1568,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^2="]]]]],"^2@",["^19",["^5B","^5C","^1P","^1Q","^5D","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/IndexedSeq."],"^1O",["^19",["^5B","^5C","^1P","^1Q","^5D","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^1:","~$cljs.core/->IndexedSeq","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^66","~$i","^2="]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1568,"^29",1568,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^2="]]]]],"^2@",["^19",["^5B","^5C","^1P","^1Q","^5D","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/IndexedSeq."],"~$->t_cljs$core10805",["^ ","^1M",null,"^1N",["^ ","^8W",true,"^1O",["^19",["^1U","^1Z","^21"]],"^2@",["^19",["^1Z","^21"]],"^26","^27","^2:",["^2;",["^2<",["^2;",[["~$meta10806"]]]]],"^2A","Positional factory function for cljs.core/t_cljs$core10805.","^23","cljs/core.cljs"],"^1O",["^19",["^1U","^1Z","^21"]],"^1:","~$cljs.core/->t_cljs$core10805","^2C",false,"^23","cljs/core.cljs","^2D",["^2;",[["^A3"]]],"^2E",null,"^2F",["^2;",[null,null]],"^8W",true,"^25",3,"^26","^27","^28",3961,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^A3"]]]]],"^2@",["^19",["^1Z","^21"]],"^2A","Positional factory function for cljs.core/t_cljs$core10805."],"~$ObjMap",["^ ","^3S",5,"^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^21","^7W","~$cljs.core/IMap","^22"]],"^1:","^4W","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",6321,"^3X",false,"^29",6321,"^31","^3Y","^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^21","^7W","^A6","^22"]]],"~$unsigned-bit-shift-right",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2888,"^25",7,"^29",2888,"^24",31,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Bitwise shift right with zero fill"],"^1:","~$cljs.core/unsigned-bit-shift-right","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2888,"^29",2888,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Bitwise shift right with zero fill"],"~$ES6SetEntriesIterator",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/ES6SetEntriesIterator","^23","cljs/core.cljs","^24",31,"^3W",true,"^25",10,"^28",6464,"^3X",false,"^29",6464,"^31","^3Y","^2@",null],"~$neg?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2921,"^25",16,"^29",2921,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if num is less than zero, else false"],"^1:","~$cljs.core/neg?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2921,"^3=","^3:","^29",2921,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if num is less than zero, else false"],"~$Cons",["^ ","^3S",4,"^1O",["^19",["~$cljs.core/IList","^1P","^1Q","^5D","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]],"^1:","^>R","^23","cljs/core.cljs","^24",14,"^3W",true,"^25",10,"^28",3194,"^3X",false,"^29",3194,"^31","^3Y","^2@",["^19",["^A>","^1P","^1Q","^5D","^1S","^1W","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]]],"~$-remove-method",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10832,"^25",4,"^29",10832,"^24",18,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-remove-method","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^7R","^7S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10832,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S"]]]]],"^2A",null],"~$->StringIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",3967,"^29",3967,"^2:",["^2;",["^2<",["^2;",[["~$s","~$i"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/StringIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->StringIter","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$s","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3967,"^29",3967,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s","~$i"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/StringIter."],"~$js-invoke",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",526,"^25",7,"^29",526,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^3;","~$s","~$&","~$args"]]]]],"^2A","Invoke JavaScript object method via string. Needed when the\n string is not a valid unquoted property name.","^2K",["^ ","^2C",true,"^2G",2,"^2D",[["^2;",["^3;","~$s","^AD"]]],"^2:",["^2;",[["^3;","~$s","~$&","^AD"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/js-invoke","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",2,"^2D",[["^2;",["^3;","~$s","^AD"]]],"^2:",["^2;",[["^3;","~$s","~$&","^AD"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^3;","~$s","^AD"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",526,"^29",526,"^2G",2,"^2H",true,"^2:",["^2;",[["^3;","~$s","~$&","^AD"]]],"^2A","Invoke JavaScript object method via string. Needed when the\n string is not a valid unquoted property name."],"~$->List",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^A>","^1P","^1Q","^5D","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",14,"^25",10,"^26","^27","^28",3017,"^29",3017,"^2:",["^2;",["^2<",["^2;",[["^2=","^6J","^;P","~$count","^2?"]]]]],"^2@",["^19",["^A>","^1P","^1Q","^5D","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/List."],"^1O",["^19",["^A>","^1P","^1Q","^5D","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^1:","~$cljs.core/->List","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2=","^6J","^;P","^AG","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3017,"^29",3017,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^6J","^;P","^AG","^2?"]]]]],"^2@",["^19",["^A>","^1P","^1Q","^5D","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/List."],"~$m3-mix-K1",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",914,"^25",15,"^29",914,"^24",24,"^31","^<","^2:",["^2;",["^2<",["^2;",[["^@B"]]]]]],"^1:","~$cljs.core/m3-mix-K1","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^@B"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",914,"^3=","^<","^29",914,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^@B"]]]]]],"~$Iterate",["^ ","^3S",5,"^1O",["^19",["^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","^?4","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",4976,"^3X",false,"^29",4976,"^31","^3Y","^2@",["^19",["^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$unchecked-float",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2693,"^25",15,"^29",2693,"^24",30,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/unchecked-float","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2693,"^3=","^<","^29",2693,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$undefined?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2207,"^25",16,"^29",2207,"^24",26,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x identical to the JavaScript undefined value."],"^1:","~$cljs.core/undefined?","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2207,"^3=","^3:","^29",2207,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x identical to the JavaScript undefined value."],"~$IMeta",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",679,"^25",14,"^29",679,"^24",19,"^2A","Protocol for accessing the metadata of an object.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-meta",[["~$o"]]]]],"^2S",true,"^1:","^1Z","^23","cljs/core.cljs","^24",19,"^25",1,"^28",679,"^2U",["^ ","^2V",["^ ","^AQ",[["~$o"]]]],"^30",null,"^29",679,"^31","^32","^33",["^19",["^4V","^4W","^>R","^4X","^9[","^>T","^5F","^4Y","^4Z","^>V","^8?","^4[","^>W","^4F","^>Y","^>Z","^>[","^;V","^50","^?0","^?1","^?3","^?4","^7E","^3Y","^51","^?5","^?6","^?7","^7F","^?8","^K","^9>","^52"]],"^2A","Protocol for accessing the metadata of an object.","^2T",["^2;",["@interface"]]],"~$reduced?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1426,"^25",16,"^29",1426,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$r"]]]]],"^2A","Returns true if x is the result of a call to reduced"],"^1:","~$cljs.core/reduced?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$r"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1426,"^3=","^3:","^29",1426,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$r"]]]]],"^2A","Returns true if x is the result of a call to reduced"],"~$apply-to",["^ ","^1M",null,"^1N",["^ ","^2:",["^2;",["^2<",["^2;",[["~$f","~$argc","^AD"]]]]],"^23","cljs/core.cljs"],"^1:","~$cljs.core/apply-to","^2C",false,"^23","cljs/core.cljs","^2D",["^2;",[["~$f","^AW","^AD"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3845,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f","^AW","^AD"]]]]]],"~$disj!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3830,"^25",7,"^29",3830,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2X","^2Z"],["^2X","^2Z","~$&","~$vals"]]]]],"^2A","disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s).","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2X","^2Z"]]],"^2:",["^2;",[["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/disj!","^2C",true,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2X","^2Z"]]],"^2:",["^2;",[["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2X","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3830,"^29",3830,"^2G",2,"^2H",true,"^2:",["^2;",[["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]],"^2A","disj[oin]. Returns a transient set of the same (hashed/sorted) type, that\n does not contain key(s)."],"^7B",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",621,"^25",4,"^29",621,"^24",11,"^5Y","^22","^2A","Use k to look up a value in o. If not-found is supplied and k is not\n a valid value that can be used for look up, not-found is returned.","^2:",["^2;",["^2<",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2:",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2F",["^2;",[null,null]]]],"^5Y","^22","^1:","~$cljs.core/-lookup","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2:",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",619,"^29",621,"^2G",3,"^2H",true,"^2:",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2A","Use k to look up a value in o. If not-found is supplied and k is not\n a valid value that can be used for look up, not-found is returned."],"~$float?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2301,"^25",16,"^29",2301,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true for JavaScript numbers, false otherwise."],"^1:","~$cljs.core/float?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2301,"^3=","^3:","^29",2301,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true for JavaScript numbers, false otherwise."],"~$ICloneable",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",565,"^25",14,"^29",565,"^24",24,"^2A","Protocol for cloning a value.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^<1",[["^4@"]]]]],"^2S",true,"^1:","^1[","^23","cljs/core.cljs","^24",24,"^25",1,"^28",565,"^2U",["^ ","^2V",["^ ","^<1",[["^4@"]]]],"^30",null,"^29",565,"^31","^32","^33",["^19",["^4V","^>R","^4X","^>T","^5F","^>V","^4[","^50","^?0","^?3","^7E","^51","^7F","^>K"]],"^2A","Protocol for cloning a value.","^2T",["^2;",["@interface"]]],"~$IEncodeClojure",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",10561,"^25",14,"^29",10561,"^24",28,"^2A",null,"^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^89",[["~$x","^8;"]]]]],"^2S",true,"^1:","^8:","^23","cljs/core.cljs","^24",28,"^25",1,"^28",10561,"^2U",["^ ","^2V",["^ ","^89",[["~$x","^8;"]]]],"^30",null,"^29",10561,"^31","^32","^33",["^19",[]],"^2A",null,"^2T",["^2;",["@interface"]]],"~$booleans",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2797,"^25",7,"^29",2797,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/booleans","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2797,"^29",2797,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$->ArrayList",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",19,"^25",10,"^26","^27","^28",9429,"^29",9429,"^2:",["^2;",["^2<",["^2;",[["^66"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ArrayList."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->ArrayList","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",9429,"^29",9429,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ArrayList."],"~$RSeq",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",1515,"^25",40,"^29",1515,"^24",44,"^5A",true],"^3S",3,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]],"^1:","^?3","^23","cljs/core.cljs","^24",14,"^3W",true,"^25",10,"^28",1673,"^3X",false,"^5A",true,"^29",1673,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]]],"~$mask",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7054,"^25",8,"^29",7054,"^24",12,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$hash","^=D"]]]]]],"^59",true,"^1:","~$cljs.core/mask","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^B;","^=D"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7054,"^29",7054,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^B;","^=D"]]]]]],"~$int-array",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3630,"^25",7,"^29",3630,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$size-or-seq"],["~$size","~$init-val-or-seq"]]]]],"^2A","Creates an array of ints. Does not coerce array, provided for compatibility\n with Clojure.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/int-array","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3630,"^29",3630,"^2G",2,"^2H",true,"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2A","Creates an array of ints. Does not coerce array, provided for compatibility\n with Clojure."],"~$find-and-cache-best-method",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10801,"^25",8,"^29",10801,"^24",34,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^:","^7S","^63","^61","~$prefer-table","^60","^62","~$default-dispatch-val"]]]]]],"^59",true,"^1:","~$cljs.core/find-and-cache-best-method","^2C",false,"^23","cljs/core.cljs","^24",34,"^2D",["^2;",[["^:","^7S","^63","^61","^BC","^60","^62","^BD"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10801,"^29",10801,"^2G",8,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:","^7S","^63","^61","^BC","^60","^62","^BD"]]]]]],"~$set?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2106,"^25",16,"^29",2106,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x satisfies ISet"],"^1:","~$cljs.core/set?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2106,"^3=","^3:","^29",2106,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x satisfies ISet"],"~$iterable?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1187,"^25",16,"^29",1187,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x implements IIterable protocol."],"^1:","~$cljs.core/iterable?","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1187,"^3=","^3:","^29",1187,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x implements IIterable protocol."],"~$cat",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10406,"^25",7,"^29",10406,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$rf"]]]]],"^2A","A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction.","^76","1.7"],"^76","1.7","^1:","~$cljs.core/cat","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^BK"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10406,"^29",10406,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^BK"]]]]],"^2A","A transducer which concatenates the contents of each input, which must be a\n collection, into the reduction."],"~$->ES6EntriesIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",28,"^25",10,"^26","^27","^28",6451,"^29",6451,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ES6EntriesIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->ES6EntriesIterator","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6451,"^29",6451,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ES6EntriesIterator."],"~$divide",["^ ","^1:","~$cljs.core/divide","^23","cljs/core.cljs","^28",2601,"^25",1,"^29",2601,"^24",16,"^5A",true,"^1N",["^ ","^23","cljs/core.cljs","^28",2601,"^25",10,"^29",2601,"^24",16,"^5A",true]],"~$js-reserved-arr",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",11254,"^25",3,"^29",11254,"^24",18,"^59",true,"^2T",["@type {*}"]],"^59",true,"^1:","~$cljs.core/js-reserved-arr","^23","cljs/core.cljs","^24",18,"^25",1,"^28",11251,"^29",11254,"^31","^79","^2T",["@type {*}"]],"^>Q",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",763,"^25",4,"^29",763,"^24",14,"^5Y","^5N","^2A",null,"^2:",["^2;",["^2<",["^2;",[["~$o","^7K","^2J"]]]]]],"^5Y","^5N","^1:","~$cljs.core/-pr-writer","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$o","^7K","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",757,"^29",763,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^7K","^2J"]]]]],"^2A",null],"~$flush",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9885,"^25",7,"^29",9885,"^24",12,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"^1:","~$cljs.core/flush","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9885,"^29",9885,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"~$set-from-indexed-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9298,"^25",7,"^29",9298,"^24",27,"^2:",["^2;",["^2<",["^2;",[["~$iseq"]]]]]],"^1:","~$cljs.core/set-from-indexed-seq","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^BW"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9298,"^29",9298,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^BW"]]]]]],"~$maybe-init-tapset",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11345,"^25",8,"^29",11345,"^24",25,"^59",true,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"^59",true,"^1:","~$cljs.core/maybe-init-tapset","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11345,"^29",11345,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"~$take-while",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9471,"^25",7,"^29",9471,"^24",17,"^2:",["^2;",["^2<",["^2;",[["^4<"],["^4<","^2O"]]]]],"^2A","Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/take-while","^2C",false,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9471,"^29",9471,"^2G",2,"^2H",true,"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2A","Returns a lazy sequence of successive items from coll while\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided."],"~$vary-meta",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3933,"^25",7,"^29",3933,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"],["^3;","~$f","~$a","~$b","~$c","~$d","~$&","^AD"]]]]],"^2A","Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata.","^2K",["^ ","^2C",true,"^2G",6,"^2D",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"]]],"^2:",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"],["^3;","~$f","~$a","~$b","~$c","~$d","~$&","^AD"]]],"^2F",["^2;",[null,null,null,null,null,null]]]],"^1:","~$cljs.core/vary-meta","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",6,"^2D",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"]]],"^2:",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"],["^3;","~$f","~$a","~$b","~$c","~$d","~$&","^AD"]]],"^2F",["^2;",[null,null,null,null,null,null]]],"^2D",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null,null]],"^25",1,"^28",3933,"^29",3933,"^2G",6,"^2H",true,"^2:",["^2;",[["^3;","~$f"],["^3;","~$f","~$a"],["^3;","~$f","~$a","~$b"],["^3;","~$f","~$a","~$b","~$c"],["^3;","~$f","~$a","~$b","~$c","~$d"],["^3;","~$f","~$a","~$b","~$c","~$d","~$&","^AD"]]],"^2A","Returns an object of the same type and value as obj, with\n (apply f (meta obj) args) as its metadata."],"~$INext",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",611,"^25",14,"^29",611,"^24",19,"^2A","Protocol for accessing the next items of a collection.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-next",[["^2O"]]]]],"^2S",true,"^1:","^4J","^23","cljs/core.cljs","^24",19,"^25",1,"^28",611,"^2U",["^ ","^2V",["^ ","^C4",[["^2O"]]]],"^30",null,"^29",611,"^31","^32","^33",["^19",["^>R","^9[","^5F","^>V","^8?","^>W","^>Y","^>Z","^>[","^;V","^?0","^?1","^?3","^?4","^?5","^?6","^?8","^>K","^9>"]],"^2A","Protocol for accessing the next items of a collection.","^2T",["^2;",["@interface"]]],"~$is_proto_",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",290,"^25",7,"^29",290,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/is_proto_","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",290,"^29",290,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$START",["^ ","^1:","~$cljs.core/START","^23","cljs/core.cljs","^28",3992,"^25",1,"^29",3992,"^24",11,"^1N",["^ ","^23","cljs/core.cljs","^28",3992,"^25",6,"^29",3992,"^24",11],"^31","^45"],"~$ICounted",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",570,"^25",14,"^29",570,"^24",22,"^2A","Protocol for adding the ability to count a collection in constant time.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^T","^5F","^4Y","^4Z","^>V","^4[","^35","~$cljs.core/ChunkBuffer","^;V","^50","^?0","^36","^?3","^7D","^7E","^51","^:G","^7F","^>K","^9>","^52"]],"^2A","Protocol for adding the ability to count a collection in constant time.","^2T",["^2;",["@interface"]]],"~$IMapEntry",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",644,"^25",14,"^29",644,"^24",23,"^2A","Protocol for examining a map entry.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-key",[["^2O"]],"~$-val",[["^2O"]]]]],"^2S",true,"^1:","^8U","^23","cljs/core.cljs","^24",23,"^25",1,"^28",644,"^2U",["^ ","^2V",["^ ","^C<",[["^2O"]],"^C=",[["^2O"]]]],"^30",null,"^29",644,"^31","^32","^33",["^19",["^4Y","^4Z","^52"]],"^2A","Protocol for examining a map entry.","^2T",["^2;",["@interface"]]],"~$pv-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5411,"^25",8,"^29",5411,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]]]],"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]],"^2:",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/pv-reduce","^2C",false,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]],"^2:",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5411,"^29",5411,"^2G",5,"^2H",true,"^2:",["^2;",[["^6>","~$f","^4P","^4Q"],["^6>","~$f","^97","^4P","^4Q"]]]],"~$<=",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2622,"^25",16,"^29",2622,"^24",18,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/<=","^2C",true,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2622,"^3=","^3:","^29",2622,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns non-nil if nums are in monotonically non-decreasing order,\n otherwise false."],"~$MODULE_INFOS",["^ ","^1:","~$cljs.core/MODULE_INFOS","^23","cljs/core.cljs","^28",40,"^25",1,"^29",40,"^24",18,"^1N",["^ ","^23","cljs/core.cljs","^28",40,"^25",6,"^29",40,"^24",18],"^31","^57"],"~$conj!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3789,"^25",7,"^29",3789,"^24",12,"^2:",["^2;",["^2<",["^2;",[[],["^2X"],["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]]]],"^2A","Adds val to the transient collection, and return tcoll. The 'addition'\n may happen at different 'places' depending on the concrete type.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["^2X"],["^2X","^2Z"]]],"^2:",["^2;",[[],["^2X"],["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/conj!","^2C",true,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["^2X"],["^2X","^2Z"]]],"^2:",["^2;",[[],["^2X"],["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["^2X"],["^2X","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",3789,"^29",3789,"^2G",2,"^2H",true,"^2:",["^2;",[[],["^2X"],["^2X","^2Z"],["^2X","^2Z","~$&","^AZ"]]],"^2A","Adds val to the transient collection, and return tcoll. The 'addition'\n may happen at different 'places' depending on the concrete type."],"~$-pop",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",662,"^25",9,"^29",662,"^24",13,"^31","^5X","^5Y","^8T","^2A","Returns a new stack without the item on top of the stack. Is used\n by cljs.core/pop.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^8T","^1:","~$cljs.core/-pop","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",656,"^3=","^5X","^29",662,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a new stack without the item on top of the stack. Is used\n by cljs.core/pop."],"~$array-index-of-identical?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6506,"^25",8,"^29",6506,"^24",33,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"^59",true,"^1:","~$cljs.core/array-index-of-identical?","^2C",false,"^23","cljs/core.cljs","^24",33,"^2D",["^2;",[["^66","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6506,"^29",6506,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"~$repeatedly",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4967,"^25",7,"^29",4967,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$n","~$f"]]]]],"^2A","Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$n","~$f"]]],"^2:",["^2;",[["~$f"],["~$n","~$f"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/repeatedly","^2C",false,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$n","~$f"]]],"^2:",["^2;",[["~$f"],["~$n","~$f"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f"],["~$n","~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4967,"^29",4967,"^2G",2,"^2H",true,"^2:",["^2;",[["~$f"],["~$n","~$f"]]],"^2A","Takes a function of no args, presumably with side effects, and\n returns an infinite (or length n if supplied) lazy sequence of calls\n to it"],"~$zipmap",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9399,"^25",7,"^29",9399,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$keys","^AZ"]]]]],"^2A","Returns a map with the keys mapped to the corresponding vals."],"^1:","~$cljs.core/zipmap","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^CM","^AZ"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9399,"^29",9399,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^CM","^AZ"]]]]],"^2A","Returns a map with the keys mapped to the corresponding vals."],"~$reset-vals!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4439,"^25",7,"^29",4439,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$a","~$new-value"]]]]],"^2A","Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset.","^76","1.9"],"^76","1.9","^1:","~$cljs.core/reset-vals!","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["~$a","^CP"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4439,"^29",4439,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$a","^CP"]]]]],"^2A","Sets the value of atom to newval. Returns [old new], the value of the\n atom before and after the reset."],"~$IStack",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",656,"^25",14,"^29",656,"^24",20,"^2A","Protocol for collections to provide access to their items as stacks. The top\n of the stack should be accessed in the most efficient way for the different\n data structures.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-peek",[["^2O"]],"^CF",[["^2O"]]]]],"^2S",true,"^1:","^8T","^23","cljs/core.cljs","^24",20,"^25",1,"^28",656,"^2U",["^ ","^2V",["^ ","^CS",[["^2O"]],"^CF",[["^2O"]]]],"^30",null,"^29",656,"^31","^32","^33",["^19",["^>T","^4Y","^4Z","^>V","^4[","^50","^?0","^52"]],"^2A","Protocol for collections to provide access to their items as stacks. The top\n of the stack should be accessed in the most efficient way for the different\n data structures.","^2T",["^2;",["@interface"]]],"~$-remove-watch",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",778,"^25",4,"^29",778,"^24",17,"^5Y","~$cljs.core/IWatchable","^2A","Removes watcher that corresponds to key from this.","^2:",["^2;",["^2<",["^2;",[["~$this","^2Y"]]]]]],"^5Y","^CU","^1:","~$cljs.core/-remove-watch","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^CV","^2Y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",771,"^29",778,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^CV","^2Y"]]]]],"^2A","Removes watcher that corresponds to key from this."],"~$IVolatile",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",859,"^25",14,"^29",859,"^24",23,"^2A","Protocol for adding volatile functionality.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-vreset!",[["~$o","^CP"]]]]],"^2S",true,"^1:","^3T","^23","cljs/core.cljs","^24",23,"^25",1,"^28",859,"^2U",["^ ","^2V",["^ ","^CY",[["~$o","^CP"]]]],"^30",null,"^29",859,"^31","^32","^33",["^19",["^3V"]],"^2A","Protocol for adding volatile functionality.","^2T",["^2;",["@interface"]]],"~$remove",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5128,"^25",7,"^29",5128,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^4<"],["^4<","^2O"]]]]],"^2A","Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/remove","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5128,"^29",5128,"^2G",2,"^2H",true,"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2A","Returns a lazy sequence of the items in coll for which\n (pred item) returns logical false. pred must be free of side-effects.\n Returns a transducer when no collection is provided."],"~$->BitmapIndexedNode",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U","^20"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",7145,"^29",7145,"^2:",["^2;",["^2<",["^2;",[["^=J","^:@","^66"]]]]],"^2@",["^19",["^20"]],"^2A","Positional factory function for cljs.core/BitmapIndexedNode."],"^1O",["^19",["^1U","^20"]],"^1:","~$cljs.core/->BitmapIndexedNode","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^=J","^:@","^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7145,"^29",7145,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^:@","^66"]]]]],"^2@",["^19",["^20"]],"^2A","Positional factory function for cljs.core/BitmapIndexedNode."],"~$*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2594,"^25",15,"^29",2594,"^24",16,"^31","^<","^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the product of nums. (*) returns 1.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/*","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",2594,"^3=","^<","^29",2594,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns the product of nums. (*) returns 1."],"~$re-pattern",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9841,"^25",7,"^29",9841,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Returns an instance of RegExp which has compiled the provided string."],"^1:","~$cljs.core/re-pattern","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9841,"^29",9841,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]],"^2A","Returns an instance of RegExp which has compiled the provided string."],"~$min",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2669,"^25",15,"^29",2669,"^24",18,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the least of the nums.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/min","^2C",true,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2669,"^3=","^<","^29",2669,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns the least of the nums."],"~$array-index-of-nil?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6478,"^25",8,"^29",6478,"^24",27,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66"]]]]]],"^59",true,"^1:","~$cljs.core/array-index-of-nil?","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6478,"^29",6478,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66"]]]]]],"~$-persistent!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",790,"^25",9,"^29",790,"^24",21,"^31","^5X","^5Y","^?V","^2A","Creates a persistent data structure from tcoll and returns it.","^2:",["^2;",["^2<",["^2;",[["^2X"]]]]]],"^5Y","^?V","^1:","~$cljs.core/-persistent!","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^2X"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",786,"^3=","^5X","^29",790,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2X"]]]]],"^2A","Creates a persistent data structure from tcoll and returns it."],"^>J",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",594,"^25",4,"^29",594,"^24",8,"^5Y","^5B","^2A","Returns the value at the index n in the collection coll.\n Returns not-found if index n is out of bounds and not-found is supplied.","^2:",["^2;",["^2<",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2F",["^2;",[null,null]]]],"^5Y","^5B","^1:","~$cljs.core/-nth","^2C",false,"^23","cljs/core.cljs","^24",8,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",592,"^29",594,"^2G",3,"^2H",true,"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2A","Returns the value at the index n in the collection coll.\n Returns not-found if index n is out of bounds and not-found is supplied."],"~$pop!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3824,"^25",7,"^29",3824,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2X"]]]]],"^2A","Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns tcoll"],"^1:","~$cljs.core/pop!","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^2X"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3824,"^29",3824,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2X"]]]]],"^2A","Removes the last item from a transient vector. If\n the collection is empty, throws an exception. Returns tcoll"],"~$chunk-append",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3590,"^25",7,"^29",3590,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$b","~$x"]]]]]],"^1:","~$cljs.core/chunk-append","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$b","~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3590,"^29",3590,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$b","~$x"]]]]]],"~$*unchecked-arrays*",["^ ","^1:","~$cljs.core/*unchecked-arrays*","^23","cljs/core.cljs","^28",30,"^25",1,"^29",30,"^24",24,"^1N",["^ ","^23","cljs/core.cljs","^28",30,"^25",6,"^29",30,"^24",24],"^31","^3:"],"~$prn-str",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10060,"^25",7,"^29",10060,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$&","^6Y"]]]]],"^2A","Same as pr-str followed by (newline)","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/prn-str","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^6Y"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10060,"^29",10060,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^6Y"]]],"^2A","Same as pr-str followed by (newline)"],"~$IReversible",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",728,"^25",14,"^29",728,"^24",25,"^2A","Protocol for reversing a seq.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-rseq",[["^2O"]]]]],"^2S",true,"^1:","^5C","^23","cljs/core.cljs","^24",25,"^25",1,"^28",728,"^2U",["^ ","^2V",["^ ","^DE",[["^2O"]]]],"^30",null,"^29",728,"^31","^32","^33",["^19",["^5F","^4Y","^4Z","^4[","^50","^51","^7F","^52"]],"^2A","Protocol for reversing a seq.","^2T",["^2;",["@interface"]]],"~$reversible?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3159,"^25",16,"^29",3159,"^24",27,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns true if coll satisfies? IReversible."],"^1:","~$cljs.core/reversible?","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3159,"^3=","^3:","^29",3159,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns true if coll satisfies? IReversible."],"~$-realized?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",768,"^25",13,"^29",768,"^24",23,"^31","^3:","^5Y","^8>","^2A","Returns true if a value for x has been produced, false otherwise.","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^5Y","^8>","^1:","~$cljs.core/-realized?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",765,"^3=","^3:","^29",768,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if a value for x has been produced, false otherwise."],"~$-add-watch",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",775,"^25",4,"^29",775,"^24",14,"^5Y","^CU","^2A","Adds a watcher function f to this. Keys must be unique per reference,\n and can be used to remove the watch with -remove-watch.","^2:",["^2;",["^2<",["^2;",[["^CV","^2Y","~$f"]]]]]],"^5Y","^CU","^1:","~$cljs.core/-add-watch","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^CV","^2Y","~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",771,"^29",775,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^CV","^2Y","~$f"]]]]],"^2A","Adds a watcher function f to this. Keys must be unique per reference,\n and can be used to remove the watch with -remove-watch."],"~$-deref-with-timeout",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",677,"^25",4,"^29",677,"^24",23,"^5Y","~$cljs.core/IDerefWithTimeout","^2A",null,"^2:",["^2;",["^2<",["^2;",[["~$o","~$msec","~$timeout-val"]]]]]],"^5Y","^DM","^1:","~$cljs.core/-deref-with-timeout","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$o","^DN","^DO"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",676,"^29",677,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^DN","^DO"]]]]],"^2A",null],"~$conj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1773,"^25",7,"^29",1773,"^24",11,"^2:",["^2;",["^2<",["^2;",[[],["^2O"],["^2O","~$x"],["^2O","~$x","~$&","^5:"]]]]],"^2A","conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item). The 'addition' may\n happen at different 'places' depending on the concrete type.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["^2O"],["^2O","~$x"]]],"^2:",["^2;",[[],["^2O"],["^2O","~$x"],["^2O","~$x","~$&","^5:"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/conj","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["^2O"],["^2O","~$x"]]],"^2:",["^2;",[[],["^2O"],["^2O","~$x"],["^2O","~$x","~$&","^5:"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["^2O"],["^2O","~$x"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",1773,"^29",1773,"^2G",2,"^2H",true,"^2:",["^2;",[[],["^2O"],["^2O","~$x"],["^2O","~$x","~$&","^5:"]]],"^2A","conj[oin]. Returns a new collection with the xs\n 'added'. (conj nil item) returns (item). The 'addition' may\n happen at different 'places' depending on the concrete type."],"~$-sorted-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",736,"^25",9,"^29",736,"^24",20,"^31","^5X","^5Y","^6U","^2A","Returns a sorted seq from coll in either ascending or descending order.","^2:",["^2;",["^2<",["^2;",[["^2O","^6V"]]]]]],"^5Y","^6U","^1:","~$cljs.core/-sorted-seq","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^2O","^6V"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",733,"^3=","^5X","^29",736,"^2G",2,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","^6V"]]]]],"^2A","Returns a sorted seq from coll in either ascending or descending order."],"~$flatten1",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5075,"^25",8,"^29",5075,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^;?"]]]]],"^2A","Take a collection of collections, and return a lazy seq\n of items from the inner collection"],"^59",true,"^1:","~$cljs.core/flatten1","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^;?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5075,"^29",5075,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;?"]]]]],"^2A","Take a collection of collections, and return a lazy seq\n of items from the inner collection"],"~$transduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2561,"^25",7,"^29",2561,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]]]],"^2A","reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items.","^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]],"^2:",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/transduce","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]],"^2:",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2561,"^29",2561,"^2G",4,"^2H",true,"^2:",["^2;",[["^5O","~$f","^2O"],["^5O","~$f","^97","^2O"]]],"^2A","reduce with a transformation of f (xf). If init is not\n supplied, (f) will be called to produce it. f should be a reducing\n step function that accepts both 1 and 2 arguments, if it accepts\n only 2 you can add the arity-1 with 'completing'. Returns the result\n of applying (the transformed) xf to init and the first item in coll,\n then applying xf to that result and the 2nd item, etc. If coll\n contains no items, returns init and f is not called. Note that\n certain transforms may inject or skip items."],"~$-swap!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",856,"^25",4,"^29",856,"^24",10,"^5Y","~$cljs.core/ISwap","^2A","Swaps the value of o to be (apply f current-value-of-atom args).","^2:",["^2;",["^2<",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]]]],"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]],"^2:",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]],"^2F",["^2;",[null,null,null,null]]]],"^5Y","^DZ","^1:","~$cljs.core/-swap!","^2C",false,"^23","cljs/core.cljs","^24",10,"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]],"^2:",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",854,"^29",856,"^2G",5,"^2H",true,"^2:",["^2;",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]],"^2A","Swaps the value of o to be (apply f current-value-of-atom args)."],"~$*print-length*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",150,"^25",3,"^29",150,"^24",17,"^6F",true,"^2A","*print-length* controls how many items of each collection the\n printer will print. If it is bound to logical false, there is no\n limit. Otherwise, it must be bound to an integer indicating the maximum\n number of items of each collection to print. If a collection contains\n more items, the printer will print items up to the limit followed by\n '...' to represent the remaining items. The root binding is nil\n indicating no limit.","^2T",["@type {null|number}"]],"^1:","~$cljs.core/*print-length*","^23","cljs/core.cljs","^24",17,"^25",1,"^6F",true,"^28",140,"^29",150,"^31","^57","^2A","*print-length* controls how many items of each collection the\n printer will print. If it is bound to logical false, there is no\n limit. Otherwise, it must be bound to an integer indicating the maximum\n number of items of each collection to print. If a collection contains\n more items, the printer will print items up to the limit followed by\n '...' to represent the remaining items. The root binding is nil\n indicating no limit.","^2T",["@type {null|number}"]],"~$js-delete",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2169,"^25",7,"^29",2169,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^3;","^2Y"]]]]],"^2A","Delete a property from a JavaScript object.\n Returns true upon success, false otherwise."],"^1:","~$cljs.core/js-delete","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^3;","^2Y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2169,"^29",2169,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^2Y"]]]]],"^2A","Delete a property from a JavaScript object.\n Returns true upon success, false otherwise."],"~$truth_",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",215,"^25",7,"^29",215,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Internal - do not use!"],"^1:","~$cljs.core/truth_","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",215,"^29",215,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Internal - do not use!"],"~$array-index-of",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6522,"^25",7,"^29",6522,"^24",21,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"^1:","~$cljs.core/array-index-of","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^66","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6522,"^29",6522,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"~$->MultiFn",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1Q","^1R","^7Q","^6","^BD","^63","^61","^BC","^60","^62"]]]]],"^2@",["^19",["^1Q","^1R","^7Q","^MultiFn","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^:","^>6","^BD","^63","^61","^BC","^60","^62"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",10843,"^29",10843,"^2G",8,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:","^>6","^BD","^63","^61","^BC","^60","^62"]]]]],"^2@",["^19",["^1Q","^1R","^7Q","^js",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10522,"^25",7,"^29",10522,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$k"],["~$k","~$primitive-fn"]]]]],"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$k"],["~$k","^E;"]]],"^2:",["^2;",[["~$k"],["~$k","^E;"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/key->js","^2C",false,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$k"],["~$k","^E;"]]],"^2:",["^2;",[["~$k"],["~$k","^E;"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$k"],["~$k","^E;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10522,"^29",10522,"^2G",2,"^2H",true,"^2:",["^2;",[["~$k"],["~$k","^E;"]]]],"~$IEncodeJS",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",10515,"^25",14,"^29",10515,"^24",23,"^2A",null,"^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-clj->js",[["~$x"]],"~$-key->js",[["~$x"]]]]],"^2S",true,"^1:","~$cljs.core/IEncodeJS","^23","cljs/core.cljs","^24",23,"^25",1,"^28",10515,"^2U",["^ ","^2V",["^ ","^E>",[["~$x"]],"^E?",[["~$x"]]]],"^30",null,"^29",10515,"^31","^32","^33",["^19",[]],"^2A",null,"^2T",["^2;",["@interface"]]],"~$new-path",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5315,"^25",8,"^29",5315,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^:5","^84"]]]]]],"^59",true,"^1:","~$cljs.core/new-path","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^=J","^:5","^84"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5315,"^29",5315,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^:5","^84"]]]]]],"~$compare-and-set!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4491,"^25",7,"^29",4491,"^24",23,"^2:",["^2;",["^2<",["^2;",[["~$a","~$oldval","^:U"]]]]],"^2A","Atomically sets the value of atom to newval if and only if the\n current value of the atom is equal to oldval. Returns true if\n set happened, else false."],"^1:","~$cljs.core/compare-and-set!","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$a","^ED","^:U"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4491,"^29",4491,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$a","^ED","^:U"]]]]],"^2A","Atomically sets the value of atom to newval if and only if the\n current value of the atom is equal to oldval. Returns true if\n set happened, else false."],"~$array-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1664,"^25",7,"^29",1664,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^79"],["^79","~$i"]]]]],"^2A","Create a seq from a JavaScript array.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^79"],["^79","~$i"]]],"^2:",["^2;",[["^79"],["^79","~$i"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/array-seq","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^79"],["^79","~$i"]]],"^2:",["^2;",[["^79"],["^79","~$i"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^79"],["^79","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1664,"^29",1664,"^2G",2,"^2H",true,"^2:",["^2;",[["^79"],["^79","~$i"]]],"^2A","Create a seq from a JavaScript array."],"~$array-copy-downward",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2183,"^25",8,"^29",2183,"^24",27,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$from","~$i","~$to","~$j","^5<"]]]]]],"^59",true,"^1:","~$cljs.core/array-copy-downward","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^EI","~$i","^EJ","~$j","^5<"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2183,"^29",2183,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^EI","~$i","^EJ","~$j","^5<"]]]]]],"~$pack-array-node",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7347,"^25",8,"^29",7347,"^24",23,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$array-node","^=J","^7:"]]]]]],"^59",true,"^1:","~$cljs.core/pack-array-node","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^EM","^=J","^7:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7347,"^29",7347,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^EM","^=J","^7:"]]]]]],"~$interleave",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5037,"^25",7,"^29",5037,"^24",17,"^2:",["^2;",["^2<",["^2;",[[],["^;<"],["^;<","^;="],["^;<","^;=","~$&","^;?"]]]]],"^2A","Returns a lazy seq of the first item in each coll, then the second etc.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["^;<"],["^;<","^;="]]],"^2:",["^2;",[[],["^;<"],["^;<","^;="],["^;<","^;=","~$&","^;?"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/interleave","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["^;<"],["^;<","^;="]]],"^2:",["^2;",[[],["^;<"],["^;<","^;="],["^;<","^;=","~$&","^;?"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["^;<"],["^;<","^;="]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",5037,"^29",5037,"^2G",2,"^2H",true,"^2:",["^2;",[[],["^;<"],["^;<","^;="],["^;<","^;=","~$&","^;?"]]],"^2A","Returns a lazy seq of the first item in each coll, then the second etc."],"~$print-map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10136,"^25",7,"^29",10136,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$m","^>A","^7K","^2J"]]]]]],"^1:","~$cljs.core/print-map","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$m","^>A","^7K","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10136,"^29",10136,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m","^>A","^7K","^2J"]]]]]],"~$map?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2133,"^25",16,"^29",2133,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies IMap"],"^1:","~$cljs.core/map?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2133,"^3=","^3:","^29",2133,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies IMap"],"~$m3-C1",["^ ","^1:","~$cljs.core/m3-C1","^23","cljs/core.cljs","^28",911,"^25",1,"^29",911,"^24",11,"^1N",["^ ","^23","cljs/core.cljs","^28",911,"^25",6,"^29",911,"^24",11],"^31","^<"],"~$get",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1917,"^25",7,"^29",1917,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]]]],"^2A","Returns the value mapped to key, not-found or nil if key not present.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2:",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/get","^2C",false,"^23","cljs/core.cljs","^24",10,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2:",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1917,"^29",1917,"^2G",3,"^2H",true,"^2:",["^2;",[["~$o","~$k"],["~$o","~$k","^73"]]],"^2A","Returns the value mapped to key, not-found or nil if key not present."],"~$identity",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2546,"^25",7,"^29",2546,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns its argument."],"^1:","~$cljs.core/identity","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2546,"^29",2546,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns its argument."],"~$into",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5159,"^25",7,"^29",5159,"^24",11,"^2:",["^2;",["^2<",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]]]],"^2A","Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined. A transducer may be supplied.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]],"^2:",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/into","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]],"^2:",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",5159,"^29",5159,"^2G",3,"^2H",true,"^2:",["^2;",[[],["^EJ"],["^EJ","^EI"],["^EJ","^5O","^EI"]]],"^2A","Returns a new coll consisting of to-coll with all of the items of\n from-coll conjoined. A transducer may be supplied."],"~$long",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2787,"^25",7,"^29",2787,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Coerce to long by stripping decimal places. Identical to `int'."],"^1:","~$cljs.core/long","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2787,"^29",2787,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Coerce to long by stripping decimal places. Identical to `int'."],"~$double",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2688,"^25",15,"^29",2688,"^24",21,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/double","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2688,"^3=","^<","^29",2688,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$volatile?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4531,"^25",16,"^29",4531,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a volatile."],"^1:","~$cljs.core/volatile?","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4531,"^3=","^3:","^29",4531,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a volatile."],"~$ChunkBuffer",["^ ","^3S",2,"^1O",["^19",["^1U","^1X"]],"^1:","^C:","^23","cljs/core.cljs","^24",21,"^3W",true,"^25",10,"^28",3464,"^3X",false,"^29",3464,"^31","^3Y","^2@",["^19",["^1X"]]],"~$HashSetIter",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/HashSetIter","^23","cljs/core.cljs","^24",21,"^3W",true,"^25",10,"^28",9032,"^3X",false,"^29",9032,"^31","^3Y","^2@",null],"^C<",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",646,"^25",4,"^29",646,"^24",8,"^5Y","^8U","^2A","Returns the key of the map entry.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^8U","^1:","~$cljs.core/-key","^2C",false,"^23","cljs/core.cljs","^24",8,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",644,"^29",646,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the key of the map entry."],"~$nfirst",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1746,"^25",7,"^29",1746,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (next (first x))"],"^1:","~$cljs.core/nfirst","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1746,"^29",1746,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (next (first x))"],"~$StringBufferWriter",["^ ","^3S",1,"^1O",["^19",["^9@"]],"^1:","~$cljs.core/StringBufferWriter","^23","cljs/core.cljs","^24",28,"^3W",true,"^25",10,"^28",872,"^3X",false,"^29",872,"^31","^3Y","^2@",["^19",["^9@"]]],"^2=",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2057,"^25",7,"^29",2057,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$o"]]]]],"^2A","Returns the metadata of obj, returns nil if there is no metadata."],"^1:","~$cljs.core/meta","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$o"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2057,"^29",2057,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o"]]]]],"^2A","Returns the metadata of obj, returns nil if there is no metadata."],"~$tv-editable-tail",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5926,"^25",8,"^29",5926,"^24",24,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$tl"]]]]]],"^59",true,"^1:","~$cljs.core/tv-editable-tail","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^FA"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5926,"^29",5926,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^FA"]]]]]],"^96",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",700,"^25",4,"^29",700,"^24",14,"^5Y","^98","^2A","Reduces an associative collection and returns the result. f should be\n a function that takes three arguments.","^2:",["^2;",["^2<",["^2;",[["^2O","~$f","^97"]]]]]],"^5Y","^98","^1:","~$cljs.core/-kv-reduce","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O","~$f","^97"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",697,"^29",700,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$f","^97"]]]]],"^2A","Reduces an associative collection and returns the result. f should be\n a function that takes three arguments."],"~$IHash",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",709,"^25",14,"^29",709,"^24",19,"^2A","Protocol for adding hashing functionality to a type.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-hash",[["~$o"]]]]],"^2S",true,"^1:","^1Q","^23","cljs/core.cljs","^24",19,"^25",1,"^28",709,"^2U",["^ ","^2V",["^ ","^FE",[["~$o"]]]],"^30",null,"^29",709,"^31","^32","^33",["^19",["~$cljs.core/Namespace","^4V","~$cljs.core/MultiFn","^4W","^>R","^4X","^9[","^>T","^5F","^>U","^4Y","^4Z","^>V","^8?","^4[","^>W","^4F","^>Y","^>Z","^7C","~$default","^;V","^50","^?0","^?1","^?3","^7E","^51","^?5","^?6","^?7","^7F","^?8","^K","^9>","^52"]],"^2A","Protocol for adding hashing functionality to a type.","^2T",["^2;",["@interface"]]],"~$bit-and-not",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2846,"^25",7,"^29",2846,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Bitwise and with complement","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/bit-and-not","^2C",true,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2846,"^29",2846,"^2G",2,"^2H",true,"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Bitwise and with complement"],"~$var?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1178,"^25",16,"^29",1178,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$v"]]]]],"^2A","Returns true if v is of type cljs.core.Var"],"^1:","~$cljs.core/var?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1178,"^3=","^3:","^29",1178,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$v"]]]]],"^2A","Returns true if v is of type cljs.core.Var"],"~$-comparator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",747,"^25",4,"^29",747,"^24",15,"^5Y","^6U","^2A","Returns the comparator for coll.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^6U","^1:","~$cljs.core/-comparator","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",733,"^29",747,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the comparator for coll."],"~$unchecked-add-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2703,"^25",15,"^29",2703,"^24",32,"^31","^<","^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the sum of nums. (+) returns 0.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/unchecked-add-int","^2C",true,"^23","cljs/core.cljs","^24",32,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",2703,"^3=","^<","^29",2703,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns the sum of nums. (+) returns 0."],"~$hash-ordered-coll",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1325,"^25",15,"^29",1325,"^24",32,"^31","^<","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://clojure.org/data_structures#hash for full algorithms."],"^1:","~$cljs.core/hash-ordered-coll","^2C",false,"^23","cljs/core.cljs","^24",32,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1325,"^3=","^<","^29",1325,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the hash code, consistent with =, for an external ordered\n collection implementing Iterable.\n See http://clojure.org/data_structures#hash for full algorithms."],"~$extend-object!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3005,"^25",8,"^29",3005,"^24",22,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^3;","~$fn-map"]]]]],"^2A","Takes a JavaScript object and a map of names to functions and\n attaches said functions as methods on the object. Any references to\n JavaScript's implicit this (via the this-as macro) will resolve to the\n object that the function is attached."],"^59",true,"^1:","~$cljs.core/extend-object!","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^3;","^FT"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3005,"^29",3005,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^FT"]]]]],"^2A","Takes a JavaScript object and a map of names to functions and\n attaches said functions as methods on the object. Any references to\n JavaScript's implicit this (via the this-as macro) will resolve to the\n object that the function is attached."],"~$do-assoc",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5368,"^25",8,"^29",5368,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>","^:5","^84","~$i","^2Z"]]]]]],"^59",true,"^1:","~$cljs.core/do-assoc","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^6>","^:5","^84","~$i","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5368,"^29",5368,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>","^:5","^84","~$i","^2Z"]]]]]],"~$reset-meta!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10319,"^25",7,"^29",10319,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$iref","~$m"]]]]],"^2A","Atomically resets the metadata for an atom"],"^1:","~$cljs.core/reset-meta!","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^FY","~$m"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10319,"^29",10319,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^FY","~$m"]]]]],"^2A","Atomically resets the metadata for an atom"],"~$->KeySeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",16,"^25",10,"^26","^27","^28",8838,"^29",8838,"^2:",["^2;",["^2<",["^2;",[["~$mseq","~$_meta"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/KeySeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->KeySeq","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^G0","^G1"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",8838,"^29",8838,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^G0","^G1"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/KeySeq."],"~$IEquiv",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",704,"^25",14,"^29",704,"^24",20,"^2A","Protocol for adding value comparison functionality to a type.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-equiv",[["~$o","~$other"]]]]],"^2S",true,"^1:","^1P","^23","cljs/core.cljs","^24",20,"^25",1,"^28",704,"^2U",["^ ","^2V",["^ ","^G4",[["~$o","^G5"]]]],"^30",null,"^29",704,"^31","^32","^33",["^19",["^FF","^4V","^4W","^>R","^4X","^9[","~$js/Date","^>T","^5F","^>U","^4Y","^4Z","^>V","^8?","^4[","^>W","^4F","^>Y","^>Z","^7C","^<","^FH","^;V","^50","^?0","^?1","^?3","^7E","^51","^?5","^?6","^?7","^7F","^?8","^K","^9>","^52"]],"^2A","Protocol for adding value comparison functionality to a type.","^2T",["^2;",["@interface"]]],"~$tree-map-kv-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8225,"^25",8,"^29",8225,"^24",26,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^84","~$f","^97"]]]]]],"^59",true,"^1:","~$cljs.core/tree-map-kv-reduce","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["^84","~$f","^97"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8225,"^29",8225,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^84","~$f","^97"]]]]]],"~$cycle",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4850,"^25",7,"^29",4850,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a lazy (infinite!) sequence of repetitions of the items in coll."],"^1:","~$cljs.core/cycle","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4850,"^29",4850,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a lazy (infinite!) sequence of repetitions of the items in coll."],"~$-deref",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",673,"^25",4,"^29",673,"^24",10,"^5Y","^3U","^2A","Returns the value of the reference o.","^2:",["^2;",["^2<",["^2;",[["~$o"]]]]]],"^5Y","^3U","^1:","~$cljs.core/-deref","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["~$o"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",671,"^29",673,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o"]]]]],"^2A","Returns the value of the reference o."],"~$pr-writer-ex-info",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11116,"^25",8,"^29",11116,"^24",25,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^7K","^2J"]]]]]],"^59",true,"^1:","~$cljs.core/pr-writer-ex-info","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^3;","^7K","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11116,"^29",11116,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^7K","^2J"]]]]]],"~$empty?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2093,"^25",16,"^29",2093,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns true if coll has no items - same as (not (seq coll)).\n Please use the idiom (seq x) rather than (not (empty? x))"],"^1:","~$cljs.core/empty?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2093,"^3=","^3:","^29",2093,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns true if coll has no items - same as (not (seq coll)).\n Please use the idiom (seq x) rather than (not (empty? x))"],"~$TaggedLiteral",["^ ","^3S",2,"^1O",["^19",["^1P","^1Q","^1U","^5N","^22"]],"^1:","^7C","^23","cljs/core.cljs","^24",23,"^3W",true,"^25",10,"^28",11209,"^3X",false,"^29",11209,"^31","^3Y","^2@",["^19",["^1P","^1Q","^5N","^22"]]],"~$short",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2686,"^25",15,"^29",2686,"^24",20,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/short","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2686,"^3=","^<","^29",2686,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^E>",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10516,"^25",4,"^29",10516,"^24",12,"^5Y","^E@","^2A","Recursively transforms clj values to JavaScript","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^5Y","^E@","^1:","~$cljs.core/-clj->js","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10515,"^29",10516,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Recursively transforms clj values to JavaScript"],"~$-chunked-first",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",829,"^25",4,"^29",829,"^24",18,"^5Y","^7H","^2A","Returns the first chunk in coll.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^7H","^1:","~$cljs.core/-chunked-first","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",827,"^29",829,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the first chunk in coll."],"~$add-tap",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11349,"^25",7,"^29",11349,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Adds f, a fn of one argument, to the tap set. This function will be called with\n anything sent via tap>. Remember f in order to remove-tap"],"^1:","~$cljs.core/add-tap","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11349,"^29",11349,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Adds f, a fn of one argument, to the tap set. This function will be called with\n anything sent via tap>. Remember f in order to remove-tap"],"~$filterv",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5191,"^25",7,"^29",5191,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects."],"^1:","~$cljs.core/filterv","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5191,"^29",5191,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns a vector of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects."],"~$->TaggedLiteral",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1U","^5N","^22"]],"^23","cljs/core.cljs","^24",23,"^25",10,"^26","^27","^28",11209,"^29",11209,"^2:",["^2;",["^2<",["^2;",[["~$tag","^?F"]]]]],"^2@",["^19",["^1P","^1Q","^5N","^22"]],"^2A","Positional factory function for cljs.core/TaggedLiteral."],"^1O",["^19",["^1P","^1Q","^1U","^5N","^22"]],"^1:","~$cljs.core/->TaggedLiteral","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^GM","^?F"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",11209,"^29",11209,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^GM","^?F"]]]]],"^2@",["^19",["^1P","^1Q","^5N","^22"]],"^2A","Positional factory function for cljs.core/TaggedLiteral."],"~$tv-editable-root",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5923,"^25",8,"^29",5923,"^24",24,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^84"]]]]]],"^59",true,"^1:","~$cljs.core/tv-editable-root","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^84"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5923,"^29",5923,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^84"]]]]]],"^B;",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",987,"^25",7,"^29",987,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$o"]]]]],"^2A","Returns the hash code of its argument. Note this is the hash code\n consistent with =."],"^1:","~$cljs.core/hash","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$o"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",987,"^29",987,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o"]]]]],"^2A","Returns the hash code of its argument. Note this is the hash code\n consistent with =."],"~$quot",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2816,"^25",7,"^29",2816,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","quot[ient] of dividing numerator by denominator."],"^1:","~$cljs.core/quot","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$n","~$d"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2816,"^29",2816,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","quot[ient] of dividing numerator by denominator."],"~$ns-interns*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11439,"^25",7,"^29",11439,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$sym"]]]]],"^2A","Returns a map of the intern mappings for the namespace.\n Bootstrap only."],"^1:","~$cljs.core/ns-interns*","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^GU"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11439,"^29",11439,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^GU"]]]]],"^2A","Returns a map of the intern mappings for the namespace.\n Bootstrap only."],"~$unchecked-double",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2694,"^25",15,"^29",2694,"^24",31,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/unchecked-double","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2694,"^3=","^<","^29",2694,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$*target*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^24",11,"^25",3,"^6F",true,"^28",48,"^5A",true,"^29",48,"^31","^90","^2A","Var bound to the name value of the compiler build :target option.\n For example, if the compiler build :target is :nodejs, *target* will be bound\n to \"nodejs\". *target* is a Google Closure define and can be set by compiler\n :closure-defines option."],"^1:","~$cljs.core/*target*","^23","cljs/core.cljs","^24",11,"^25",1,"^6F",true,"^28",42,"^5A",true,"^29",48,"^31","^90","^2A","Var bound to the name value of the compiler build :target option.\n For example, if the compiler build :target is :nodejs, *target* will be bound\n to \"nodejs\". *target* is a Google Closure define and can be set by compiler\n :closure-defines option."],"~$->ChunkedCons",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^5D","^1S","^@S","^1U","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21"]],"^23","cljs/core.cljs","^24",21,"^25",10,"^26","^27","^28",3513,"^29",3513,"^2:",["^2;",["^2<",["^2;",[["^:W","^6A","^2=","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^5D","^1S","^@S","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21"]],"^2A","Positional factory function for cljs.core/ChunkedCons."],"^1O",["^19",["^1P","^1Q","^5D","^1S","^@S","^1U","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21"]],"^1:","~$cljs.core/->ChunkedCons","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^:W","^6A","^2=","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3513,"^29",3513,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:W","^6A","^2=","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^5D","^1S","^@S","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21"]],"^2A","Positional factory function for cljs.core/ChunkedCons."],"~$ranged-iterator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5404,"^25",7,"^29",5404,"^24",22,"^2:",["^2;",["^2<",["^2;",[["~$v","^4P","^4Q"]]]]]],"^1:","~$cljs.core/ranged-iterator","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$v","^4P","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5404,"^29",5404,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$v","^4P","^4Q"]]]]]],"~$ITransientVector",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",804,"^25",14,"^29",804,"^24",30,"^2A","Protocol for adding vector functionality to transient collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-assoc-n!",[["^2X","~$n","^2Z"]],"~$-pop!",[["^2X"]]]]],"^2S",true,"^1:","^?W","^23","cljs/core.cljs","^24",30,"^25",1,"^28",804,"^2U",["^ ","^2V",["^ ","^H4",[["^2X","~$n","^2Z"]],"^H5",[["^2X"]]]],"^30",null,"^29",804,"^31","^32","^33",["^19",["^34"]],"^2A","Protocol for adding vector functionality to transient collections.","^2T",["^2;",["@interface"]]],"^2Y",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8909,"^25",7,"^29",8909,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$map-entry"]]]]],"^2A","Returns the key of the map entry."],"^1:","~$cljs.core/key","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^H6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8909,"^29",8909,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^H6"]]]]],"^2A","Returns the key of the map entry."],"~$longs",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2804,"^25",7,"^29",2804,"^24",12,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/longs","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2804,"^29",2804,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$not=",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3949,"^25",16,"^29",3949,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Same as (not (= obj1 obj2))","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/not=","^2C",true,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",3949,"^3=","^3:","^29",3949,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Same as (not (= obj1 obj2))"],"~$set-print-err-fn!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",90,"^25",7,"^29",90,"^24",24,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Set *print-err-fn* to f."],"^1:","~$cljs.core/set-print-err-fn!","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",90,"^29",90,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Set *print-err-fn* to f."],"~$string?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",265,"^25",16,"^29",265,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a JavaScript string."],"^1:","~$cljs.core/string?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",265,"^3=","^3:","^29",265,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a JavaScript string."],"~$uri?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11499,"^25",7,"^29",11499,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true x is a goog.Uri instance.","^76","1.9"],"^76","1.9","^1:","~$cljs.core/uri?","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11499,"^29",11499,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true x is a goog.Uri instance."],"~$es6-iterator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1286,"^25",7,"^29",1286,"^24",19,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","EXPERIMENTAL: Return a ES2015 compatible iterator for coll."],"^1:","~$cljs.core/es6-iterator","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1286,"^29",1286,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","EXPERIMENTAL: Return a ES2015 compatible iterator for coll."],"~$Delay",["^ ","^3S",2,"^1O",["^19",["^8>","^3U"]],"^1:","~$cljs.core/Delay","^23","cljs/core.cljs","^24",15,"^3W",true,"^25",10,"^28",10371,"^3X",false,"^29",10371,"^31","^3Y","^2@",["^19",["^8>","^3U"]]],"~$munge-str",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11296,"^25",8,"^29",11296,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^:"]]]]]],"^59",true,"^1:","~$cljs.core/munge-str","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11296,"^29",11296,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:"]]]]]],"~$pr-str-with-opts",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10024,"^25",7,"^29",10024,"^24",23,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]],"^2A","Prints a sequence of objects to a string, observing all the\n options given in opts"],"^1:","~$cljs.core/pr-str-with-opts","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^6Y","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10024,"^29",10024,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]],"^2A","Prints a sequence of objects to a string, observing all the\n options given in opts"],"~$->RecordIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",6438,"^29",6438,"^2:",["^2;",["^2<",["^2;",[["~$i","~$record","~$base-count","~$fields","~$ext-map-iter"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/RecordIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->RecordIter","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$i","^HK","^HL","^HM","^HN"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6438,"^29",6438,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$i","^HK","^HL","^HM","^HN"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/RecordIter."],"~$m3-C2",["^ ","^1:","~$cljs.core/m3-C2","^23","cljs/core.cljs","^28",912,"^25",1,"^29",912,"^24",11,"^1N",["^ ","^23","cljs/core.cljs","^28",912,"^25",6,"^29",912,"^24",11],"^31","^<"],"~$->Symbol",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1R","^1U","^Symbol","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^47","^:","^HS","^HT","^G1"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1060,"^29",1060,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^47","^:","^HS","^HT","^G1"]]]]],"^2@",["^19",["^1P","^1Q","^1R","^Cycle",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",15,"^25",10,"^26","^27","^28",4792,"^29",4792,"^2:",["^2;",["^2<",["^2;",[["^2=","~$all","~$prev","~$current","^;3"]]]]],"^2@",["^19",["^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Cycle."],"^1O",["^19",["^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->Cycle","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2=","^I?","^I@","^IA","^;3"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4792,"^29",4792,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^I?","^I@","^IA","^;3"]]]]],"^2@",["^19",["^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Cycle."],"~$*print-meta*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",122,"^25",3,"^29",122,"^24",15,"^6F",true,"^2A","If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false."],"^1:","~$cljs.core/*print-meta*","^23","cljs/core.cljs","^24",15,"^25",1,"^6F",true,"^28",116,"^29",122,"^31","^3:","^2A","If set to logical true, when printing an object, its metadata will also\n be printed in a form that can be read back by the reader.\n\n Defaults to false."],"~$-notify-watches",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",773,"^25",4,"^29",773,"^24",19,"^5Y","^CU","^2A","Calls all watchers with this, oldval and newval.","^2:",["^2;",["^2<",["^2;",[["^CV","^ED","^:U"]]]]]],"^5Y","^CU","^1:","~$cljs.core/-notify-watches","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^CV","^ED","^:U"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",771,"^29",773,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^CV","^ED","^:U"]]]]],"^2A","Calls all watchers with this, oldval and newval."],"~$MultiFn",["^ ","^3S",8,"^1O",["^19",["^1Q","^1R","^7Q","^ValSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",16,"^25",10,"^26","^27","^28",8914,"^29",8914,"^2:",["^2;",["^2<",["^2;",[["^G0","^G1"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/ValSeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->ValSeq","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^G0","^G1"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",8914,"^29",8914,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^G0","^G1"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/ValSeq."],"~$map-entry?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6650,"^25",16,"^29",6650,"^24",26,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x satisfies IMapEntry"],"^1:","~$cljs.core/map-entry?","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6650,"^3=","^3:","^29",6650,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x satisfies IMapEntry"],"~$rand",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10628,"^25",7,"^29",10628,"^24",11,"^2:",["^2;",["^2<",["^2;",[[],["~$n"]]]]],"^2A","Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive).","^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["~$n"]]],"^2:",["^2;",[[],["~$n"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/rand","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["~$n"]]],"^2:",["^2;",[[],["~$n"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[],["~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10628,"^29",10628,"^2G",1,"^2H",true,"^2:",["^2;",[[],["~$n"]]],"^2A","Returns a random floating point number between 0 (inclusive) and\n n (default 1) (exclusive)."],"~$second",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1736,"^25",7,"^29",1736,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (first (next x))"],"^1:","~$cljs.core/second","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1736,"^29",1736,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (first (next x))"],"~$find-ns-obj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11416,"^25",7,"^29",11416,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^47"]]]]],"^2A","Bootstrap only."],"^1:","~$cljs.core/find-ns-obj","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^47"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11416,"^29",11416,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^47"]]]]],"^2A","Bootstrap only."],"~$IEditableCollection",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",781,"^25",14,"^29",781,"^24",33,"^2A","Protocol for collections which can transformed to transients.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^><",[["^2O"]]]]],"^2S",true,"^1:","^1T","^23","cljs/core.cljs","^24",33,"^25",1,"^28",781,"^2U",["^ ","^2V",["^ ","^><",[["^2O"]]]],"^30",null,"^29",781,"^31","^32","^33",["^19",["^4V","^4W","^4X","^50","^7E"]],"^2A","Protocol for collections which can transformed to transients.","^2T",["^2;",["@interface"]]],"~$hash-combine",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1023,"^25",7,"^29",1023,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$seed","^B;"]]]]]],"^1:","~$cljs.core/hash-combine","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^IX","^B;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1023,"^29",1023,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^IX","^B;"]]]]]],"~$>",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2634,"^25",16,"^29",2634,"^24",17,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns non-nil if nums are in monotonically decreasing order,\n otherwise false.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/>","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2634,"^3=","^3:","^29",2634,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns non-nil if nums are in monotonically decreasing order,\n otherwise false."],"~$-name",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",841,"^25",12,"^29",841,"^24",17,"^31","^90","^5Y","^Subvec",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]],"^23","cljs/core.cljs","^24",16,"^25",10,"^26","^27","^28",5759,"^29",5759,"^2:",["^2;",["^2<",["^2;",[["^2=","~$v","^4P","^4Q","^2?"]]]]],"^2@",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]],"^2A","Positional factory function for cljs.core/Subvec."],"^1O",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]],"^1:","~$cljs.core/->Subvec","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2=","~$v","^4P","^4Q","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",5759,"^29",5759,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","~$v","^4P","^4Q","^2?"]]]]],"^2@",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]],"^2A","Positional factory function for cljs.core/Subvec."],"~$associative?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2113,"^25",16,"^29",2113,"^24",28,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements IAssociative"],"^1:","~$cljs.core/associative?","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2113,"^3=","^3:","^29",2113,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements IAssociative"],"~$unchecked-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2782,"^25",7,"^29",2782,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Coerce to int by stripping decimal places."],"^1:","~$cljs.core/unchecked-int","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2782,"^29",2782,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Coerce to int by stripping decimal places."],"~$js-keys",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2164,"^25",7,"^29",2164,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^3;"]]]]],"^2A","Return the JavaScript keys for an object."],"^1:","~$cljs.core/js-keys","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^3;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2164,"^29",2164,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;"]]]]],"^2A","Return the JavaScript keys for an object."],"~$inst-ms*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1378,"^25",4,"^29",1378,"^24",12,"^5Y","~$cljs.core/Inst","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^70"]]]]]],"^5Y","^J?","^1:","~$cljs.core/inst-ms*","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^70"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1377,"^29",1378,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^70"]]]]],"^2A",null],"~$ES6EntriesIterator",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/ES6EntriesIterator","^23","cljs/core.cljs","^24",28,"^3W",true,"^25",10,"^28",6451,"^3X",false,"^29",6451,"^31","^3Y","^2@",null],"~$keyword?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3302,"^25",16,"^29",3302,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a Keyword"],"^1:","~$cljs.core/keyword?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3302,"^3=","^3:","^29",3302,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a Keyword"],"~$array-iter",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3988,"^25",7,"^29",3988,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/array-iter","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3988,"^29",3988,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$force",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10387,"^25",7,"^29",10387,"^24",12,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","If x is a Delay, returns the (possibly cached) value of its expression, else returns x"],"^1:","~$cljs.core/force","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10387,"^29",10387,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","If x is a Delay, returns the (possibly cached) value of its expression, else returns x"],"~$group-by",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10645,"^25",7,"^29",10645,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$f","^2O"]]]]],"^2A","Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll."],"^1:","~$cljs.core/group-by","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$f","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10645,"^29",10645,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f","^2O"]]]]],"^2A","Returns a map of the elements of coll keyed by the result of\n f on each element. The value at each key will be a vector of the\n corresponding elements, in the order they appeared in coll."],"^DE",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",730,"^25",9,"^29",730,"^24",14,"^31","^5X","^5Y","^5C","^2A","Returns a seq of the items in coll in reversed order.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^5C","^1:","~$cljs.core/-rseq","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",728,"^3=","^5X","^29",730,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a seq of the items in coll in reversed order."],"~$prn",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10097,"^25",7,"^29",10097,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$&","^6Y"]]]]],"^2A","Same as pr followed by (newline).","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/prn","^2C",true,"^23","cljs/core.cljs","^24",10,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^6Y"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10097,"^29",10097,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^6Y"]]],"^2A","Same as pr followed by (newline)."],"~$tv-pop-tail",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5943,"^25",8,"^29",5943,"^24",19,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^8C","^:5","^84"]]]]]],"^59",true,"^1:","~$cljs.core/tv-pop-tail","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^8C","^:5","^84"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5943,"^29",5943,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^8C","^:5","^84"]]]]]],"^BD",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11057,"^25",7,"^29",11057,"^24",27,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, return it's default-dispatch-val."],"^1:","~$cljs.core/default-dispatch-val","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^87"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11057,"^29",11057,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, return it's default-dispatch-val."],"~$->Atom",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^CU","~$cljs.core/IAtom","^1P","^1Q","^1U","^1Z","^3U"]],"^23","cljs/core.cljs","^24",14,"^25",10,"^26","^27","^28",4375,"^29",4375,"^2:",["^2;",["^2<",["^2;",[["~$state","^2=","^8N","~$watches"]]]]],"^2@",["^19",["^CU","^JR","^1P","^1Q","^1Z","^3U"]],"^2A","Positional factory function for cljs.core/Atom."],"^1O",["^19",["^CU","^JR","^1P","^1Q","^1U","^1Z","^3U"]],"^1:","~$cljs.core/->Atom","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^JS","^2=","^8N","^JT"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4375,"^29",4375,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^JS","^2=","^8N","^JT"]]]]],"^2@",["^19",["^CU","^JR","^1P","^1Q","^1Z","^3U"]],"^2A","Positional factory function for cljs.core/Atom."],"~$PersistentHashMap",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",1959,"^25",10,"^29",1959,"^24",27,"^5A",true],"^3S",6,"^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22"]],"^1:","^4V","^23","cljs/core.cljs","^24",27,"^3W",true,"^25",10,"^28",7767,"^3X",false,"^5A",true,"^29",7767,"^31","^3Y","^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22"]]],"~$unchecked-multiply",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2733,"^25",15,"^29",2733,"^24",33,"^31","^<","^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the product of nums. (*) returns 1.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/unchecked-multiply","^2C",true,"^23","cljs/core.cljs","^24",33,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",2733,"^3=","^<","^29",2733,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns the product of nums. (*) returns 1."],"~$ArrayNodeSeq",["^ ","^3S",5,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","^>Y","^23","cljs/core.cljs","^24",22,"^3W",true,"^25",10,"^28",7688,"^3X",false,"^29",7688,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$even?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4206,"^25",16,"^29",4206,"^24",21,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns true if n is even, throws an exception if n is not an integer"],"^1:","~$cljs.core/even?","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4206,"^3=","^3:","^29",4206,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns true if n is even, throws an exception if n is not an integer"],"~$es6-iterator-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1303,"^25",7,"^29",1303,"^24",23,"^2:",["^2;",["^2<",["^2;",[["^4A"]]]]],"^2A","EXPERIMENTAL: Given an ES2015 compatible iterator return a seq."],"^1:","~$cljs.core/es6-iterator-seq","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^4A"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1303,"^29",1303,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4A"]]]]],"^2A","EXPERIMENTAL: Given an ES2015 compatible iterator return a seq."],"~$unchecked-dec",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2710,"^25",7,"^29",2710,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one less than x, an int."],"^1:","~$cljs.core/unchecked-dec","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2710,"^29",2710,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one less than x, an int."],"~$Inst",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",1377,"^25",14,"^29",1377,"^24",18,"^2A",null,"^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^J>",[["^70"]]]]],"^2S",true,"^1:","^J?","^23","cljs/core.cljs","^24",18,"^25",1,"^28",1377,"^2U",["^ ","^2V",["^ ","^J>",[["^70"]]]],"^30",null,"^29",1377,"^31","^32","^33",["^19",["^G6"]],"^2A",null,"^2T",["^2;",["@interface"]]],"~$hash-collision-node-find-index",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7481,"^25",8,"^29",7481,"^24",38,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","^67","^2Y"]]]]]],"^59",true,"^1:","~$cljs.core/hash-collision-node-find-index","^2C",false,"^23","cljs/core.cljs","^24",38,"^2D",["^2;",[["^66","^67","^2Y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7481,"^29",7481,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","^67","^2Y"]]]]]],"~$persistent-array-map-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6718,"^25",7,"^29",6718,"^24",31,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^G1"]]]]]],"^1:","~$cljs.core/persistent-array-map-seq","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["^66","~$i","^G1"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6718,"^29",6718,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^G1"]]]]]],"~$RangeIterator",["^ ","^3S",3,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/RangeIterator","^23","cljs/core.cljs","^24",23,"^3W",true,"^25",10,"^28",9526,"^3X",false,"^29",9526,"^31","^3Y","^2@",null],"~$tagged-literal?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11239,"^25",16,"^29",11239,"^24",31,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^4@"]]]]],"^2A","Return true if the value is the data representation of a tagged literal"],"^1:","~$cljs.core/tagged-literal?","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["^4@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11239,"^3=","^3:","^29",11239,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4@"]]]]],"^2A","Return true if the value is the data representation of a tagged literal"],"~$double-array",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3674,"^25",7,"^29",3674,"^24",19,"^2:",["^2;",["^2<",["^2;",[["^B>"],["^B?","^B@"]]]]],"^2A","Creates an array of doubles. Does not coerce array, provided for compatibility\n with Clojure.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/double-array","^2C",false,"^23","cljs/core.cljs","^24",19,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3674,"^29",3674,"^2G",2,"^2H",true,"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2A","Creates an array of doubles. Does not coerce array, provided for compatibility\n with Clojure."],"~$create-ns",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11452,"^25",7,"^29",11452,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^GU"],["^GU","^?Q"]]]]],"^2A","Create a new namespace named by the symbol. Bootstrap only.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^GU"],["^GU","^?Q"]]],"^2:",["^2;",[["^GU"],["^GU","^?Q"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/create-ns","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^GU"],["^GU","^?Q"]]],"^2:",["^2;",[["^GU"],["^GU","^?Q"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^GU"],["^GU","^?Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11452,"^29",11452,"^2G",2,"^2H",true,"^2:",["^2;",[["^GU"],["^GU","^?Q"]]],"^2A","Create a new namespace named by the symbol. Bootstrap only."],"~$->EmptyList",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^A>","^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",19,"^25",10,"^26","^27","^28",3091,"^29",3091,"^2:",["^2;",["^2<",["^2;",[["^2="]]]]],"^2@",["^19",["^A>","^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/EmptyList."],"^1O",["^19",["^A>","^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^1:","~$cljs.core/->EmptyList","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^2="]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3091,"^29",3091,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2="]]]]],"^2@",["^19",["^A>","^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/EmptyList."],"~$seq-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2439,"^25",8,"^29",2439,"^24",18,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/seq-reduce","^2C",false,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2439,"^29",2439,"^2G",3,"^2H",true,"^2:",["^2;",[["~$f","^2O"],["~$f","^2Z","^2O"]]]],"~$spread",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3730,"^25",7,"^29",3730,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$arglist"]]]]]],"^1:","~$cljs.core/spread","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^KF"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3730,"^29",3730,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^KF"]]]]]],"~$balance-left",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8140,"^25",8,"^29",8140,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","~$ins","~$right"]]]]]],"^59",true,"^1:","~$cljs.core/balance-left","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^2Y","^2Z","^KI","^KJ"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8140,"^29",8140,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^KI","^KJ"]]]]]],"~$rseq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3164,"^25",12,"^29",3164,"^24",16,"^31","^3P","^2:",["^2;",["^2<",["^2;",[["~$rev"]]]]],"^2A","Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil"],"^1:","~$cljs.core/rseq","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^KM"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3164,"^3=","^3P","^29",3164,"^2G",1,"^31","^3P","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^KM"]]]]],"^2A","Returns, in constant time, a seq of the items in rev (which\n can be a vector or sorted-map), in reverse order. If rev is empty returns nil"],"~$ex-cause",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11177,"^25",7,"^29",11177,"^24",15,"^2:",["^2;",["^2<",["^2;",[["^;S"]]]]],"^2A","Returns exception cause (an Error / ExceptionInfo) if ex is an\n ExceptionInfo.\n Otherwise returns nil."],"^1:","~$cljs.core/ex-cause","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^;S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11177,"^29",11177,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;S"]]]]],"^2A","Returns exception cause (an Error / ExceptionInfo) if ex is an\n ExceptionInfo.\n Otherwise returns nil."],"~$IReset",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",849,"^25",14,"^29",849,"^24",20,"^2A","Protocol for adding resetting functionality.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-reset!",[["~$o","^CP"]]]]],"^2S",true,"^1:","~$cljs.core/IReset","^23","cljs/core.cljs","^24",20,"^25",1,"^28",849,"^2U",["^ ","^2V",["^ ","^KR",[["~$o","^CP"]]]],"^30",null,"^29",849,"^31","^32","^33",["^19",[]],"^2A","Protocol for adding resetting functionality.","^2T",["^2;",["@interface"]]],"~$IEmptyableCollection",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",575,"^25",14,"^29",575,"^24",34,"^2A","Protocol for creating an empty collection.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^7=",[["^2O"]]]]],"^2S",true,"^1:","^1W","^23","cljs/core.cljs","^24",34,"^25",1,"^28",575,"^2U",["^ ","^2V",["^ ","^7=",[["^2O"]]]],"^30",null,"^29",575,"^31","^32","^33",["^19",["^4V","^4W","^>R","^4X","^9[","^>T","^5F","^4Y","^4Z","^>V","^8?","^4[","^>W","^>Y","^>Z","^>[","^;V","^50","^?0","^?1","^?3","^?4","^7E","^51","^?5","^?6","^7F","^?8","^>K","^9>","^52"]],"^2A","Protocol for creating an empty collection.","^2T",["^2;",["@interface"]]],"~$array-map-index-of",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6536,"^25",8,"^29",6536,"^24",26,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k"]]]]]],"^59",true,"^1:","~$cljs.core/array-map-index-of","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["~$m","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6536,"^29",6536,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k"]]]]]],"~$ex-message",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11170,"^25",7,"^29",11170,"^24",17,"^2:",["^2;",["^2<",["^2;",[["^;S"]]]]],"^2A","Returns the message attached to the given Error / ExceptionInfo object.\n For non-Errors returns nil."],"^1:","~$cljs.core/ex-message","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^;S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11170,"^29",11170,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;S"]]]]],"^2A","Returns the message attached to the given Error / ExceptionInfo object.\n For non-Errors returns nil."],"~$->NodeIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",23,"^25",11,"^26","^27","^28",7107,"^29",7107,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","~$next-entry","~$next-iter"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/NodeIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->NodeIterator","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^66","~$i","^KZ","^K["]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",2,"^26","^27","^28",7107,"^29",7107,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^KZ","^K["]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/NodeIterator."],"~$*print-fn-bodies*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",169,"^25",3,"^29",169,"^24",20,"^6F",true,"^2A","*print-fns-bodies* controls whether functions print their source or\n only their names."],"^1:","~$cljs.core/*print-fn-bodies*","^23","cljs/core.cljs","^24",20,"^25",1,"^6F",true,"^28",165,"^29",169,"^31","^3:","^2A","*print-fns-bodies* controls whether functions print their source or\n only their names."],"~$string-print",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9879,"^25",7,"^29",9879,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/string-print","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9879,"^29",9879,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$float",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2687,"^25",15,"^29",2687,"^24",20,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/float","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2687,"^3=","^<","^29",2687,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$IRecord",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",725,"^25",14,"^29",725,"^24",21,"^2A","Marker interface indicating a record object","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","~$cljs.core/IRecord","^23","cljs/core.cljs","^24",21,"^25",1,"^28",725,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",725,"^31","^32","^33",["^19",[]],"^2A","Marker interface indicating a record object","^2T",["^2;",["@interface"]]],"~$pr-str",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10055,"^25",7,"^29",10055,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$&","^6Y"]]]]],"^2A","pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/pr-str","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^6Y"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10055,"^29",10055,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^6Y"]]],"^2A","pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter."],"~$first-array-for-longvec",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5344,"^25",8,"^29",5344,"^24",31,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>"]]]]]],"^59",true,"^1:","~$cljs.core/first-array-for-longvec","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["^6>"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5344,"^29",5344,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>"]]]]]],"~$es6-set-entries-iterator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6473,"^25",7,"^29",6473,"^24",31,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^1:","~$cljs.core/es6-set-entries-iterator","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6473,"^29",6473,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"~$concat",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3739,"^25",7,"^29",3739,"^24",13,"^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","~$zs"]]]]],"^2A","Returns a lazy seq representing the concatenation of the elements in the supplied colls.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^L@"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/concat","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^L@"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",3739,"^29",3739,"^2G",2,"^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^L@"]]],"^2A","Returns a lazy seq representing the concatenation of the elements in the supplied colls."],"~$-methods",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10835,"^25",4,"^29",10835,"^24",12,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-methods","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^7R"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10835,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]],"^2A",null],"~$js-reserved",["^ ","^1:","~$cljs.core/js-reserved","^23","cljs/core.cljs","^28",11269,"^25",1,"^29",11271,"^24",14,"^2T",["@type {null|Object}"],"^1N",["^ ","^23","cljs/core.cljs","^28",11271,"^25",3,"^29",11271,"^24",14,"^2T",["@type {null|Object}"]],"^31","^57"],"~$IDerefWithTimeout",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",676,"^25",14,"^29",676,"^24",31,"^2A",null,"^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^DL",[["~$o","^DN","^DO"]]]]],"^2S",true,"^1:","^DM","^23","cljs/core.cljs","^24",31,"^25",1,"^28",676,"^2U",["^ ","^2V",["^ ","^DL",[["~$o","^DN","^DO"]]]],"^30",null,"^29",676,"^31","^32","^33",["^19",[]],"^2A",null,"^2T",["^2;",["@interface"]]],"~$symbol",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1094,"^25",7,"^29",1094,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^:"],["^47","^:"]]]]],"^2A","Returns a Symbol with the given namespace and name.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^:"],["^47","^:"]]],"^2:",["^2;",[["^:"],["^47","^:"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/symbol","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^:"],["^47","^:"]]],"^2:",["^2;",[["^:"],["^47","^:"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^:"],["^47","^:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1094,"^29",1094,"^2G",2,"^2H",true,"^2:",["^2;",[["^:"],["^47","^:"]]],"^2A","Returns a Symbol with the given namespace and name."],"~$to-array-2d",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3619,"^25",7,"^29",3619,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a (potentially-ragged) 2-dimensional array\n containing the contents of coll."],"^1:","~$cljs.core/to-array-2d","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3619,"^29",3619,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a (potentially-ragged) 2-dimensional array\n containing the contents of coll."],"~$Subvec",["^ ","^3S",5,"^1O",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]],"^1:","^4[","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",5759,"^3X",false,"^29",5759,"^31","^3Y","^2@",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]]],"~$ExceptionInfo",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11128,"^25",3,"^29",11128,"^24",16,"^2T",["@constructor"],"^2:",["^2;",["^2<",["^2;",[["~$message","~$data","~$cause"]]]]]],"^1:","^>X","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^LM","^LN","^LO"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11127,"^29",11128,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^LM","^LN","^LO"]]]]],"^2T",["@constructor"]],"~$mod",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2811,"^25",7,"^29",2811,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","Modulus of num and div. Truncates toward negative infinity."],"^1:","~$cljs.core/mod","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["~$n","~$d"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2811,"^29",2811,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","Modulus of num and div. Truncates toward negative infinity."],"~$ISet",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",651,"^25",14,"^29",651,"^24",18,"^2A","Protocol for adding set functionality to a collection.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-disjoin",[["^2O","~$v"]]]]],"^2S",true,"^1:","^1V","^23","cljs/core.cljs","^24",18,"^25",1,"^28",651,"^2U",["^ ","^2V",["^ ","^LS",[["^2O","~$v"]]]],"^30",null,"^29",651,"^31","^32","^33",["^19",["^7E","^7F"]],"^2A","Protocol for adding set functionality to a collection.","^2T",["^2;",["@interface"]]],"~$pop",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2071,"^25",7,"^29",2071,"^24",10,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item.\n Note - not the same as next/butlast."],"^1:","~$cljs.core/pop","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2071,"^29",2071,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","For a list or queue, returns a new list/queue without the first\n item, for a vector, returns a new vector without the last item.\n Note - not the same as next/butlast."],"~$IPending",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",765,"^25",14,"^29",765,"^24",22,"^2A","Protocol for types which can have a deferred realization. Currently only\n implemented by Delay and LazySeq.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^DH",[["~$x"]]]]],"^2S",true,"^1:","^8>","^23","cljs/core.cljs","^24",22,"^25",1,"^28",765,"^2U",["^ ","^2V",["^ ","^DH",[["~$x"]]]],"^30",null,"^29",765,"^31","^32","^33",["^19",["^HE","^8?","^>[","^?1","^?4"]],"^2A","Protocol for types which can have a deferred realization. Currently only\n implemented by Delay and LazySeq.","^2T",["^2;",["@interface"]]],"~$-entry-key",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",745,"^25",4,"^29",745,"^24",14,"^5Y","^6U","^2A","Returns the key for entry.","^2:",["^2;",["^2<",["^2;",[["^2O","~$entry"]]]]]],"^5Y","^6U","^1:","~$cljs.core/-entry-key","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O","^LX"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",733,"^29",745,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","^LX"]]]]],"^2A","Returns the key for entry."],"~$CHAR_MAP",["^ ","^1:","~$cljs.core/CHAR_MAP","^23","cljs/core.cljs","^28",335,"^25",1,"^29",336,"^24",11,"^2T",["@enum {string}"],"^1N",["^ ","^23","cljs/core.cljs","^28",336,"^25",3,"^29",336,"^24",11,"^2T",["@enum {string}"]],"^31","^45"],"~$pop-tail",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5378,"^25",8,"^29",5378,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>","^:5","^84"]]]]]],"^59",true,"^1:","~$cljs.core/pop-tail","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^6>","^:5","^84"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5378,"^29",5378,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>","^:5","^84"]]]]]],"~$dissoc!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3814,"^25",7,"^29",3814,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^2X","^2Y"],["^2X","^2Y","~$&","^8J"]]]]],"^2A","Returns a transient map that doesn't contain a mapping for key(s).","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2X","^2Y"]]],"^2:",["^2;",[["^2X","^2Y"],["^2X","^2Y","~$&","^8J"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/dissoc!","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["^2X","^2Y"]]],"^2:",["^2;",[["^2X","^2Y"],["^2X","^2Y","~$&","^8J"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2X","^2Y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3814,"^29",3814,"^2G",2,"^2H",true,"^2:",["^2;",[["^2X","^2Y"],["^2X","^2Y","~$&","^8J"]]],"^2A","Returns a transient map that doesn't contain a mapping for key(s)."],"~$reductions",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9719,"^25",7,"^29",9719,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]]]],"^2A","Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/reductions","^2C",false,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9719,"^29",9719,"^2G",3,"^2H",true,"^2:",["^2;",[["~$f","^2O"],["~$f","^97","^2O"]]],"^2A","Returns a lazy seq of the intermediate values of the reduction (as\n per reduce) of coll by f, starting with init."],"~$indexed?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1521,"^25",16,"^29",1521,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements nth in constant time"],"^1:","~$cljs.core/indexed?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1521,"^3=","^3:","^29",1521,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements nth in constant time"],"~$-",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2587,"^25",15,"^29",2587,"^24",16,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/-","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2587,"^3=","^<","^29",2587,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result."],"~$Cycle",["^ ","^3S",5,"^1O",["^19",["^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","^>[","^23","cljs/core.cljs","^24",15,"^3W",true,"^25",10,"^28",4792,"^3X",false,"^29",4792,"^31","^3Y","^2@",["^19",["^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"^G4",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",706,"^25",13,"^29",706,"^24",19,"^31","^3:","^5Y","^1P","^2A","Returns true if o and other are equal, false otherwise.","^2:",["^2;",["^2<",["^2;",[["~$o","^G5"]]]]]],"^5Y","^1P","^1:","~$cljs.core/-equiv","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$o","^G5"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",704,"^3=","^3:","^29",706,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^G5"]]]]],"^2A","Returns true if o and other are equal, false otherwise."],"~$->RangeIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",23,"^25",10,"^26","^27","^28",9526,"^29",9526,"^2:",["^2;",["^2<",["^2;",[["~$i","^4Q","^=?"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/RangeIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->RangeIterator","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$i","^4Q","^=?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",9526,"^29",9526,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$i","^4Q","^=?"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/RangeIterator."],"~$->ArrayNode",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U","^20"]],"^23","cljs/core.cljs","^24",19,"^25",10,"^26","^27","^28",7380,"^29",7380,"^2:",["^2;",["^2<",["^2;",[["^=J","^67","^66"]]]]],"^2@",["^19",["^20"]],"^2A","Positional factory function for cljs.core/ArrayNode."],"^1O",["^19",["^1U","^20"]],"^1:","~$cljs.core/->ArrayNode","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^=J","^67","^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7380,"^29",7380,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^67","^66"]]]]],"^2@",["^19",["^20"]],"^2A","Positional factory function for cljs.core/ArrayNode."],"~$assoc!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3802,"^25",7,"^29",3802,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^2X","^2Y","^2Z"],["^2X","^2Y","^2Z","~$&","~$kvs"]]]]],"^2A","When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll.","^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^2X","^2Y","^2Z"]]],"^2:",["^2;",[["^2X","^2Y","^2Z"],["^2X","^2Y","^2Z","~$&","^M@"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/assoc!","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^2X","^2Y","^2Z"]]],"^2:",["^2;",[["^2X","^2Y","^2Z"],["^2X","^2Y","^2Z","~$&","^M@"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2X","^2Y","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3802,"^29",3802,"^2G",3,"^2H",true,"^2:",["^2;",[["^2X","^2Y","^2Z"],["^2X","^2Y","^2Z","~$&","^M@"]]],"^2A","When applied to a transient map, adds mapping of key(s) to\n val(s). When applied to a transient vector, sets the val at index.\n Note - index must be <= (count vector). Returns coll."],"~$hash-set",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9321,"^25",7,"^29",9321,"^24",15,"^2:",["^2;",["^2<",["^2;",[[],["~$&","^CM"]]]]],"^2A","Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj.","^2K",["^ ","^2C",true,"^2G",0,"^2D",["^2;",[[]]],"^2:",["^2;",[[],["~$&","^CM"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/hash-set","^2C",true,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",true,"^2G",0,"^2D",["^2;",[[]]],"^2:",["^2;",[[],["~$&","^CM"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9321,"^29",9321,"^2G",0,"^2H",true,"^2:",["^2;",[[],["~$&","^CM"]]],"^2A","Returns a new hash set with supplied keys. Any equal keys are\n handled as if by repeated uses of conj."],"~$reduce-kv",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2534,"^25",7,"^29",2534,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$f","^97","^2O"]]]]],"^2A","Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals."],"^1:","~$cljs.core/reduce-kv","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$f","^97","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2534,"^29",2534,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f","^97","^2O"]]]]],"^2A","Reduces an associative collection. f should be a function of 3\n arguments. Returns the result of applying f to init, the first key\n and the first value in coll, then applying f to that result and the\n 2nd key and value, etc. If coll contains no entries, returns init\n and f is not called. Note that reduce-kv is supported on vectors,\n where the keys will be the ordinals."],"~$reset!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4423,"^25",7,"^29",4423,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$a","^CP"]]]]],"^2A","Sets the value of atom to newval without regard for the\n current value. Returns new-value."],"^1:","~$cljs.core/reset!","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["~$a","^CP"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4423,"^29",4423,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$a","^CP"]]]]],"^2A","Sets the value of atom to newval without regard for the\n current value. Returns new-value."],"^:",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9390,"^25",7,"^29",9390,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns the name String of a string, symbol or keyword."],"^1:","~$cljs.core/name","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9390,"^29",9390,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns the name String of a string, symbol or keyword."],"~$->RedNode",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^23","cljs/core.cljs","^24",17,"^25",10,"^26","^27","^28",8363,"^29",8363,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","~$left","^KJ","^2?"]]]]],"^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^2A","Positional factory function for cljs.core/RedNode."],"^1O",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^1:","~$cljs.core/->RedNode","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2Y","^2Z","^MJ","^KJ","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",8363,"^29",8363,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^MJ","^KJ","^2?"]]]]],"^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^2A","Positional factory function for cljs.core/RedNode."],"~$unchecked-array-for",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5352,"^25",8,"^29",5352,"^24",27,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>","~$i"]]]]]],"^59",true,"^1:","~$cljs.core/unchecked-array-for","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^6>","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5352,"^29",5352,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>","~$i"]]]]]],"~$Fn",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",534,"^25",14,"^29",534,"^24",16,"^2A","Marker protocol","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","^4E","^23","cljs/core.cljs","^24",16,"^25",1,"^28",534,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",534,"^31","^32","^33",["^19",["^4F","^3Y","^AR"]],"^2A","Marker protocol","^2T",["^2;",["@interface"]]],"~$ffirst",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1741,"^25",7,"^29",1741,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (first (first x))"],"^1:","~$cljs.core/ffirst","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1741,"^29",1741,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (first (first x))"],"~$->ArrayNodeIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",7360,"^29",7360,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^K["]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ArrayNodeIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->ArrayNodeIterator","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^66","~$i","^K["]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7360,"^29",7360,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","^K["]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ArrayNodeIterator."],"~$sorted-set",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9327,"^25",7,"^29",9327,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$&","^CM"]]]]],"^2A","Returns a new sorted set with supplied keys.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^CM"]]],"^2:",["^2;",[["~$&","^CM"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/sorted-set","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^CM"]]],"^2:",["^2;",[["~$&","^CM"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^CM"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",9327,"^29",9327,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^CM"]]],"^2A","Returns a new sorted set with supplied keys."],"~$pr-with-opts",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10041,"^25",8,"^29",10041,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]],"^2A","Prints a sequence of objects using string-print, observing all\n the options given in opts"],"^59",true,"^1:","~$cljs.core/pr-with-opts","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^6Y","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10041,"^29",10041,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]],"^2A","Prints a sequence of objects using string-print, observing all\n the options given in opts"],"~$PersistentTreeMap",["^ ","^3S",5,"^1O",["^19",["^5C","^98","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^7W","^A6","^22"]],"^1:","^51","^23","cljs/core.cljs","^24",27,"^3W",true,"^25",10,"^28",8634,"^3X",false,"^29",8634,"^31","^3Y","^2@",["^19",["^5C","^98","^1P","^1Q","^1R","^1S","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^7W","^A6","^22"]]],"~$strip-ns",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10104,"^25",8,"^29",10104,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$named"]]]]]],"^59",true,"^1:","~$cljs.core/strip-ns","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^MY"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10104,"^29",10104,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^MY"]]]]]],"~$->PersistentTreeMap",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5C","^98","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^7W","^A6","^22"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",8634,"^29",8634,"^2:",["^2;",["^2<",["^2;",[["^2P","^5R","^67","^2=","^2?"]]]]],"^2@",["^19",["^5C","^98","^1P","^1Q","^1R","^1S","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^7W","^A6","^22"]],"^2A","Positional factory function for cljs.core/PersistentTreeMap."],"^1O",["^19",["^5C","^98","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^7W","^A6","^22"]],"^1:","~$cljs.core/->PersistentTreeMap","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2P","^5R","^67","^2=","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",8634,"^29",8634,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2P","^5R","^67","^2=","^2?"]]]]],"^2@",["^19",["^5C","^98","^1P","^1Q","^1R","^1S","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^7W","^A6","^22"]],"^2A","Positional factory function for cljs.core/PersistentTreeMap."],"~$array-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1484,"^25",8,"^29",1484,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]]]],"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]],"^2:",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]],"^2F",["^2;",[null,null,null]]]],"^59",true,"^1:","~$cljs.core/array-reduce","^2C",false,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]],"^2:",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",1484,"^29",1484,"^2G",4,"^2H",true,"^2:",["^2;",[["^66","~$f"],["^66","~$f","^2Z"],["^66","~$f","^2Z","^7:"]]]],"~$counted?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1517,"^25",16,"^29",1517,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements count in constant time"],"^1:","~$cljs.core/counted?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1517,"^3=","^3:","^29",1517,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements count in constant time"],"~$tagged-literal",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11244,"^25",7,"^29",11244,"^24",21,"^2:",["^2;",["^2<",["^2;",[["^GM","^?F"]]]]],"^2A","Construct a data representation of a tagged literal from a\n tag symbol and a form."],"^1:","~$cljs.core/tagged-literal","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^GM","^?F"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11244,"^29",11244,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^GM","^?F"]]]]],"^2A","Construct a data representation of a tagged literal from a\n tag symbol and a form."],"^C",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10085,"^25",7,"^29",10085,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$&","^6Y"]]]]],"^2A","Same as print followed by (newline)","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/println","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^6Y"]]],"^2:",["^2;",[["~$&","^6Y"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^6Y"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10085,"^29",10085,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^6Y"]]],"^2A","Same as print followed by (newline)"],"~$assoc-in",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5241,"^25",7,"^29",5241,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$m",["~$k","~$&","^8J"],"~$v"]]]]],"^2A","Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created."],"^1:","~$cljs.core/assoc-in","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$m","~$p__1982","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5241,"^29",5241,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m",["~$k","~$&","^8J"],"~$v"]]]]],"^2A","Associates a value in a nested associative structure, where ks is a\n sequence of keys and v is the new value and returns a new nested structure.\n If any levels do not exist, hash-maps will be created."],"~$PersistentHashSet",["^ ","^3S",3,"^1O",["^19",["^1P","^1Q","^1R","^1S","^1T","^1U","^1V","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^22"]],"^1:","^7E","^23","cljs/core.cljs","^24",27,"^3W",true,"^25",10,"^28",9042,"^3X",false,"^29",9042,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1R","^1S","^1T","^1V","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^22"]]],"~$bit-test",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2871,"^25",16,"^29",2871,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Test bit at index n"],"^1:","~$cljs.core/bit-test","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2871,"^3=","^3:","^29",2871,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Test bit at index n"],"~$->Namespace",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1U"]],"^23","cljs/core.cljs","^24",19,"^25",10,"^26","^27","^28",11384,"^29",11384,"^2:",["^2;",["^2<",["^2;",[["^3;","^:"]]]]],"^2@",["^19",["^1P","^1Q"]],"^2A","Positional factory function for cljs.core/Namespace."],"^1O",["^19",["^1P","^1Q","^1U"]],"^1:","~$cljs.core/->Namespace","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^3;","^:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",11384,"^29",11384,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^:"]]]]],"^2@",["^19",["^1P","^1Q"]],"^2A","Positional factory function for cljs.core/Namespace."],"~$TransientHashMap",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",7033,"^25",10,"^29",7033,"^24",26,"^5A",true],"^3S",5,"^1O",["^19",["^1R","^:3","^1U","^1X","^?V","^2[","^22"]],"^1:","^35","^23","cljs/core.cljs","^24",26,"^3W",true,"^25",10,"^28",7942,"^3X",false,"^5A",true,"^29",7942,"^31","^3Y","^2@",["^19",["^1R","^:3","^1X","^?V","^2[","^22"]]],"~$->PersistentHashMap",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",7767,"^29",7767,"^2:",["^2;",["^2<",["^2;",[["^2=","^67","^3J","~$has-nil?","~$nil-val","^2?"]]]]],"^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22"]],"^2A","Positional factory function for cljs.core/PersistentHashMap."],"^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22"]],"^1:","~$cljs.core/->PersistentHashMap","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2=","^67","^3J","^NB","^NC","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7767,"^29",7767,"^2G",6,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^67","^3J","^NB","^NC","^2?"]]]]],"^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22"]],"^2A","Positional factory function for cljs.core/PersistentHashMap."],"~$array-extend-kv",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6539,"^25",8,"^29",6539,"^24",23,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k","~$v"]]]]]],"^59",true,"^1:","~$cljs.core/array-extend-kv","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^66","~$k","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6539,"^29",6539,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k","~$v"]]]]]],"~$ISwap",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",854,"^25",14,"^29",854,"^24",19,"^2A","Protocol for adding swapping functionality.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^DY",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]]]],"^2S",true,"^1:","^DZ","^23","cljs/core.cljs","^24",19,"^25",1,"^28",854,"^2U",["^ ","^2V",["^ ","^DY",[["~$o","~$f"],["~$o","~$f","~$a"],["~$o","~$f","~$a","~$b"],["~$o","~$f","~$a","~$b","^5:"]]]],"^30",null,"^29",854,"^31","^32","^33",["^19",[]],"^2A","Protocol for adding swapping functionality.","^2T",["^2;",["@interface"]]],"~$ChunkedCons",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",2149,"^25",10,"^29",2149,"^24",21,"^5A",true],"^3S",4,"^1O",["^19",["^1P","^1Q","^5D","^1S","^@S","^1U","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21"]],"^1:","^?8","^23","cljs/core.cljs","^24",21,"^3W",true,"^25",10,"^28",3513,"^3X",false,"^5A",true,"^29",3513,"^31","^3Y","^2@",["^19",["^1P","^1Q","^5D","^1S","^@S","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21"]]],"~$memoize",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10597,"^25",7,"^29",10597,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use."],"^1:","~$cljs.core/memoize","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10597,"^29",10597,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Returns a memoized version of a referentially transparent function. The\n memoized version of the function keeps a cache of the mapping from arguments\n to results and, when calls with the same arguments are repeated often, has\n higher performance at the expense of higher memory use."],"~$alter-meta!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10310,"^25",7,"^29",10310,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^FY","~$f","~$&","^AD"]]]]],"^2A","Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects","^2K",["^ ","^2C",true,"^2G",2,"^2D",[["^2;",["^FY","~$f","^AD"]]],"^2:",["^2;",[["^FY","~$f","~$&","^AD"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/alter-meta!","^2C",true,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",true,"^2G",2,"^2D",[["^2;",["^FY","~$f","^AD"]]],"^2:",["^2;",[["^FY","~$f","~$&","^AD"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^FY","~$f","^AD"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",10310,"^29",10310,"^2G",2,"^2H",true,"^2:",["^2;",[["^FY","~$f","~$&","^AD"]]],"^2A","Atomically sets the metadata for a namespace/var/ref/agent/atom to be:\n\n (apply f its-current-meta args)\n\n f must be free of side-effects"],"~$->StringBufferWriter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^9@"]],"^23","cljs/core.cljs","^24",28,"^25",10,"^26","^27","^28",872,"^29",872,"^2:",["^2;",["^2<",["^2;",[["~$sb"]]]]],"^2@",["^19",["^9@"]],"^2A","Positional factory function for cljs.core/StringBufferWriter."],"^1O",["^19",["^9@"]],"^1:","~$cljs.core/->StringBufferWriter","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["^NN"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",872,"^29",872,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^NN"]]]]],"^2@",["^19",["^9@"]],"^2A","Positional factory function for cljs.core/StringBufferWriter."],"~$zero?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2916,"^25",16,"^29",2916,"^24",21,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if num is zero, else false"],"^1:","~$cljs.core/zero?","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2916,"^3=","^3:","^29",2916,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if num is zero, else false"],"~$tv-ensure-editable",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5918,"^25",8,"^29",5918,"^24",26,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^84"]]]]]],"^59",true,"^1:","~$cljs.core/tv-ensure-editable","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["^=J","^84"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5918,"^29",5918,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^84"]]]]]],"~$t_cljs$core1500",["^ ","^3S",1,"^1O",["^19",["^1U","^1Z","^21"]],"^1:","^AS","^23","cljs/core.cljs","^3W",true,"^8W",true,"^25",3,"^28",3961,"^3X",false,"^31","^3Y","^2@",["^19",["^1Z","^21"]]],"~$simple-keyword?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3352,"^25",16,"^29",3352,"^24",31,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a keyword without a namespace"],"^1:","~$cljs.core/simple-keyword?","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3352,"^3=","^3:","^29",3352,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a keyword without a namespace"],"~$-indexOf",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1525,"^25",8,"^29",1525,"^24",16,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]],"^2:",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/-indexOf","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]],"^2:",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1525,"^29",1525,"^2G",3,"^2H",true,"^2:",["^2;",[["^2O","~$x"],["^2O","~$x","^4P"]]]],"~$*main-cli-fn*",["^ ","^1:","~$cljs.core/*main-cli-fn*","^23","cljs/core.cljs","^28",294,"^25",1,"^29",298,"^24",16,"^2A","When compiled for a command-line target, whatever function\n *main-cli-fn* is set to will be called with the command-line\n argv as arguments","^1N",["^ ","^23","cljs/core.cljs","^28",298,"^25",3,"^29",298,"^24",16,"^2A","When compiled for a command-line target, whatever function\n *main-cli-fn* is set to will be called with the command-line\n argv as arguments"],"^31","^57"],"^?<",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",668,"^25",9,"^29",668,"^24",17,"^31","^5X","^5Y","^8S","^2A","Returns a new vector with value val added at position n.","^2:",["^2;",["^2<",["^2;",[["^2O","~$n","^2Z"]]]]]],"^5Y","^8S","^1:","~$cljs.core/-assoc-n","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2O","~$n","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",666,"^3=","^5X","^29",668,"^2G",3,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$n","^2Z"]]]]],"^2A","Returns a new vector with value val added at position n."],"~$unchecked-dec-int",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2715,"^25",7,"^29",2715,"^24",24,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one less than x, an int."],"^1:","~$cljs.core/unchecked-dec-int","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2715,"^29",2715,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one less than x, an int."],"~$hash-imap",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2984,"^25",8,"^29",2984,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$m"]]]]]],"^59",true,"^1:","~$cljs.core/hash-imap","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["~$m"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2984,"^29",2984,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m"]]]]]],"~$dominates",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10797,"^25",8,"^29",10797,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y","^BC","^63"]]]]]],"^59",true,"^1:","~$cljs.core/dominates","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["~$x","~$y","^BC","^63"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10797,"^29",10797,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y","^BC","^63"]]]]]],"~$persistent!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3782,"^25",7,"^29",3782,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^2X"]]]]],"^2A","Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception."],"^1:","~$cljs.core/persistent!","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^2X"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3782,"^29",3782,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2X"]]]]],"^2A","Returns a new, persistent version of the transient collection, in\n constant time. The transient collection cannot be used after this\n call, any such use will throw an exception."],"~$set-print-fn!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",86,"^25",7,"^29",86,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Set *print-fn* to f."],"^1:","~$cljs.core/set-print-fn!","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",86,"^29",86,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Set *print-fn* to f."],"~$nnext",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1756,"^25",7,"^29",1756,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (next (next x))"],"^1:","~$cljs.core/nnext","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1756,"^29",1756,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Same as (next (next x))"],"~$Box",["^ ","^3S",1,"^1O",["^19",[]],"^1:","~$cljs.core/Box","^23","cljs/core.cljs","^24",13,"^3W",true,"^25",10,"^28",7044,"^3X",false,"^29",7044,"^31","^3Y","^2@",null],"~$balance-right",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8165,"^25",8,"^29",8165,"^24",21,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^MJ","^KI"]]]]]],"^59",true,"^1:","~$cljs.core/balance-right","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^2Y","^2Z","^MJ","^KI"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8165,"^29",8165,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^MJ","^KI"]]]]]],"~$throw-no-method-error",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10840,"^25",8,"^29",10840,"^24",29,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^:","^7S"]]]]]],"^59",true,"^1:","~$cljs.core/throw-no-method-error","^2C",false,"^23","cljs/core.cljs","^24",29,"^2D",["^2;",[["^:","^7S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10840,"^29",10840,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^:","^7S"]]]]]],"~$demunge-str",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11318,"^25",8,"^29",11318,"^24",19,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$munged-name"]]]]]],"^59",true,"^1:","~$cljs.core/demunge-str","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^OC"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11318,"^29",11318,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^OC"]]]]]],"~$add-watch",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10324,"^25",7,"^29",10324,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^FY","^2Y","~$f"]]]]],"^2A","Adds a watch function to an atom reference. The watch fn must be a\n fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch\n fn will be called synchronously. Note that an atom's state\n may have changed again prior to the fn call, so use old/new-state\n rather than derefing the reference. Keys must be unique per\n reference, and can be used to remove the watch with remove-watch,\n but are otherwise considered opaque by the watch mechanism. Bear in\n mind that regardless of the result or action of the watch fns the\n atom's value will change. Example:\n\n (def a (atom 0))\n (add-watch a :inc (fn [k r o n] (assert (== 0 n))))\n (swap! a inc)\n ;; Assertion Error\n (deref a)\n ;=> 1"],"^1:","~$cljs.core/add-watch","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^FY","^2Y","~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10324,"^29",10324,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^FY","^2Y","~$f"]]]]],"^2A","Adds a watch function to an atom reference. The watch fn must be a\n fn of 4 args: a key, the reference, its old-state, its\n new-state. Whenever the reference's state might have been changed,\n any registered watches will have their functions called. The watch\n fn will be called synchronously. Note that an atom's state\n may have changed again prior to the fn call, so use old/new-state\n rather than derefing the reference. Keys must be unique per\n reference, and can be used to remove the watch with remove-watch,\n but are otherwise considered opaque by the watch mechanism. Bear in\n mind that regardless of the result or action of the watch fns the\n atom's value will change. Example:\n\n (def a (atom 0))\n (add-watch a :inc (fn [k r o n] (assert (== 0 n))))\n (swap! a inc)\n ;; Assertion Error\n (deref a)\n ;=> 1"],"~$not-every?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4187,"^25",16,"^29",4187,"^24",26,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns false if (pred x) is logical true for every x in\n coll, else true."],"^1:","~$cljs.core/not-every?","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4187,"^3=","^3:","^29",4187,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns false if (pred x) is logical true for every x in\n coll, else true."],"~$rem",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2822,"^25",7,"^29",2822,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","remainder of dividing numerator by denominator."],"^1:","~$cljs.core/rem","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["~$n","~$d"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2822,"^29",2822,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","remainder of dividing numerator by denominator."],"~$ifind?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2117,"^25",16,"^29",2117,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements IFind"],"^1:","~$cljs.core/ifind?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2117,"^3=","^3:","^29",2117,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll implements IFind"],"~$pr-sb-with-opts",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10017,"^25",8,"^29",10017,"^24",23,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]]],"^59",true,"^1:","~$cljs.core/pr-sb-with-opts","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^6Y","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10017,"^29",10017,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]]],"~$->HashMapIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",21,"^25",10,"^26","^27","^28",7755,"^29",7755,"^2:",["^2;",["^2<",["^2;",[["^NC","~$root-iter","~$seen"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/HashMapIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->HashMapIter","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^NC","^OP","^OQ"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7755,"^29",7755,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^NC","^OP","^OQ"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/HashMapIter."],"~$BitmapIndexedNode",["^ ","^3S",3,"^1O",["^19",["^1U","^20"]],"^1:","^?@","^23","cljs/core.cljs","^24",27,"^3W",true,"^25",10,"^28",7145,"^3X",false,"^29",7145,"^31","^3Y","^2@",["^19",["^20"]]],"~$->NodeSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",17,"^25",10,"^26","^27","^28",7610,"^29",7610,"^2:",["^2;",["^2<",["^2;",[["^2=","~$nodes","~$i","~$s","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/NodeSeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->NodeSeq","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2=","^OU","~$i","~$s","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7610,"^29",7610,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^OU","~$i","~$s","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/NodeSeq."],"~$some",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4192,"^25",7,"^29",4192,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)"],"^1:","~$cljs.core/some","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4192,"^29",4192,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns the first logical true value of (pred x) for any x in coll,\n else nil. One common idiom is to use a set as pred, for example\n this will return :fred if :fred is in the sequence, otherwise nil:\n (some #{:fred} coll)"],"~$INamed",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",839,"^25",14,"^29",839,"^24",20,"^2A","Protocol for adding a name.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^I[",[["~$x"]],"~$-namespace",[["~$x"]]]]],"^2S",true,"^1:","^U","^Box",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",[]],"^23","cljs/core.cljs","^24",13,"^25",10,"^26","^27","^28",7044,"^29",7044,"^2:",["^2;",["^2<",["^2;",[["^2Z"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Box."],"^1O",["^19",[]],"^1:","~$cljs.core/->Box","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7044,"^29",7044,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Z"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Box."],"~$IReduce",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",689,"^25",14,"^29",689,"^24",21,"^2A","Protocol for seq types that can reduce themselves.\n Called by cljs.core/reduce.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^R","^>S","^4X","^9[","^5F","^4Y","^4Z","^>V","^8?","^4[","^>Y","^>Z","^>[","^;V","^50","^?0","^?1","^?3","^?4","^?5","^?6","^:G","^>K","^9>","^52"]],"^2A","Protocol for seq types that can reduce themselves.\n Called by cljs.core/reduce.","^2T",["^2;",["@interface"]]],"~$neg-int?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2272,"^25",16,"^29",2272,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies int? and is negative."],"^1:","~$cljs.core/neg-int?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2272,"^3=","^3:","^29",2272,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies int? and is negative."],"~$drop",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4728,"^25",7,"^29",4728,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$n"],["~$n","^2O"]]]]],"^2A","Returns a lazy sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/drop","^2C",false,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$n"],["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4728,"^29",4728,"^2G",2,"^2H",true,"^2:",["^2;",[["~$n"],["~$n","^2O"]]],"^2A","Returns a lazy sequence of all but the first n items in coll.\n Returns a stateful transducer when no collection is provided."],"~$NodeIterator",["^ ","^3S",4,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/NodeIterator","^23","cljs/core.cljs","^24",23,"^3W",true,"^25",11,"^28",7107,"^3X",false,"^29",7107,"^31","^3Y","^2@",null],"~$js-obj",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2156,"^25",7,"^29",2156,"^24",13,"^2:",["^2;",["^2<",["^2;",[[],["~$&","^9T"]]]]],"^2A","Create JavaSript object from an even number arguments representing\n interleaved keys and values.","^2K",["^ ","^2C",true,"^2G",0,"^2D",["^2;",[[]]],"^2:",["^2;",[[],["~$&","^9T"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/js-obj","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",0,"^2D",["^2;",[[]]],"^2:",["^2;",[[],["~$&","^9T"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2156,"^29",2156,"^2G",0,"^2H",true,"^2:",["^2;",[[],["~$&","^9T"]]],"^2A","Create JavaSript object from an even number arguments representing\n interleaved keys and values."],"~$ITransientCollection",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",786,"^25",14,"^29",786,"^24",34,"^2A","Protocol for adding basic functionality to transient collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-conj!",[["^2X","^2Z"]],"^D9",[["^2X"]]]]],"^2S",true,"^1:","^?V","^23","cljs/core.cljs","^24",34,"^25",1,"^28",786,"^2U",["^ ","^2V",["^ ","^P;",[["^2X","^2Z"]],"^D9",[["^2X"]]]],"^30",null,"^29",786,"^31","^32","^33",["^19",["^34","^35","^36","^7D"]],"^2A","Protocol for adding basic functionality to transient collections.","^2T",["^2;",["@interface"]]],"~$Atom",["^ ","^3S",4,"^1O",["^19",["^CU","^JR","^1P","^1Q","^1U","^1Z","^3U"]],"^1:","^?7","^23","cljs/core.cljs","^24",14,"^3W",true,"^25",10,"^28",4375,"^3X",false,"^29",4375,"^31","^3Y","^2@",["^19",["^CU","^JR","^1P","^1Q","^1Z","^3U"]]],"~$nth",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1841,"^25",7,"^29",1841,"^24",10,"^2:",["^2;",["^2<",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]]]],"^2A","Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/nth","^2C",false,"^23","cljs/core.cljs","^24",10,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1841,"^29",1841,"^2G",3,"^2H",true,"^2:",["^2;",[["^2O","~$n"],["^2O","~$n","^73"]]],"^2A","Returns the value at the index. get returns nil if index out of\n bounds, nth throws an exception unless not-found is supplied. nth\n also works for strings, arrays, regex Matchers and Lists, and,\n in O(n) time, for sequences."],"~$sorted?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2125,"^25",16,"^29",2125,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll satisfies ISorted"],"^1:","~$cljs.core/sorted?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2125,"^3=","^3:","^29",2125,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll satisfies ISorted"],"~$nil?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",229,"^25",16,"^29",229,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is nil, false otherwise."],"^1:","~$cljs.core/nil?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",229,"^3=","^3:","^29",229,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is nil, false otherwise."],"~$split-at",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4856,"^25",7,"^29",4856,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"]]]]],"^2A","Returns a vector of [(take n coll) (drop n coll)]"],"^1:","~$cljs.core/split-at","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4856,"^29",4856,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"]]]]],"^2A","Returns a vector of [(take n coll) (drop n coll)]"],"~$TransientHashSet",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",9030,"^25",10,"^29",9030,"^24",26,"^5A",true],"^3S",1,"^1O",["^19",["~$cljs.core/ITransientSet","^1R","^1X","^?V","^22"]],"^1:","^7D","^23","cljs/core.cljs","^24",26,"^3W",true,"^25",10,"^28",9163,"^3X",false,"^5A",true,"^29",9163,"^31","^3Y","^2@",["^19",["^PF","^1R","^1X","^?V","^22"]]],"~$*e",["^ ","^1:","~$cljs.core/*e","^23","cljs/core.cljs","^28",211,"^25",1,"^29",213,"^24",5,"^2A","bound in a repl thread to the most recent exception caught by the repl","^1N",["^ ","^23","cljs/core.cljs","^28",213,"^25",3,"^29",213,"^24",5,"^2A","bound in a repl thread to the most recent exception caught by the repl"]],"~$array-map-extend-kv",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6550,"^25",8,"^29",6550,"^24",27,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k","~$v"]]]]]],"^59",true,"^1:","~$cljs.core/array-map-extend-kv","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["~$m","~$k","~$v"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6550,"^29",6550,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k","~$v"]]]]]],"~$prn-str-with-opts",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10032,"^25",7,"^29",10032,"^24",24,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]],"^2A","Same as pr-str-with-opts followed by (newline)"],"^1:","~$cljs.core/prn-str-with-opts","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^6Y","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10032,"^29",10032,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^2J"]]]]],"^2A","Same as pr-str-with-opts followed by (newline)"],"~$not-native",["^ ","^1:","~$cljs.core/not-native","^23","cljs/core.cljs","^28",220,"^25",1,"^29",220,"^24",16,"^1N",["^ ","^23","cljs/core.cljs","^28",220,"^25",6,"^29",220,"^24",16],"^31","^57"],"~$random-sample",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10461,"^25",7,"^29",10461,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$prob"],["^PP","^2O"]]]]],"^2A","Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^PP"],["^PP","^2O"]]],"^2:",["^2;",[["^PP"],["^PP","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/random-sample","^2C",false,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^PP"],["^PP","^2O"]]],"^2:",["^2;",[["^PP"],["^PP","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^PP"],["^PP","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10461,"^29",10461,"^2G",2,"^2H",true,"^2:",["^2;",[["^PP"],["^PP","^2O"]]],"^2A","Returns items from coll with random probability of prob (0.0 -\n 1.0). Returns a transducer when no collection is provided."],"~$select-keys",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9014,"^25",7,"^29",9014,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^;;","~$keyseq"]]]]],"^2A","Returns a map containing only those entries in map whose key is in keys"],"^1:","~$cljs.core/select-keys","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^;;","^PS"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9014,"^29",9014,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^;;","^PS"]]]]],"^2A","Returns a map containing only those entries in map whose key is in keys"],"~$bit-and",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2834,"^25",7,"^29",2834,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Bitwise and","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/bit-and","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2834,"^29",2834,"^2G",2,"^2H",true,"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Bitwise and"],"~$bounded-count",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3718,"^25",7,"^29",3718,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"]]]]],"^2A","If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq","^76","1.9"],"^76","1.9","^1:","~$cljs.core/bounded-count","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$n","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3718,"^29",3718,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"]]]]],"^2A","If coll is counted? returns its count, else will count at most the first n\n elements of coll using its seq"],"~$update",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5277,"^25",7,"^29",5277,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"],["~$m","~$k","~$f","~$x","~$y","~$z","~$&","^6A"]]]]],"^2A","'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value.","^2K",["^ ","^2C",true,"^2G",6,"^2D",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"]]],"^2:",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"],["~$m","~$k","~$f","~$x","~$y","~$z","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null,null]]]],"^1:","~$cljs.core/update","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",6,"^2D",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"]]],"^2:",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"],["~$m","~$k","~$f","~$x","~$y","~$z","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null,null]]],"^2D",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null]],"^25",1,"^28",5277,"^29",5277,"^2G",6,"^2H",true,"^2:",["^2;",[["~$m","~$k","~$f"],["~$m","~$k","~$f","~$x"],["~$m","~$k","~$f","~$x","~$y"],["~$m","~$k","~$f","~$x","~$y","~$z"],["~$m","~$k","~$f","~$x","~$y","~$z","~$&","^6A"]]],"^2A","'Updates' a value in an associative structure, where k is a\n key and f is a function that will take the old value\n and any supplied args and return the new value, and returns a new\n structure. If the key does not exist, nil is passed as the old value."],"~$gensym_counter",["^ ","^1:","~$cljs.core/gensym_counter","^23","cljs/core.cljs","^28",10355,"^25",1,"^29",10357,"^24",17,"^2T",["@type {*}"],"^1N",["^ ","^23","cljs/core.cljs","^28",10357,"^25",3,"^29",10357,"^24",17,"^2T",["@type {*}"]],"^31","^57"],"~$find-macros-ns",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11474,"^25",7,"^29",11474,"^24",21,"^2:",["^2;",["^2<",["^2;",[["^47"]]]]],"^2A","Returns the macros namespace named by the symbol or nil if it doesn't exist.\n Bootstrap only."],"^1:","~$cljs.core/find-macros-ns","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^47"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11474,"^29",11474,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^47"]]]]],"^2A","Returns the macros namespace named by the symbol or nil if it doesn't exist.\n Bootstrap only."],"~$list*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3764,"^25",7,"^29",3764,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"],["~$a","~$b","~$c","~$d","~$&","^6A"]]]]],"^2A","Creates a new list containing the items prepended to the rest, the\n last of which will be treated as a sequence.","^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"]]],"^2:",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"],["~$a","~$b","~$c","~$d","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null,null]]]],"^1:","~$cljs.core/list*","^2C",true,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"]]],"^2:",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"],["~$a","~$b","~$c","~$d","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null,null]]],"^2D",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null]],"^25",1,"^28",3764,"^29",3764,"^2G",4,"^2H",true,"^2:",["^2;",[["^AD"],["~$a","^AD"],["~$a","~$b","^AD"],["~$a","~$b","~$c","^AD"],["~$a","~$b","~$c","~$d","~$&","^6A"]]],"^2A","Creates a new list containing the items prepended to the rest, the\n last of which will be treated as a sequence."],"~$array-index-of-keyword?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6486,"^25",8,"^29",6486,"^24",31,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"^59",true,"^1:","~$cljs.core/array-index-of-keyword?","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["^66","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6486,"^29",6486,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$k"]]]]]],"~$->Keyword",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1R","^1U","^Keyword","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^47","^:","^Q8","^HT"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3274,"^29",3274,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^47","^:","^Q8","^HT"]]]]],"^2@",["^19",["^1P","^1Q","^1R","^PersistentArrayMap",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22","^5E"]],"^23","cljs/core.cljs","^24",28,"^25",10,"^26","^27","^28",6733,"^29",6733,"^2:",["^2;",["^2<",["^2;",[["^2=","^67","^66","^2?"]]]]],"^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22","^5E"]],"^2A","Positional factory function for cljs.core/PersistentArrayMap."],"^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22","^5E"]],"^1:","~$cljs.core/->PersistentArrayMap","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["^2=","^67","^66","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6733,"^29",6733,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^67","^66","^2?"]]]]],"^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22","^5E"]],"^2A","Positional factory function for cljs.core/PersistentArrayMap."],"~$instance?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1030,"^25",16,"^29",1030,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$c","~$x"]]]]],"^2A","Evaluates x and tests if it is an instance of the type\n c. Returns true or false"],"^1:","~$cljs.core/instance?","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["~$c","~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1030,"^3=","^3:","^29",1030,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$c","~$x"]]]]],"^2A","Evaluates x and tests if it is an instance of the type\n c. Returns true or false"],"~$mix-collection-hash",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1313,"^25",15,"^29",1313,"^24",34,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$hash-basis","^AG"]]]]],"^2A","Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://clojure.org/data_structures#hash for full algorithms."],"^1:","~$cljs.core/mix-collection-hash","^2C",false,"^23","cljs/core.cljs","^24",34,"^2D",["^2;",[["^QK","^AG"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1313,"^3=","^<","^29",1313,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^QK","^AG"]]]]],"^2A","Mix final collection hash for ordered or unordered collections.\n hash-basis is the combined collection hash, count is the number\n of elements included in the basis. Note this is the hash code\n consistent with =, different from .hashCode.\n See http://clojure.org/data_structures#hash for full algorithms."],"~$re-find",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9817,"^25",7,"^29",9817,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^<>","~$s"]]]]],"^2A","Returns the first regex match, if any, of s to re, using\n re.exec(s). Returns a vector, containing first the matching\n substring, then any capturing groups if the regular expression contains\n capturing groups."],"^1:","~$cljs.core/re-find","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^<>","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9817,"^29",9817,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^<>","~$s"]]]]],"^2A","Returns the first regex match, if any, of s to re, using\n re.exec(s). Returns a vector, containing first the matching\n substring, then any capturing groups if the regular expression contains\n capturing groups."],"~$run!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10508,"^25",7,"^29",10508,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$proc","^2O"]]]]],"^2A","Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil"],"^1:","~$cljs.core/run!","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^QP","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10508,"^29",10508,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^QP","^2O"]]]]],"^2A","Runs the supplied procedure (via reduce), for purposes of side\n effects, on successive items in the collection. Returns nil"],"~$char-escapes",["^ ","^1:","~$cljs.core/char-escapes","^23","cljs/core.cljs","^28",9888,"^25",1,"^29",9888,"^24",28,"^59",true,"^1N",["^ ","^23","cljs/core.cljs","^28",9888,"^25",16,"^29",9888,"^24",28,"^59",true],"^31","^45"],"~$ES6Iterator",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/ES6Iterator","^23","cljs/core.cljs","^24",21,"^3W",true,"^25",10,"^28",1277,"^3X",false,"^29",1277,"^31","^3Y","^2@",null],"^2Z",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8985,"^25",7,"^29",8985,"^24",10,"^2:",["^2;",["^2<",["^2;",[["^H6"]]]]],"^2A","Returns the value in the map entry."],"^1:","~$cljs.core/val","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^H6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8985,"^29",8985,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^H6"]]]]],"^2A","Returns the value in the map entry."],"~$unchecked-add",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2696,"^25",15,"^29",2696,"^24",28,"^31","^<","^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the sum of nums. (+) returns 0.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/unchecked-add","^2C",true,"^23","cljs/core.cljs","^24",28,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",2696,"^3=","^<","^29",2696,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns the sum of nums. (+) returns 0."],"~$transformer-iterator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4136,"^25",7,"^29",4136,"^24",27,"^2:",["^2;",["^2<",["^2;",[["^5O","^;6","^;7"]]]]]],"^1:","~$cljs.core/transformer-iterator","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^5O","^;6","^;7"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4136,"^29",4136,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^5O","^;6","^;7"]]]]]],"~$not",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",246,"^25",16,"^29",246,"^24",19,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is logical false, false otherwise."],"^1:","~$cljs.core/not","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",246,"^3=","^3:","^29",246,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is logical false, false otherwise."],"~$->t_cljs$core9266",["^ ","^1M",null,"^1N",["^ ","^8W",true,"^1O",["^19",["^1U","^1Z","^21"]],"^2@",["^19",["^1Z","^21"]],"^26","^27","^2:",["^2;",["^2<",["^2;",[["~$meta9267"]]]]],"^2A","Positional factory function for cljs.core/t_cljs$core9266.","^23","cljs/core.cljs"],"^1O",["^19",["^1U","^1Z","^21"]],"^1:","~$cljs.core/->t_cljs$core9266","^2C",false,"^23","cljs/core.cljs","^2D",["^2;",[["^R2"]]],"^2E",null,"^2F",["^2;",[null,null]],"^8W",true,"^25",3,"^26","^27","^28",3961,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^R2"]]]]],"^2@",["^19",["^1Z","^21"]],"^2A","Positional factory function for cljs.core/t_cljs$core9266."],"^CY",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",861,"^25",4,"^29",861,"^24",12,"^5Y","^3T","^2A","Sets the value of volatile o to new-value without regard for the\n current value. Returns new-value.","^2:",["^2;",["^2<",["^2;",[["~$o","^CP"]]]]]],"^5Y","^3T","^1:","~$cljs.core/-vreset!","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$o","^CP"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",859,"^29",861,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^CP"]]]]],"^2A","Sets the value of volatile o to new-value without regard for the\n current value. Returns new-value."],"~$fn->comparator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2398,"^25",17,"^29",2398,"^24",31,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Given a fn that might be boolean valued or a comparator,\n return a fn that is a comparator."],"^59",true,"^1:","~$cljs.core/fn->comparator","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2398,"^29",2398,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Given a fn that might be boolean valued or a comparator,\n return a fn that is a comparator."],"~$with-meta",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2048,"^25",7,"^29",2048,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$o","^2="]]]]],"^2A","Returns an object of the same type and value as obj, with\n map m as its metadata."],"^1:","~$cljs.core/with-meta","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$o","^2="]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2048,"^29",2048,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^2="]]]]],"^2A","Returns an object of the same type and value as obj, with\n map m as its metadata."],"~$unreduced",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1436,"^25",7,"^29",1436,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","If x is reduced?, returns (deref x), else returns x"],"^1:","~$cljs.core/unreduced","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1436,"^29",1436,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","If x is reduced?, returns (deref x), else returns x"],"~$record?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2140,"^25",16,"^29",2140,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies IRecord"],"^1:","~$cljs.core/record?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2140,"^3=","^3:","^29",2140,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies IRecord"],"^15",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",305,"^25",7,"^29",305,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return x's constructor."],"^1:","~$cljs.core/type","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",305,"^29",305,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return x's constructor."],"~$identical?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",224,"^25",16,"^29",224,"^24",26,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Tests if 2 arguments are the same object"],"^1:","~$cljs.core/identical?","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",224,"^3=","^3:","^29",224,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Tests if 2 arguments are the same object"],"^OZ",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",843,"^25",12,"^29",843,"^24",22,"^31","^90","^5Y","^PersistentTreeSet",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5C","^1P","^1Q","^1R","^1S","^1U","^1V","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^22"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",9200,"^29",9200,"^2:",["^2;",["^2<",["^2;",[["^2=","~$tree-map","^2?"]]]]],"^2@",["^19",["^5C","^1P","^1Q","^1R","^1S","^1V","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^22"]],"^2A","Positional factory function for cljs.core/PersistentTreeSet."],"^1O",["^19",["^5C","^1P","^1Q","^1R","^1S","^1U","^1V","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^22"]],"^1:","~$cljs.core/->PersistentTreeSet","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2=","^RJ","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",9200,"^29",9200,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^RJ","^2?"]]]]],"^2@",["^19",["^5C","^1P","^1Q","^1R","^1S","^1V","^1W","^1X","^6U","^1Y","^1Z","^1[","^21","^22"]],"^2A","Positional factory function for cljs.core/PersistentTreeSet."],"~$*out*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",59,"^25",3,"^29",59,"^24",8,"^6F",true,"^2T",["@type {*}"]],"^1:","~$cljs.core/*out*","^23","cljs/core.cljs","^24",8,"^25",1,"^6F",true,"^28",56,"^29",59,"^31","^57","^2T",["@type {*}"]],"~$->ChunkBuffer",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U","^1X"]],"^23","cljs/core.cljs","^24",21,"^25",10,"^26","^27","^28",3464,"^29",3464,"^2:",["^2;",["^2<",["^2;",[["~$buf","^4Q"]]]]],"^2@",["^19",["^1X"]],"^2A","Positional factory function for cljs.core/ChunkBuffer."],"^1O",["^19",["^1U","^1X"]],"^1:","~$cljs.core/->ChunkBuffer","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^RO","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3464,"^29",3464,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^RO","^4Q"]]]]],"^2@",["^19",["^1X"]],"^2A","Positional factory function for cljs.core/ChunkBuffer."],"~$hash-string",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",976,"^25",7,"^29",976,"^24",18,"^2:",["^2;",["^2<",["^2;",[["~$k"]]]]]],"^1:","~$cljs.core/hash-string","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",976,"^29",976,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$k"]]]]]],"~$ValSeq",["^ ","^3S",2,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","^>Z","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",8914,"^3X",false,"^29",8914,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$-prefers",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10836,"^25",4,"^29",10836,"^24",12,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-prefers","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^7R"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10836,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]],"^2A",null],"~$set-validator!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4500,"^25",7,"^29",4500,"^24",21,"^2:",["^2;",["^2<",["^2;",[["^FY","^2Z"]]]]],"^2A","Sets the validator-fn for an atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an Error. If the current state\n is not acceptable to the new validator, an Error will be thrown and the\n validator will not be changed."],"^1:","~$cljs.core/set-validator!","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^FY","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4500,"^29",4500,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^FY","^2Z"]]]]],"^2A","Sets the validator-fn for an atom. validator-fn must be nil or a\n side-effect-free fn of one argument, which will be passed the intended\n new state on any state change. If the new state is unacceptable, the\n validator-fn should return false or throw an Error. If the current state\n is not acceptable to the new validator, an Error will be thrown and the\n validator will not be changed."],"~$ident?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3332,"^25",16,"^29",3332,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a symbol or keyword"],"^1:","~$cljs.core/ident?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3332,"^3=","^3:","^29",3332,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a symbol or keyword"],"^AQ",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",681,"^25",16,"^29",681,"^24",21,"^31","~$clj-or-nil","^5Y","^1Z","^2A","Returns the metadata of object o.","^2:",["^2;",["^2<",["^2;",[["~$o"]]]]]],"^5Y","^1Z","^1:","~$cljs.core/-meta","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$o"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",679,"^3=","^RZ","^29",681,"^2G",1,"^31","^RZ","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o"]]]]],"^2A","Returns the metadata of object o."],"~$RedNode",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",8138,"^25",10,"^29",8138,"^24",17,"^5A",true],"^3S",5,"^1O",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^1:","^52","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",8363,"^3X",false,"^5A",true,"^29",8363,"^31","^3Y","^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]]],"~$-dispatch-fn",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10838,"^25",4,"^29",10838,"^24",16,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-dispatch-fn","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^7R"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10838,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]],"^2A",null],"~$->IndexedSeqIterator",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",28,"^25",10,"^26","^27","^28",1559,"^29",1559,"^2:",["^2;",["^2<",["^2;",[["^66","~$i"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/IndexedSeqIterator."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->IndexedSeqIterator","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["^66","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1559,"^29",1559,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/IndexedSeqIterator."],"~$-add-method",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10831,"^25",4,"^29",10831,"^24",15,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S","~$method"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-add-method","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^7R","^7S","^S6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10831,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S","^S6"]]]]],"^2A",null],"~$balance-left-del",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8187,"^25",8,"^29",8187,"^24",24,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","~$del","^KJ"]]]]]],"^59",true,"^1:","~$cljs.core/balance-left-del","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^2Y","^2Z","^S9","^KJ"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8187,"^29",8187,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^S9","^KJ"]]]]]],"~$swap!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4454,"^25",7,"^29",4454,"^24",12,"^2:",["^2;",["^2<",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"],["~$a","~$f","~$x","~$y","~$&","^6A"]]]]],"^2A","Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in.","^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"]]],"^2:",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"],["~$a","~$f","~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/swap!","^2C",true,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"]]],"^2:",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"],["~$a","~$f","~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",4454,"^29",4454,"^2G",4,"^2H",true,"^2:",["^2;",[["~$a","~$f"],["~$a","~$f","~$x"],["~$a","~$f","~$x","~$y"],["~$a","~$f","~$x","~$y","~$&","^6A"]]],"^2A","Atomically swaps the value of atom to be:\n (apply f current-value-of-atom args). Note that f may be called\n multiple times, and thus should be free of side effects. Returns\n the value that was swapped in."],"^AZ",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8979,"^25",7,"^29",8979,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2>"]]]]],"^2A","Returns a sequence of the map's values."],"^1:","~$cljs.core/vals","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^2>"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8979,"^29",8979,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2>"]]]]],"^2A","Returns a sequence of the map's values."],"~$Repeat",["^ ","^3S",5,"^1O",["^19",["^1P","^1Q","^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","^?1","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",4861,"^3X",false,"^29",4861,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]]],"~$-chunked-next",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",836,"^25",4,"^29",836,"^24",17,"^5Y","^@S","^2A","Returns a new collection of coll without the first chunk.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^@S","^1:","~$cljs.core/-chunked-next","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",834,"^29",836,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a new collection of coll without the first chunk."],"~$Single",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/Single","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",4038,"^3X",false,"^29",4038,"^31","^3Y","^2@",null],"~$unchecked-subtract",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2758,"^25",15,"^29",2758,"^24",33,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/unchecked-subtract","^2C",true,"^23","cljs/core.cljs","^24",33,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2758,"^3=","^<","^29",2758,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","If no ys are supplied, returns the negation of x, else subtracts\n the ys from x and returns the result."],"~$tap>",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11364,"^25",16,"^29",11364,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Sends x to any taps. Returns the result of *exec-tap-fn*, a Boolean value."],"^1:","~$cljs.core/tap>","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11364,"^3=","^3:","^29",11364,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Sends x to any taps. Returns the result of *exec-tap-fn*, a Boolean value."],"~$remove-pair",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7066,"^25",8,"^29",7066,"^24",19,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i"]]]]]],"^59",true,"^1:","~$cljs.core/remove-pair","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^66","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7066,"^29",7066,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i"]]]]]],"~$IMap",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",638,"^25",14,"^29",638,"^24",18,"^2A","Protocol for adding mapping functionality to collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-dissoc",[["^2O","~$k"]]]]],"^2S",true,"^1:","^A6","^23","cljs/core.cljs","^24",18,"^25",1,"^28",638,"^2U",["^ ","^2V",["^ ","^SJ",[["^2O","~$k"]]]],"^30",null,"^29",638,"^31","^32","^33",["^19",["^4V","^4W","^4X","^51"]],"^2A","Protocol for adding mapping functionality to collections.","^2T",["^2;",["@interface"]]],"~$->SeqIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",17,"^25",10,"^26","^27","^28",3994,"^29",3994,"^2:",["^2;",["^2<",["^2;",[["~$_seq","^;3"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/SeqIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->SeqIter","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^SL","^;3"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3994,"^29",3994,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^SL","^;3"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/SeqIter."],"~$sorted-set-by",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9332,"^25",7,"^29",9332,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$comparator","~$&","^CM"]]]]],"^2A","Returns a new sorted set with supplied keys, using the supplied comparator.","^2K",["^ ","^2C",true,"^2G",1,"^2D",[["^2;",["^SO","^CM"]]],"^2:",["^2;",[["^SO","~$&","^CM"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/sorted-set-by","^2C",true,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",true,"^2G",1,"^2D",[["^2;",["^SO","^CM"]]],"^2:",["^2;",[["^SO","~$&","^CM"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^SO","^CM"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",9332,"^29",9332,"^2G",1,"^2H",true,"^2:",["^2;",[["^SO","~$&","^CM"]]],"^2A","Returns a new sorted set with supplied keys, using the supplied comparator."],"~$PersistentVector",["^ ","^3S",6,"^1O",["^19",["^;:","^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]],"^1:","^50","^23","cljs/core.cljs","^24",26,"^3W",true,"^25",10,"^28",5433,"^3X",false,"^29",5433,"^31","^3Y","^2@",["^19",["^5B","^8S","^5C","^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^8T","^20","^4K","^21","^7W","^22","^5E"]]],"~$cloneable?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1197,"^25",16,"^29",1197,"^24",26,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^4@"]]]]],"^2A","Return true if x implements ICloneable protocol."],"^1:","~$cljs.core/cloneable?","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["^4@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1197,"^3=","^3:","^29",1197,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4@"]]]]],"^2A","Return true if x implements ICloneable protocol."],"~$qualified-ident?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3340,"^25",16,"^29",3340,"^24",32,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a symbol or keyword with a namespace"],"^1:","~$cljs.core/qualified-ident?","^2C",false,"^23","cljs/core.cljs","^24",32,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3340,"^3=","^3:","^29",3340,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is a symbol or keyword with a namespace"],"~$hash-string*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",959,"^25",7,"^29",959,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"^1:","~$cljs.core/hash-string*","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",959,"^29",959,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"~$key-test",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7048,"^25",16,"^29",7048,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["^2Y","^G5"]]]]]],"^1:","~$cljs.core/key-test","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["^2Y","^G5"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7048,"^3=","^3:","^29",7048,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^G5"]]]]]],"~$-reset",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10830,"^25",4,"^29",10830,"^24",10,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-reset","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["^7R"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10830,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R"]]]]],"^2A",null],"~$true?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2199,"^25",16,"^29",2199,"^24",21,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is the value true, false otherwise."],"^1:","~$cljs.core/true?","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2199,"^3=","^3:","^29",2199,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is the value true, false otherwise."],"~$find-ns-obj*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11408,"^25",8,"^29",11408,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$ctxt","^5:"]]]]],"^2A","Bootstrap only."],"^59",true,"^1:","~$cljs.core/find-ns-obj*","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^T3","^5:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11408,"^29",11408,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^T3","^5:"]]]]],"^2A","Bootstrap only."],"^79",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",435,"^25",14,"^29",435,"^24",19,"^31","^79","^2:",["^2;",["^2<",["^2;",[["~$var-args"]]]]],"^2A","Creates a new javascript array.\n@param {...*} var_args"],"^1:","~$cljs.core/array","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^T5"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",435,"^3=","^79","^29",435,"^2G",1,"^31","^79","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^T5"]]]]],"^2A","Creates a new javascript array.\n@param {...*} var_args"],"~$print",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10076,"^25",3,"^29",10076,"^24",8,"^2A","Prints the object(s) using string-print.\n print and println produce output for human consumption."],"^1:","~$cljs.core/print","^2C",true,"^23","cljs/core.cljs","^24",8,"^2D",["^2;",[["^6Y"]]],"^2E",null,"^2F",["^2;",[]],"^25",1,"^28",10073,"^29",10076,"^2G",0,"^2H",true,"^2:",null,"^2A","Prints the object(s) using string-print.\n print and println produce output for human consumption."],"^CS",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",660,"^25",4,"^29",660,"^24",9,"^5Y","^8T","^2A","Returns the item from the top of the stack. Is used by cljs.core/peek.","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^8T","^1:","~$cljs.core/-peek","^2C",false,"^23","cljs/core.cljs","^24",9,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",656,"^29",660,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns the item from the top of the stack. Is used by cljs.core/peek."],"~$ISeq",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",601,"^25",14,"^29",601,"^24",18,"^2A","Protocol for collections to provide access to their items as sequences.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^91",[["^2O"]],"~$-rest",[["^2O"]]]]],"^2S",true,"^1:","^4?","^23","cljs/core.cljs","^24",18,"^25",1,"^28",601,"^2U",["^ ","^2V",["^ ","^91",[["^2O"]],"^T;",[["^2O"]]]],"^30",null,"^29",601,"^31","^32","^33",["^19",["^>R","^9[","^>T","^5F","^>V","^8?","^>W","^>Y","^>Z","^>[","^<:","^;V","^?0","^?1","^?3","^?4","^?5","^?6","^?8","^>K","^9>"]],"^2A","Protocol for collections to provide access to their items as sequences.","^2T",["^2;",["@interface"]]],"~$empty",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1788,"^25",7,"^29",1788,"^24",12,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns an empty collection of the same category as coll, or nil"],"^1:","~$cljs.core/empty","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1788,"^29",1788,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns an empty collection of the same category as coll, or nil"],"~$remove-method",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11033,"^25",7,"^29",11033,"^24",20,"^2:",["^2;",["^2<",["^2;",[["^87","^7S"]]]]],"^2A","Removes the method of multimethod associated with dispatch-value."],"^1:","~$cljs.core/remove-method","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^87","^7S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11033,"^29",11033,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^87","^7S"]]]]],"^2A","Removes the method of multimethod associated with dispatch-value."],"~$PersistentQueueSeq",["^ ","^3S",4,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21"]],"^1:","^>W","^23","cljs/core.cljs","^24",28,"^3W",true,"^25",10,"^28",6121,"^3X",false,"^29",6121,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21"]]],"~$balance-right-del",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8206,"^25",8,"^29",8206,"^24",25,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^MJ","^S9"]]]]]],"^59",true,"^1:","~$cljs.core/balance-right-del","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^2Y","^2Z","^MJ","^S9"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8206,"^29",8206,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^MJ","^S9"]]]]]],"~$volatile!",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4526,"^25",7,"^29",4526,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^2Z"]]]]],"^2A","Creates and returns a Volatile with an initial value of val."],"^1:","~$cljs.core/volatile!","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4526,"^29",4526,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Z"]]]]],"^2A","Creates and returns a Volatile with an initial value of val."],"~$/",["^ ","^1M",null,"^1N",["^ ","^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^23","cljs/core.cljs"],"^1:","~$cljs.core//","^2C",true,"^23","cljs/core.cljs","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2603,"^3=","^<","^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","If no denominators are supplied, returns 1/numerator,\n else returns numerator divided by all of the denominators."],"~$bitpos",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7075,"^25",8,"^29",7075,"^24",14,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^B;","^=D"]]]]]],"^59",true,"^1:","~$cljs.core/bitpos","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^B;","^=D"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7075,"^29",7075,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^B;","^=D"]]]]]],"~$Many",["^ ","^3S",1,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/Many","^23","cljs/core.cljs","^24",14,"^3W",true,"^25",10,"^28",4024,"^3X",false,"^29",4024,"^31","^3Y","^2@",null],"~$bit-or",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2840,"^25",7,"^29",2840,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Bitwise or","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/bit-or","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x","~$y"]]],"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2840,"^29",2840,"^2G",2,"^2H",true,"^2:",["^2;",[["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Bitwise or"],"~$m3-fmix",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",920,"^25",15,"^29",920,"^24",22,"^31","^<","^2:",["^2;",["^2<",["^2;",[["^@A","^5<"]]]]]],"^1:","~$cljs.core/m3-fmix","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^@A","^5<"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",920,"^3=","^<","^29",920,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^@A","^5<"]]]]]],"~$vector",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5658,"^25",7,"^29",5658,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$&","^AD"]]]]],"^2A","Creates a new vector containing the args.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^AD"]]],"^2:",["^2;",[["~$&","^AD"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/vector","^2C",true,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^AD"]]],"^2:",["^2;",[["~$&","^AD"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^AD"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",5658,"^29",5658,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^AD"]]],"^2A","Creates a new vector containing the args."],"~$hash-coll",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2974,"^25",8,"^29",2974,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^59",true,"^1:","~$cljs.core/hash-coll","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2974,"^29",2974,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"~$clone-and-set",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7057,"^25",8,"^29",7057,"^24",21,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]]]],"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]],"^2:",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/clone-and-set","^2C",false,"^23","cljs/core.cljs","^24",21,"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]],"^2:",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7057,"^29",7057,"^2G",5,"^2H",true,"^2:",["^2;",[["^66","~$i","~$a"],["^66","~$i","~$a","~$j","~$b"]]]],"~$array->transient-hash-map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7035,"^25",8,"^29",7035,"^24",33,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^5<","^66"]]]]]],"^59",true,"^1:","~$cljs.core/array->transient-hash-map","^2C",false,"^23","cljs/core.cljs","^24",33,"^2D",["^2;",[["^5<","^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7035,"^29",7035,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^5<","^66"]]]]]],"~$>=",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2646,"^25",16,"^29",2646,"^24",18,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/>=","^2C",true,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2646,"^3=","^3:","^29",2646,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns non-nil if nums are in monotonically non-increasing order,\n otherwise false."],"~$->TransientHashSet",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^PF","^1R","^1X","^?V","^22"]],"^23","cljs/core.cljs","^24",26,"^25",10,"^26","^27","^28",9163,"^29",9163,"^2:",["^2;",["^2<",["^2;",[["~$transient-map"]]]]],"^2@",["^19",["^PF","^1R","^1X","^?V","^22"]],"^2A","Positional factory function for cljs.core/TransientHashSet."],"^1O",["^19",["^PF","^1R","^1X","^?V","^22"]],"^1:","~$cljs.core/->TransientHashSet","^2C",false,"^23","cljs/core.cljs","^24",26,"^2D",["^2;",[["^TY"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",9163,"^29",9163,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^TY"]]]]],"^2@",["^19",["^PF","^1R","^1X","^?V","^22"]],"^2A","Positional factory function for cljs.core/TransientHashSet."],"~$drop-last",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4753,"^25",7,"^29",4753,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$s"],["~$n","~$s"]]]]],"^2A","Return a lazy sequence of all but the last n (default 1) items in coll","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$s"],["~$n","~$s"]]],"^2:",["^2;",[["~$s"],["~$n","~$s"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/drop-last","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$s"],["~$n","~$s"]]],"^2:",["^2;",[["~$s"],["~$n","~$s"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$s"],["~$n","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4753,"^29",4753,"^2G",2,"^2H",true,"^2:",["^2;",[["~$s"],["~$n","~$s"]]],"^2A","Return a lazy sequence of all but the last n (default 1) items in coll"],"~$->ArrayIter",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",19,"^25",10,"^26","^27","^28",3979,"^29",3979,"^2:",["^2;",["^2<",["^2;",[["^66","~$i"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ArrayIter."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->ArrayIter","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^66","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3979,"^29",3979,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","~$i"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/ArrayIter."],"~$object?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",258,"^25",16,"^29",258,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x's constructor is Object"],"^1:","~$cljs.core/object?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",258,"^3=","^3:","^29",258,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x's constructor is Object"],"~$->ArrayNodeSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",22,"^25",10,"^26","^27","^28",7688,"^29",7688,"^2:",["^2;",["^2<",["^2;",[["^2=","^OU","~$i","~$s","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/ArrayNodeSeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->ArrayNodeSeq","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^2=","^OU","~$i","~$s","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7688,"^29",7688,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^OU","~$i","~$s","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/ArrayNodeSeq."],"~$lift-ns",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10110,"^25",8,"^29",10110,"^24",15,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$m"]]]]],"^2A","Returns [lifted-ns lifted-map] or nil if m can't be lifted."],"^59",true,"^1:","~$cljs.core/lift-ns","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$m"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10110,"^29",10110,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$m"]]]]],"^2A","Returns [lifted-ns lifted-map] or nil if m can't be lifted."],"~$tree-map-append",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8546,"^25",8,"^29",8546,"^24",23,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^MJ","^KJ"]]]]]],"^59",true,"^1:","~$cljs.core/tree-map-append","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^MJ","^KJ"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8546,"^29",8546,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^MJ","^KJ"]]]]]],"~$not-empty",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3956,"^25",7,"^29",3956,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","If coll is empty, returns nil, else coll"],"^1:","~$cljs.core/not-empty","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3956,"^29",3956,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","If coll is empty, returns nil, else coll"],"~$distinct",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9356,"^25",7,"^29",9356,"^24",15,"^2:",["^2;",["^2<",["^2;",[[],["^2O"]]]]],"^2A","Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^2O"]]],"^2:",["^2;",[[],["^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/distinct","^2C",false,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^2O"]]],"^2:",["^2;",[[],["^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[],["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9356,"^29",9356,"^2G",1,"^2H",true,"^2:",["^2;",[[],["^2O"]]],"^2A","Returns a lazy sequence of the elements of coll with duplicates removed.\n Returns a stateful transducer when no collection is provided."],"~$partition",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5200,"^25",7,"^29",5200,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","~$pad","^2O"]]]]],"^2A","Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition up to n items. In case there are\n not enough padding elements, return a partition with less than n items.","^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","^U@","^2O"]]],"^2:",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","^U@","^2O"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/partition","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","^U@","^2O"]]],"^2:",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","^U@","^2O"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","^U@","^2O"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",5200,"^29",5200,"^2G",4,"^2H",true,"^2:",["^2;",[["~$n","^2O"],["~$n","^=?","^2O"],["~$n","^=?","^U@","^2O"]]],"^2A","Returns a lazy sequence of lists of n items each, at offsets step\n apart. If step is not supplied, defaults to n, i.e. the partitions\n do not overlap. If a pad collection is supplied, use its elements as\n necessary to complete last partition up to n items. In case there are\n not enough padding elements, return a partition with less than n items."],"~$IMultiFn",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",10829,"^25",14,"^29",10829,"^24",22,"^2A",null,"^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^7P",[["^7R","^7S","^7T"]],"^9I",[["^7R"]],"^A?",[["^7R","^7S"]],"^LB",[["^7R"]],"^RT",[["^7R"]],"^S1",[["^7R"]],"^S5",[["^7R","^7S","^S6"]],"^SZ",[["^7R"]],"~$-get-method",[["^7R","^7S"]]]]],"^2S",true,"^1:","^7Q","^23","cljs/core.cljs","^24",22,"^25",1,"^28",10829,"^2U",["^ ","^2V",["^ ","^7P",[["^7R","^7S","^7T"]],"^9I",[["^7R"]],"^A?",[["^7R","^7S"]],"^LB",[["^7R"]],"^RT",[["^7R"]],"^S1",[["^7R"]],"^S5",[["^7R","^7S","^S6"]],"^SZ",[["^7R"]],"^UC",[["^7R","^7S"]]]],"^30",null,"^29",10829,"^31","^32","^33",["^19",["^FG"]],"^2A",null,"^2T",["^2;",["@interface"]]],"~$->Many",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",14,"^25",10,"^26","^27","^28",4024,"^29",4024,"^2:",["^2;",["^2<",["^2;",[["^AZ"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Many."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->Many","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^AZ"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4024,"^29",4024,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^AZ"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Many."],"~$DEMUNGE_PATTERN",["^ ","^1:","~$cljs.core/DEMUNGE_PATTERN","^23","cljs/core.cljs","^28",389,"^25",1,"^29",389,"^24",21,"^1N",["^ ","^23","cljs/core.cljs","^28",389,"^25",6,"^29",389,"^24",21],"^31","^57"],"~$fix",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2772,"^25",16,"^29",2772,"^24",19,"^31","^<","^59",true,"^2:",["^2;",["^2<",["^2;",[["~$q"]]]]]],"^59",true,"^1:","~$cljs.core/fix","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["~$q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2772,"^3=","^<","^29",2772,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$q"]]]]]],"~$EmptyList",["^ ","^3S",1,"^1O",["^19",["^A>","^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]],"^1:","^>V","^23","cljs/core.cljs","^24",19,"^3W",true,"^25",10,"^28",3091,"^3X",false,"^29",3091,"^31","^3Y","^2@",["^19",["^A>","^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^8T","^4K","^21","^5E"]]],"~$HashMapIter",["^ ","^3S",3,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/HashMapIter","^23","cljs/core.cljs","^24",21,"^3W",true,"^25",10,"^28",7755,"^3X",false,"^29",7755,"^31","^3Y","^2@",null],"~$IAssociative",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",625,"^25",14,"^29",625,"^24",26,"^2A","Protocol for adding associativity to collections.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-contains-key?",[["^2O","~$k"]],"^7V",[["^2O","~$k","~$v"]]]]],"^2S",true,"^1:","^7W","^23","cljs/core.cljs","^24",26,"^25",1,"^28",625,"^2U",["^ ","^2V",["^ ","^UN",[["^2O","~$k"]],"^7V",[["^2O","~$k","~$v"]]]],"^30",null,"^29",625,"^31","^32","^33",["^19",["^4V","^4W","^4X","^4Y","^4Z","^4[","^50","^51","^52"]],"^2A","Protocol for adding associativity to collections.","^2T",["^2;",["@interface"]]],"~$->Single",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",16,"^25",10,"^26","^27","^28",4038,"^29",4038,"^2:",["^2;",["^2<",["^2;",[["^2Z"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Single."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->Single","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4038,"^29",4038,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Z"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Single."],"~$bit-flip",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2857,"^25",7,"^29",2857,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Flip bit at index n"],"^1:","~$cljs.core/bit-flip","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2857,"^29",2857,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Flip bit at index n"],"~$long-array",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3652,"^25",7,"^29",3652,"^24",17,"^2:",["^2;",["^2<",["^2;",[["^B>"],["^B?","^B@"]]]]],"^2A","Creates an array of longs. Does not coerce array, provided for compatibility\n with Clojure.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/long-array","^2C",false,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3652,"^29",3652,"^2G",2,"^2H",true,"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2A","Creates an array of longs. Does not coerce array, provided for compatibility\n with Clojure."],"~$descendants",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10710,"^25",7,"^29",10710,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^GM"],["~$h","^GM"]]]]],"^2A","Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on JavaScript type inheritance\n relationships.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^GM"],["~$h","^GM"]]],"^2:",["^2;",[["^GM"],["~$h","^GM"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/descendants","^2C",false,"^23","cljs/core.cljs","^24",18,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^GM"],["~$h","^GM"]]],"^2:",["^2;",[["^GM"],["~$h","^GM"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^GM"],["~$h","^GM"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10710,"^29",10710,"^2G",2,"^2H",true,"^2:",["^2;",[["^GM"],["~$h","^GM"]]],"^2A","Returns the immediate and indirect children of tag, through a\n relationship established via derive. h must be a hierarchy obtained\n from make-hierarchy, if not supplied defaults to the global\n hierarchy. Note: does not work on JavaScript type inheritance\n relationships."],"~$imul",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",899,"^25",17,"^29",899,"^24",21,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$a","~$b"]]]]]],"^1:","~$cljs.core/imul","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$a","~$b"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",3,"^28",899,"^3=","^<","^29",899,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$a","~$b"]]]]]],"~$->Delay",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^8>","^3U"]],"^23","cljs/core.cljs","^24",15,"^25",10,"^26","^27","^28",10371,"^29",10371,"^2:",["^2;",["^2<",["^2;",[["~$f","^4@"]]]]],"^2@",["^19",["^8>","^3U"]],"^2A","Positional factory function for cljs.core/Delay."],"^1O",["^19",["^8>","^3U"]],"^1:","~$cljs.core/->Delay","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["~$f","^4@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",10371,"^29",10371,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f","^4@"]]]]],"^2@",["^19",["^8>","^3U"]],"^2A","Positional factory function for cljs.core/Delay."],"~$array-for",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5363,"^25",8,"^29",5363,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^6>","~$i"]]]]]],"^59",true,"^1:","~$cljs.core/array-for","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^6>","~$i"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5363,"^29",5363,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6>","~$i"]]]]]],"~$merge",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8990,"^25",7,"^29",8990,"^24",12,"^2:",["^2;",["^2<",["^2;",[["~$&","^@1"]]]]],"^2A","Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^@1"]]],"^2:",["^2;",[["~$&","^@1"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/merge","^2C",true,"^23","cljs/core.cljs","^24",12,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^@1"]]],"^2:",["^2;",[["~$&","^@1"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^@1"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",8990,"^29",8990,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^@1"]]],"^2A","Returns a map that consists of the rest of the maps conj-ed onto\n the first. If a key occurs in more than one map, the mapping from\n the latter (left-to-right) will be the mapping in the result."],"~$ISeqable",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",714,"^25",14,"^29",714,"^24",22,"^2A","Protocol for adding the ability to a type to be transformed into a sequence.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-seq",[["~$o"]]]]],"^2S",true,"^1:","^1Y","^23","cljs/core.cljs","^24",22,"^25",1,"^28",714,"^2U",["^ ","^2V",["^ ","^V4",[["~$o"]]]],"^30",null,"^29",714,"^31","^32","^33",["^19",["^4V","^4W","^>R","^>S","^4X","^9[","^>T","^5F","^4Y","^4Z","^>V","^8?","^4[","^>W","^>Y","^>Z","^>[","^<:","^;V","^50","^?0","^?1","^?3","^?4","^7E","^51","^?5","^?6","^7F","^?8","^>K","^9>","^52"]],"^2A","Protocol for adding the ability to a type to be transformed into a sequence.","^2T",["^2;",["@interface"]]],"~$Empty",["^ ","^3S",0,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/Empty","^23","cljs/core.cljs","^24",15,"^3W",true,"^25",10,"^28",4057,"^3X",false,"^29",4057,"^31","^3Y","^2@",null],"~$js-mod",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2806,"^25",7,"^29",2806,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","Modulus of num and div with original javascript behavior. i.e. bug for negative numbers"],"^1:","~$cljs.core/js-mod","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["~$n","~$d"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2806,"^29",2806,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","~$d"]]]]],"^2A","Modulus of num and div with original javascript behavior. i.e. bug for negative numbers"],"~$integer?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2240,"^25",16,"^29",2240,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns true if n is a JavaScript number with no decimal part."],"^1:","~$cljs.core/integer?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2240,"^3=","^3:","^29",2240,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns true if n is a JavaScript number with no decimal part."],"~$MetaFn",["^ ","^3S",2,"^1O",["^19",["^1R","^1Z","^4E","^21"]],"^1:","^AR","^23","cljs/core.cljs","^24",16,"^3W",true,"^25",10,"^28",1995,"^3X",false,"^29",1995,"^31","^3Y","^2@",["^19",["^1R","^1Z","^21"]]],"~$NS_CACHE",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",11406,"^25",3,"^29",11406,"^24",11,"^2A","Bootstrap only.","^2T",["@type {*}"]],"^1:","~$cljs.core/NS_CACHE","^23","cljs/core.cljs","^24",11,"^25",1,"^28",11404,"^29",11406,"^31","^57","^2A","Bootstrap only.","^2T",["@type {*}"]],"~$mapv",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5175,"^25",7,"^29",5175,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]]]],"^2A","Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments.","^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/mapv","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"]]],"^2:",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",5175,"^29",5175,"^2G",4,"^2H",true,"^2:",["^2;",[["~$f","^2O"],["~$f","^;<","^;="],["~$f","^;<","^;=","^;>"],["~$f","^;<","^;=","^;>","~$&","^;?"]]],"^2A","Returns a vector consisting of the result of applying f to the\n set of first items of each coll, followed by applying f to the set\n of second items in each coll, until any one of the colls is\n exhausted. Any remaining items in other colls are ignored. Function\n f should accept number-of-colls arguments."],"~$infinite?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2311,"^25",16,"^29",2311,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true for Infinity and -Infinity values."],"^1:","~$cljs.core/infinite?","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2311,"^3=","^3:","^29",2311,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true for Infinity and -Infinity values."],"~$partition-all",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9440,"^25",7,"^29",9440,"^24",20,"^2:",["^2;",["^2<",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]]]],"^2A","Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/partition-all","^2C",false,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]],"^2:",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",9440,"^29",9440,"^2G",3,"^2H",true,"^2:",["^2;",[["~$n"],["~$n","^2O"],["~$n","^=?","^2O"]]],"^2A","Returns a lazy sequence of lists like partition, but may include\n partitions with fewer than n items at the end. Returns a stateful\n transducer when no collection is provided."],"~$partition-by",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9669,"^25",7,"^29",9669,"^24",19,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$f","^2O"]]]]],"^2A","Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/partition-by","^2C",false,"^23","cljs/core.cljs","^24",19,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$f"],["~$f","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9669,"^29",9669,"^2G",2,"^2H",true,"^2:",["^2;",[["~$f"],["~$f","^2O"]]],"^2A","Applies f to each value in coll, splitting it each time f returns a\n new value. Returns a lazy seq of partitions. Returns a stateful\n transducer when no collection is provided."],"~$ISequential",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",719,"^25",14,"^29",719,"^24",25,"^2A","Marker interface indicating a persistent collection of sequential items","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","^4K","^23","cljs/core.cljs","^24",25,"^25",1,"^28",719,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",719,"^31","^32","^33",["^19",["^>R","^>S","^9[","^>T","^5F","^4Y","^4Z","^>V","^8?","^4[","^>W","^>Y","^>Z","^>[","^;V","^50","^?0","^?1","^?3","^?4","^?5","^?6","^?8","^>K","^9>","^52"]],"^2A","Marker interface indicating a persistent collection of sequential items","^2T",["^2;",["@interface"]]],"~$->LazySeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",17,"^25",10,"^26","^27","^28",3384,"^29",3384,"^2:",["^2;",["^2<",["^2;",[["^2=","~$fn","~$s","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/LazySeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->LazySeq","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2=","^VH","~$s","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3384,"^29",3384,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^VH","~$s","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/LazySeq."],"~$equiv-map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6255,"^25",16,"^29",6255,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Test map equivalence. Returns true if x equals y, otherwise returns false."],"^1:","~$cljs.core/equiv-map","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6255,"^3=","^3:","^29",6255,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$y"]]]]],"^2A","Test map equivalence. Returns true if x equals y, otherwise returns false."],"~$->Volatile",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^3T","^3U"]],"^23","cljs/core.cljs","^24",18,"^25",10,"^26","^27","^28",4518,"^29",4518,"^2:",["^2;",["^2<",["^2;",[["^JS"]]]]],"^2@",["^19",["^3U"]],"^2A","Positional factory function for cljs.core/Volatile."],"^1O",["^19",["^3T","^3U"]],"^1:","~$cljs.core/->Volatile","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^JS"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4518,"^29",4518,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^JS"]]]]],"^2@",["^19",["^3U"]],"^2A","Positional factory function for cljs.core/Volatile."],"~$object-array",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3696,"^25",7,"^29",3696,"^24",19,"^2:",["^2;",["^2<",["^2;",[["^B>"],["^B?","^B@"]]]]],"^2A","Creates an array of objects. Does not coerce array, provided for compatibility\n with Clojure.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/object-array","^2C",false,"^23","cljs/core.cljs","^24",19,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^B>"],["^B?","^B@"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3696,"^29",3696,"^2G",2,"^2H",true,"^2:",["^2;",[["^B>"],["^B?","^B@"]]],"^2A","Creates an array of objects. Does not coerce array, provided for compatibility\n with Clojure."],"~$Keyword",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",222,"^25",20,"^29",222,"^24",27,"^5A",true],"^3S",4,"^1O",["^19",["^1P","^1Q","^1R","^1U","^U","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",3274,"^3X",false,"^5A",true,"^29",3274,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1R","^Empty",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U"]],"^23","cljs/core.cljs","^24",15,"^25",10,"^26","^27","^28",4057,"^29",4057,"^2:",["^2;",["^2<",["^2;",[[]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Empty."],"^1O",["^19",["^1U"]],"^1:","~$cljs.core/->Empty","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4057,"^29",4057,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/Empty."],"~$IChunkedSeq",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",827,"^25",14,"^29",827,"^24",25,"^2A","Protocol for accessing a collection as sequential chunks.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^GF",[["^2O"]],"^7G",[["^2O"]]]]],"^2S",true,"^1:","^7H","^23","cljs/core.cljs","^24",25,"^25",1,"^28",827,"^2U",["^ ","^2V",["^ ","^GF",[["^2O"]],"^7G",[["^2O"]]]],"^30",null,"^29",827,"^31","^32","^33",["^19",["^?6","^?8"]],"^2A","Protocol for accessing a collection as sequential chunks.","^2T",["^2;",["@interface"]]],"~$special-symbol?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11191,"^25",16,"^29",11191,"^24",31,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x names a special form"],"^1:","~$cljs.core/special-symbol?","^2C",false,"^23","cljs/core.cljs","^24",31,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11191,"^3=","^3:","^29",11191,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x names a special form"],"~$compare-keywords",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3262,"^25",8,"^29",3262,"^24",24,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$a","~$b"]]]]]],"^59",true,"^1:","~$cljs.core/compare-keywords","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$a","~$b"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3262,"^29",3262,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$a","~$b"]]]]]],"~$ancestors",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10702,"^25",7,"^29",10702,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^GM"],["~$h","^GM"]]]]],"^2A","Returns the immediate and indirect parents of tag, either via a JavaScript type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^GM"],["~$h","^GM"]]],"^2:",["^2;",[["^GM"],["~$h","^GM"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/ancestors","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^GM"],["~$h","^GM"]]],"^2:",["^2;",[["^GM"],["~$h","^GM"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^GM"],["~$h","^GM"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10702,"^29",10702,"^2G",2,"^2H",true,"^2:",["^2;",[["^GM"],["~$h","^GM"]]],"^2A","Returns the immediate and indirect parents of tag, either via a JavaScript type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy"],"~$subseq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9496,"^25",7,"^29",9496,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^9D","^9E","^2Y"],["^9D","~$start-test","~$start-key","~$end-test","~$end-key"]]]]],"^2A","sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true","^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2:",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/subseq","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2:",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9496,"^29",9496,"^2G",5,"^2H",true,"^2:",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2A","sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true"],"~$gensym",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10359,"^25",7,"^29",10359,"^24",13,"^2:",["^2;",["^2<",["^2;",[[],["~$prefix-string"]]]]],"^2A","Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'.","^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^W9"]]],"^2:",["^2;",[[],["^W9"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/gensym","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",1,"^2D",["^2;",[[],["^W9"]]],"^2:",["^2;",[[],["^W9"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[[],["^W9"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10359,"^29",10359,"^2G",1,"^2H",true,"^2:",["^2;",[[],["^W9"]]],"^2A","Returns a new symbol with a unique name. If a prefix string is\n supplied, the name is prefix# where # is some unique number. If\n prefix is not supplied, the prefix is 'G__'."],"^C4",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",613,"^25",16,"^29",613,"^24",21,"^31","^RZ","^5Y","^4J","^2A","Returns a new collection of coll without the first item. In contrast to\n rest, it should return nil if there are no more items, e.g.\n (next []) => nil\n (next nil) => nil","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^4J","^1:","~$cljs.core/-next","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",611,"^3=","^RZ","^29",613,"^2G",1,"^31","^RZ","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a new collection of coll without the first item. In contrast to\n rest, it should return nil if there are no more items, e.g.\n (next []) => nil\n (next nil) => nil"],"~$->HashCollisionNode",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1U","^20"]],"^23","cljs/core.cljs","^24",27,"^25",10,"^26","^27","^28",7490,"^29",7490,"^2:",["^2;",["^2<",["^2;",[["^=J","~$collision-hash","^67","^66"]]]]],"^2@",["^19",["^20"]],"^2A","Positional factory function for cljs.core/HashCollisionNode."],"^1O",["^19",["^1U","^20"]],"^1:","~$cljs.core/->HashCollisionNode","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^=J","^W=","^67","^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",7490,"^29",7490,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^W=","^67","^66"]]]]],"^2@",["^19",["^20"]],"^2A","Positional factory function for cljs.core/HashCollisionNode."],"~$delay?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10383,"^25",16,"^29",10383,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","returns true if x is a Delay created with delay"],"^1:","~$cljs.core/delay?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10383,"^3=","^3:","^29",10383,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","returns true if x is a Delay created with delay"],"~$create-inode-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7671,"^25",8,"^29",7671,"^24",24,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^OU"],["^OU","~$i","~$s"]]]]],"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^OU"],["^OU","~$i","~$s"]]],"^2:",["^2;",[["^OU"],["^OU","~$i","~$s"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/create-inode-seq","^2C",false,"^23","cljs/core.cljs","^24",24,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^OU"],["^OU","~$i","~$s"]]],"^2:",["^2;",[["^OU"],["^OU","~$i","~$s"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^OU"],["^OU","~$i","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7671,"^29",7671,"^2G",3,"^2H",true,"^2:",["^2;",[["^OU"],["^OU","~$i","~$s"]]]],"~$flatten",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5151,"^25",7,"^29",5151,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat sequence.\n (flatten nil) returns nil."],"^1:","~$cljs.core/flatten","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5151,"^29",5151,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Takes any nested combination of sequential things (lists, vectors,\n etc.) and returns their contents as a single, flat sequence.\n (flatten nil) returns nil."],"^SJ",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",641,"^25",9,"^29",641,"^24",16,"^31","^5X","^5Y","^A6","^2A","Returns a new collection of coll without the mapping for key k.","^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]]],"^5Y","^A6","^1:","~$cljs.core/-dissoc","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2O","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",638,"^3=","^5X","^29",641,"^2G",2,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]],"^2A","Returns a new collection of coll without the mapping for key k."],"~$doubles",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2803,"^25",7,"^29",2803,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/doubles","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2803,"^29",2803,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$halt-when",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10418,"^25",7,"^29",10418,"^24",16,"^2:",["^2;",["^2<",["^2;",[["^4<"],["^4<","~$retf"]]]]],"^2A","Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected.","^76","1.9","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^WI"]]],"^2:",["^2;",[["^4<"],["^4<","^WI"]]],"^2F",["^2;",[null,null]]]],"^76","1.9","^1:","~$cljs.core/halt-when","^2C",false,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^WI"]]],"^2:",["^2;",[["^4<"],["^4<","^WI"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^4<"],["^4<","^WI"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10418,"^29",10418,"^2G",2,"^2H",true,"^2:",["^2;",[["^4<"],["^4<","^WI"]]],"^2A","Returns a transducer that ends transduction when pred returns true\n for an input. When retf is supplied it must be a fn of 2 arguments -\n it will be passed the (completed) result so far and the input that\n triggered the predicate, and its return value (if it does not throw\n an exception) will be the return value of the transducer. If retf\n is not supplied, the input that triggered the predicate will be\n returned. If the predicate never returns true the transduction is\n unaffected."],"^UN",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",627,"^25",13,"^29",627,"^24",27,"^31","^3:","^5Y","^7W","^2A","Returns true if k is a key in coll.","^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]]],"^5Y","^7W","^1:","~$cljs.core/-contains-key?","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2O","~$k"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",625,"^3=","^3:","^29",627,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O","~$k"]]]]],"^2A","Returns true if k is a key in coll."],"~$remove-watch",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10347,"^25",7,"^29",10347,"^24",19,"^2:",["^2;",["^2<",["^2;",[["^FY","^2Y"]]]]],"^2A","Removes a watch (set by add-watch) from a reference"],"^1:","~$cljs.core/remove-watch","^2C",false,"^23","cljs/core.cljs","^24",19,"^2D",["^2;",[["^FY","^2Y"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10347,"^29",10347,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^FY","^2Y"]]]]],"^2A","Removes a watch (set by add-watch) from a reference"],"~$ex-info",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11156,"^25",7,"^29",11156,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$msg","^LN"],["^WO","^LN","^LO"]]]]],"^2A","Create an instance of ExceptionInfo, an Error type that carries a\n map of additional data.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^WO","^LN"],["^WO","^LN","^LO"]]],"^2:",["^2;",[["^WO","^LN"],["^WO","^LN","^LO"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/ex-info","^2C",false,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^WO","^LN"],["^WO","^LN","^LO"]]],"^2:",["^2;",[["^WO","^LN"],["^WO","^LN","^LO"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^WO","^LN"],["^WO","^LN","^LO"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11156,"^29",11156,"^2G",3,"^2H",true,"^2:",["^2;",[["^WO","^LN"],["^WO","^LN","^LO"]]],"^2A","Create an instance of ExceptionInfo, an Error type that carries a\n map of additional data."],"~$ifn?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2235,"^25",16,"^29",2235,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Returns true if f returns true for fn? or satisfies IFn."],"^1:","~$cljs.core/ifn?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2235,"^3=","^3:","^29",2235,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Returns true if f returns true for fn? or satisfies IFn."],"~$IAtom",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",846,"^25",14,"^29",846,"^24",19,"^2A","Marker protocol indicating an atom.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","^JR","^23","cljs/core.cljs","^24",19,"^25",1,"^28",846,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",846,"^31","^32","^33",["^19",["^?7"]],"^2A","Marker protocol indicating an atom.","^2T",["^2;",["@interface"]]],"~$->PersistentQueue",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^1Y","^1Z","^1[","^8T","^20","^4K","^21"]],"^23","cljs/core.cljs","^24",25,"^25",10,"^26","^27","^28",6176,"^29",6176,"^2:",["^2;",["^2<",["^2;",[["^2=","^AG","^4L","^4M","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^1Y","^1Z","^1[","^8T","^20","^4K","^21"]],"^2A","Positional factory function for cljs.core/PersistentQueue."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^1Y","^1Z","^1[","^8T","^20","^4K","^21"]],"^1:","~$cljs.core/->PersistentQueue","^2C",false,"^23","cljs/core.cljs","^24",25,"^2D",["^2;",[["^2=","^AG","^4L","^4M","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6176,"^29",6176,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^AG","^4L","^4M","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^1Y","^1Z","^1[","^8T","^20","^4K","^21"]],"^2A","Positional factory function for cljs.core/PersistentQueue."],"~$nat-int?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2286,"^25",16,"^29",2286,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies int? and is a natural integer value."],"^1:","~$cljs.core/nat-int?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2286,"^3=","^3:","^29",2286,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies int? and is a natural integer value."],"~$IWatchable",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",771,"^25",14,"^29",771,"^24",24,"^2A","Protocol for types that can be watched. Currently only implemented by Atom.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^IE",[["^CV","^ED","^:U"]],"^DJ",[["^CV","^2Y","~$f"]],"^CT",[["^CV","^2Y"]]]]],"^2S",true,"^1:","^CU","^23","cljs/core.cljs","^24",24,"^25",1,"^28",771,"^2U",["^ ","^2V",["^ ","^IE",[["^CV","^ED","^:U"]],"^DJ",[["^CV","^2Y","~$f"]],"^CT",[["^CV","^2Y"]]]],"^30",null,"^29",771,"^31","^32","^33",["^19",["^?7"]],"^2A","Protocol for types that can be watched. Currently only implemented by Atom.","^2T",["^2;",["@interface"]]],"~$pv-fresh-node",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5297,"^25",8,"^29",5297,"^24",21,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^=J"]]]]]],"^59",true,"^1:","~$cljs.core/pv-fresh-node","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["^=J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5297,"^29",5297,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J"]]]]]],"~$subvec",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5906,"^25",7,"^29",5906,"^24",13,"^2:",["^2;",["^2<",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]]]],"^2A","Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]],"^2:",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/subvec","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]],"^2:",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5906,"^29",5906,"^2G",3,"^2H",true,"^2:",["^2;",[["~$v","^4P"],["~$v","^4P","^4Q"]]],"^2A","Returns a persistent vector of the items in vector from\n start (inclusive) to end (exclusive). If end is not supplied,\n defaults to (count vector). This operation is O(1) and very fast, as\n the resulting vector shares structure with the original and no\n trimming is done."],"^H5",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",808,"^25",9,"^29",808,"^24",14,"^31","^5X","^5Y","^?W","^2A","Returns tcoll with the last item removed from it.","^2:",["^2;",["^2<",["^2;",[["^2X"]]]]]],"^5Y","^?W","^1:","~$cljs.core/-pop!","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2X"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",804,"^3=","^5X","^29",808,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2X"]]]]],"^2A","Returns tcoll with the last item removed from it."],"~$partial",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4259,"^25",7,"^29",4259,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$f"],["~$f","~$arg1"],["~$f","^X3","~$arg2"],["~$f","^X3","^X4","~$arg3"],["~$f","^X3","^X4","^X5","~$&","^6A"]]]]],"^2A","Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args.","^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$f"],["~$f","^X3"],["~$f","^X3","^X4"],["~$f","^X3","^X4","^X5"]]],"^2:",["^2;",[["~$f"],["~$f","^X3"],["~$f","^X3","^X4"],["~$f","^X3","^X4","^X5"],["~$f","^X3","^X4","^X5","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null,null]]]],"^1:","~$cljs.core/partial","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",4,"^2D",["^2;",[["~$f"],["~$f","^X3"],["~$f","^X3","^X4"],["~$f","^X3","^X4","^X5"]]],"^2:",["^2;",[["~$f"],["~$f","^X3"],["~$f","^X3","^X4"],["~$f","^X3","^X4","^X5"],["~$f","^X3","^X4","^X5","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null,null]]],"^2D",["^2;",[["~$f"],["~$f","^X3"],["~$f","^X3","^X4"],["~$f","^X3","^X4","^X5"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null]],"^25",1,"^28",4259,"^29",4259,"^2G",4,"^2H",true,"^2:",["^2;",[["~$f"],["~$f","^X3"],["~$f","^X3","^X4"],["~$f","^X3","^X4","^X5"],["~$f","^X3","^X4","^X5","~$&","^6A"]]],"^2A","Takes a function f and fewer than the normal arguments to f, and\n returns a fn that takes a variable number of additional args. When\n called, the returned function calls f with args + additional args."],"~$chunked-seq?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2151,"^25",16,"^29",2151,"^24",28,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is satisfies IChunkedSeq."],"^1:","~$cljs.core/chunked-seq?","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2151,"^3=","^3:","^29",2151,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x is satisfies IChunkedSeq."],"~$replicate",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4962,"^25",7,"^29",4962,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$n","~$x"]]]]],"^2A","DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs."],"^1:","~$cljs.core/replicate","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$n","~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4962,"^29",4962,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n","~$x"]]]]],"^2A","DEPRECATED: Use 'repeat' instead.\n Returns a lazy seq of n xs."],"~$PersistentQueue",["^ ","^3S",5,"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^1Y","^1Z","^1[","^8T","^20","^4K","^21"]],"^1:","^>T","^23","cljs/core.cljs","^24",25,"^3W",true,"^25",10,"^28",6176,"^3X",false,"^29",6176,"^31","^3Y","^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^1Y","^1Z","^1[","^8T","^20","^4K","^21"]]],"~$min-key",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9420,"^25",7,"^29",9420,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"],["~$k","~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned.","^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"]]],"^2:",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"],["~$k","~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/min-key","^2C",true,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"]]],"^2:",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"],["~$k","~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",9420,"^29",9420,"^2G",3,"^2H",true,"^2:",["^2;",[["~$k","~$x"],["~$k","~$x","~$y"],["~$k","~$x","~$y","~$&","^6A"]]],"^2A","Returns the x for which (k x), a number, is least.\n\n If there are multiple such xs, the last one is returned."],"~$hash-iset",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2994,"^25",8,"^29",2994,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"^59",true,"^1:","~$cljs.core/hash-iset","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2994,"^29",2994,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$s"]]]]]],"~$reduced",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1421,"^25",7,"^29",1421,"^24",14,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Wraps x in a way such that a reduce will terminate with the value x"],"^1:","~$cljs.core/reduced","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1421,"^29",1421,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Wraps x in a way such that a reduce will terminate with the value x"],"~$re-matches",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9805,"^25",7,"^29",9805,"^24",17,"^2:",["^2;",["^2<",["^2;",[["^<>","~$s"]]]]],"^2A","Returns the result of (re-find re s) if re fully matches s."],"^1:","~$cljs.core/re-matches","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^<>","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9805,"^29",9805,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^<>","~$s"]]]]],"^2A","Returns the result of (re-find re s) if re fully matches s."],"~$pr-writer-impl",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9912,"^25",8,"^29",9912,"^24",22,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^7K","^2J"]]]]]],"^59",true,"^1:","~$cljs.core/pr-writer-impl","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["^3;","^7K","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9912,"^29",9912,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^7K","^2J"]]]]]],"~$array-map",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8797,"^25",7,"^29",8797,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$&","^9T"]]]]],"^2A","keyval => key val\n Returns a new array map with supplied mappings.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^9T"]]],"^2:",["^2;",[["~$&","^9T"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/array-map","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^9T"]]],"^2:",["^2;",[["~$&","^9T"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^9T"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",8797,"^29",8797,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^9T"]]],"^2A","keyval => key val\n Returns a new array map with supplied mappings."],"~$ITransientSet",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",811,"^25",14,"^29",811,"^24",27,"^2A","Protocol for adding set functionality to a transient collection.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-disjoin!",[["^2X","~$v"]]]]],"^2S",true,"^1:","^PF","^23","cljs/core.cljs","^24",27,"^25",1,"^28",811,"^2U",["^ ","^2V",["^ ","^XI",[["^2X","~$v"]]]],"^30",null,"^29",811,"^31","^32","^33",["^19",["^7D"]],"^2A","Protocol for adding set functionality to a transient collection.","^2T",["^2;",["@interface"]]],"~$ITER_SYMBOL",["^ ","^1:","~$cljs.core/ITER_SYMBOL","^23","cljs/core.cljs","^28",333,"^25",3,"^29",333,"^24",19,"^1N",["^ ","^23","cljs/core.cljs","^28",333,"^25",8,"^29",333,"^24",19],"^31","^90"],"~$unchecked-byte",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2690,"^25",15,"^29",2690,"^24",29,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/unchecked-byte","^2C",false,"^23","cljs/core.cljs","^24",29,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2690,"^3=","^<","^29",2690,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$checked-aset",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",466,"^25",8,"^29",466,"^24",20,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]]]],"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/checked-aset","^2C",true,"^23","cljs/core.cljs","^24",20,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",466,"^29",466,"^2G",3,"^2H",true,"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]]],"~$ArrayNode",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",7105,"^25",10,"^29",7105,"^24",19,"^5A",true],"^3S",3,"^1O",["^19",["^1U","^20"]],"^1:","^?>","^23","cljs/core.cljs","^24",19,"^3W",true,"^25",10,"^28",7380,"^3X",false,"^5A",true,"^29",7380,"^31","^3Y","^2@",["^19",["^20"]]],"~$->ChunkedSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^5D","^1S","^@S","^1U","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",5667,"^29",5667,"^2:",["^2;",["^2<",["^2;",[["^I<","^84","~$i","^>4","^2=","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^5D","^1S","^@S","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/ChunkedSeq."],"^1O",["^19",["^1P","^1Q","^5D","^1S","^@S","^1U","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21","^5E"]],"^1:","~$cljs.core/->ChunkedSeq","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^I<","^84","~$i","^>4","^2=","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",5667,"^29",5667,"^2G",6,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^I<","^84","~$i","^>4","^2=","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^5D","^1S","^@S","^1W","^4?","^4J","^1Y","^1Z","^7H","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/ChunkedSeq."],"~$every-pred",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4576,"^25",7,"^29",4576,"^24",17,"^2:",["^2;",["^2<",["^2;",[["~$p"],["~$p1","~$p2"],["^XT","^XU","~$p3"],["^XT","^XU","^XV","~$&","~$ps"]]]]],"^2A","Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates.","^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["~$p"],["^XT","^XU"],["^XT","^XU","^XV"]]],"^2:",["^2;",[["~$p"],["^XT","^XU"],["^XT","^XU","^XV"],["^XT","^XU","^XV","~$&","^XW"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/every-pred","^2C",true,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["~$p"],["^XT","^XU"],["^XT","^XU","^XV"]]],"^2:",["^2;",[["~$p"],["^XT","^XU"],["^XT","^XU","^XV"],["^XT","^XU","^XV","~$&","^XW"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[["~$p"],["^XT","^XU"],["^XT","^XU","^XV"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",4576,"^29",4576,"^2G",3,"^2H",true,"^2:",["^2;",[["~$p"],["^XT","^XU"],["^XT","^XU","^XV"],["^XT","^XU","^XV","~$&","^XW"]]],"^2A","Takes a set of predicates and returns a function f that returns true if all of its\n composing predicates return a logical true value against all of its arguments, else it returns\n false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical false result against the original predicates."],"^CM",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8903,"^25",7,"^29",8903,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^2>"]]]]],"^2A","Returns a sequence of the map's keys."],"^1:","~$cljs.core/keys","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["^2>"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8903,"^29",8903,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2>"]]]]],"^2A","Returns a sequence of the map's keys."],"~$missing-protocol",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",311,"^25",7,"^29",311,"^24",23,"^2:",["^2;",["^2<",["^2;",[["~$proto","^3;"]]]]]],"^1:","~$cljs.core/missing-protocol","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["^X[","^3;"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",311,"^29",311,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^X[","^3;"]]]]]],"~$load-file",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",326,"^25",7,"^29",326,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$file"]]]]]],"^1:","~$cljs.core/load-file","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^Y2"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",326,"^29",326,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^Y2"]]]]]],"~$PersistentArrayMap",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",1959,"^25",28,"^29",1959,"^24",46,"^5A",true],"^3S",4,"^1O",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1U","^4U","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22","^5E"]],"^1:","^4X","^23","cljs/core.cljs","^24",28,"^3W",true,"^25",10,"^28",6733,"^3X",false,"^5A",true,"^29",6733,"^31","^3Y","^2@",["^19",["^98","^1P","^1Q","^1R","^1S","^1T","^1W","^1X","^1Y","^1Z","^1[","^20","^21","^7W","^A6","^22","^5E"]]],"~$distinct?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2338,"^25",16,"^29",2338,"^24",25,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns true if no two of the arguments are =","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/distinct?","^2C",true,"^23","cljs/core.cljs","^24",25,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2338,"^3=","^3:","^29",2338,"^2G",2,"^31","^3:","^2H",true,"^2:",["^2;",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns true if no two of the arguments are ="],"~$pos-int?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2256,"^25",16,"^29",2256,"^24",24,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies int? and is positive."],"^1:","~$cljs.core/pos-int?","^2C",false,"^23","cljs/core.cljs","^24",24,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2256,"^3=","^3:","^29",2256,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Return true if x satisfies int? and is positive."],"~$never-equiv",["^ ","^1:","~$cljs.core/never-equiv","^23","cljs/core.cljs","^28",6253,"^25",1,"^29",6253,"^24",27,"^59",true,"^1N",["^ ","^23","cljs/core.cljs","^28",6253,"^25",16,"^29",6253,"^24",27,"^59",true],"^31","^G7"],"~$unchecked-short",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2692,"^25",15,"^29",2692,"^24",30,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/unchecked-short","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2692,"^3=","^<","^29",2692,"^2G",1,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$->Range",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5B","^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",15,"^25",10,"^26","^27","^28",9537,"^29",9537,"^2:",["^2;",["^2<",["^2;",[["^2=","^4P","^4Q","^=?","^2?"]]]]],"^2@",["^19",["^5B","^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Range."],"^1O",["^19",["^5B","^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^1:","~$cljs.core/->Range","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^2=","^4P","^4Q","^=?","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",9537,"^29",9537,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^4P","^4Q","^=?","^2?"]]]]],"^2@",["^19",["^5B","^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Range."],"~$->MapEntry",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^23","cljs/core.cljs","^24",18,"^25",10,"^26","^27","^28",6555,"^29",6555,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^2?"]]]]],"^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^2A","Positional factory function for cljs.core/MapEntry."],"^1O",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1U","^4U","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^1:","~$cljs.core/->MapEntry","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^2Y","^2Z","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",6555,"^29",6555,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Y","^2Z","^2?"]]]]],"^2@",["^19",["^5B","^8S","^5C","^1P","^1Q","^1R","^1S","^1W","^1X","^1Y","^1Z","^8T","^8U","^4K","^21","^7W","^22","^5E"]],"^2A","Positional factory function for cljs.core/MapEntry."],"~$apply-to-simple",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3849,"^25",8,"^29",3849,"^24",23,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$f","^AD"],["~$f","~$a0","^AD"],["~$f","^YB","~$a1","^AD"],["~$f","^YB","^YC","~$a2","^AD"],["~$f","^YB","^YC","^YD","~$a3","^AD"]]]]],"^2A","Internal. DO NOT USE!\n Assumes args was already called with seq beforehand!","^2K",["^ ","^2C",false,"^2G",6,"^2D",["^2;",[["~$f","^AD"],["~$f","^YB","^AD"],["~$f","^YB","^YC","^AD"],["~$f","^YB","^YC","^YD","^AD"],["~$f","^YB","^YC","^YD","^YE","^AD"]]],"^2:",["^2;",[["~$f","^AD"],["~$f","^YB","^AD"],["~$f","^YB","^YC","^AD"],["~$f","^YB","^YC","^YD","^AD"],["~$f","^YB","^YC","^YD","^YE","^AD"]]],"^2F",["^2;",[null,null,null,null,null]]]],"^59",true,"^1:","~$cljs.core/apply-to-simple","^2C",false,"^23","cljs/core.cljs","^24",23,"^2K",["^ ","^2C",false,"^2G",6,"^2D",["^2;",[["~$f","^AD"],["~$f","^YB","^AD"],["~$f","^YB","^YC","^AD"],["~$f","^YB","^YC","^YD","^AD"],["~$f","^YB","^YC","^YD","^YE","^AD"]]],"^2:",["^2;",[["~$f","^AD"],["~$f","^YB","^AD"],["~$f","^YB","^YC","^AD"],["~$f","^YB","^YC","^YD","^AD"],["~$f","^YB","^YC","^YD","^YE","^AD"]]],"^2F",["^2;",[null,null,null,null,null]]],"^2D",["^2;",[["~$f","^AD"],["~$f","^YB","^AD"],["~$f","^YB","^YC","^AD"],["~$f","^YB","^YC","^YD","^AD"],["~$f","^YB","^YC","^YD","^YE","^AD"]]],"^2E",null,"^2F",["^2;",[null,null,null,null,null]],"^25",1,"^28",3849,"^29",3849,"^2G",6,"^2H",true,"^2:",["^2;",[["~$f","^AD"],["~$f","^YB","^AD"],["~$f","^YB","^YC","^AD"],["~$f","^YB","^YC","^YD","^AD"],["~$f","^YB","^YC","^YD","^YE","^AD"]]],"^2A","Internal. DO NOT USE!\n Assumes args was already called with seq beforehand!"],"~$methods",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11044,"^25",7,"^29",11044,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, returns a map of dispatch values -> dispatch fns"],"^1:","~$cljs.core/methods","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^87"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11044,"^29",11044,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^87"]]]]],"^2A","Given a multimethod, returns a map of dispatch values -> dispatch fns"],"~$odd?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",4212,"^25",16,"^29",4212,"^24",20,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns true if n is odd, throws an exception if n is not an integer"],"^1:","~$cljs.core/odd?","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",4212,"^3=","^3:","^29",4212,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$n"]]]]],"^2A","Returns true if n is odd, throws an exception if n is not an integer"],"~$->ArrayChunk",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^5B","^1X","^:F","^5E"]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",3481,"^29",3481,"^2:",["^2;",["^2<",["^2;",[["^66","^>4","^4Q"]]]]],"^2@",["^19",["^5B","^1X","^5E"]],"^2A","Positional factory function for cljs.core/ArrayChunk."],"^1O",["^19",["^5B","^1X","^:F","^5E"]],"^1:","~$cljs.core/->ArrayChunk","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^66","^>4","^4Q"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3481,"^29",3481,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^66","^>4","^4Q"]]]]],"^2@",["^19",["^5B","^1X","^5E"]],"^2A","Positional factory function for cljs.core/ArrayChunk."],"~$ci-reduce",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1451,"^25",8,"^29",1451,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$cicoll","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]]]],"^2A","Accepts any collection which satisfies the ICount and IIndexed protocols and\nreduces them without incurring seq initialization","^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^YN","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]],"^2:",["^2;",[["^YN","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]],"^2F",["^2;",[null,null,null]]]],"^59",true,"^1:","~$cljs.core/ci-reduce","^2C",false,"^23","cljs/core.cljs","^24",17,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^YN","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]],"^2:",["^2;",[["^YN","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[["^YN","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",1451,"^29",1451,"^2G",4,"^2H",true,"^2:",["^2;",[["^YN","~$f"],["^YN","~$f","^2Z"],["^YN","~$f","^2Z","^7:"]]],"^2A","Accepts any collection which satisfies the ICount and IIndexed protocols and\nreduces them without incurring seq initialization"],"~$*3",["^ ","^1:","~$cljs.core/*3","^23","cljs/core.cljs","^28",207,"^25",1,"^29",209,"^24",5,"^2A","bound in a repl thread to the third most recent value printed","^1N",["^ ","^23","cljs/core.cljs","^28",209,"^25",3,"^29",209,"^24",5,"^2A","bound in a repl thread to the third most recent value printed"]],"^UC",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10834,"^25",4,"^29",10834,"^24",15,"^5Y","^7Q","^2A",null,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S"]]]]]],"^5Y","^7Q","^1:","~$cljs.core/-get-method","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[["^7R","^7S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10829,"^29",10834,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^7R","^7S"]]]]],"^2A",null],"~$->Var",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1R","^1U","^1Z","^4E","^3U","^21"]],"^23","cljs/core.cljs","^24",13,"^25",10,"^26","^27","^28",1110,"^29",1110,"^2:",["^2;",["^2<",["^2;",[["^2Z","^GU","^G1"]]]]],"^2@",["^19",["^1P","^1Q","^1R","^1Z","^3U","^21"]],"^2A","Positional factory function for cljs.core/Var."],"^1O",["^19",["^1P","^1Q","^1R","^1U","^1Z","^4E","^3U","^21"]],"^1:","~$cljs.core/->Var","^2C",false,"^23","cljs/core.cljs","^24",13,"^2D",["^2;",[["^2Z","^GU","^G1"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",1110,"^29",1110,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2Z","^GU","^G1"]]]]],"^2@",["^19",["^1P","^1Q","^1R","^1Z","^3U","^21"]],"^2A","Positional factory function for cljs.core/Var."],"~$frequencies",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9710,"^25",7,"^29",9710,"^24",18,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a map from distinct items in coll to the number of times\n they appear."],"^1:","~$cljs.core/frequencies","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9710,"^29",9710,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a map from distinct items in coll to the number of times\n they appear."],"~$reduceable?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2129,"^25",16,"^29",2129,"^24",27,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll satisfies IReduce"],"^1:","~$cljs.core/reduceable?","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2129,"^3=","^3:","^29",2129,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if coll satisfies IReduce"],"~$string-hash-cache",["^ ","^1:","~$cljs.core/string-hash-cache","^23","cljs/core.cljs","^28",955,"^25",1,"^29",955,"^24",23,"^1N",["^ ","^23","cljs/core.cljs","^28",955,"^25",6,"^29",955,"^24",23],"^31","^45"],"~$->Iterate",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",17,"^25",10,"^26","^27","^28",4976,"^29",4976,"^2:",["^2;",["^2<",["^2;",[["^2=","~$f","~$prev-seed","^IX","~$next"]]]]],"^2@",["^19",["^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Iterate."],"^1O",["^19",["^1S","^1U","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->Iterate","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^2=","~$f","^Z0","^IX","^Z1"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",4976,"^29",4976,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","~$f","^Z0","^IX","^Z1"]]]]],"^2@",["^19",["^1S","^8>","^1W","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Iterate."],"~$rsubseq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9511,"^25",7,"^29",9511,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]]]],"^2A","sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true","^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2:",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/rsubseq","^2C",false,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",false,"^2G",5,"^2D",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2:",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9511,"^29",9511,"^2G",5,"^2H",true,"^2:",["^2;",[["^9D","^9E","^2Y"],["^9D","^W3","^W4","^W5","^W6"]]],"^2A","sc must be a sorted collection, test(s) one of <, <=, > or\n >=. Returns a reverse seq of those entries with keys ek for\n which (test (.. sc comparator (compare ek key)) 0) is true"],"~$inc",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1411,"^25",7,"^29",1411,"^24",10,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one greater than num."],"^1:","~$cljs.core/inc","^2C",false,"^23","cljs/core.cljs","^24",10,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1411,"^29",1411,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns a number one greater than num."],"~$type->str",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",320,"^25",7,"^29",320,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$ty"]]]]]],"^1:","~$cljs.core/type->str","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^Z8"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",320,"^29",320,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^Z8"]]]]]],"~$obj-clone",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6311,"^25",8,"^29",6311,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^8J"]]]]]],"^59",true,"^1:","~$cljs.core/obj-clone","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^3;","^8J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6311,"^29",6311,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^8J"]]]]]],"~$get-method",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11048,"^25",7,"^29",11048,"^24",17,"^2:",["^2;",["^2<",["^2;",[["^87","^7S"]]]]],"^2A","Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default"],"^1:","~$cljs.core/get-method","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^87","^7S"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11048,"^29",11048,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^87","^7S"]]]]],"^2A","Given a multimethod and a dispatch value, returns the dispatch fn\n that would apply to that value, or nil if none apply and no default"],"~$uuid?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",11111,"^25",16,"^29",11111,"^24",21,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/uuid?","^2C",false,"^23","cljs/core.cljs","^24",21,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",11111,"^3=","^3:","^29",11111,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"~$vector-index-out-of-bounds",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5341,"^25",8,"^29",5341,"^24",34,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$i","^67"]]]]]],"^59",true,"^1:","~$cljs.core/vector-index-out-of-bounds","^2C",false,"^23","cljs/core.cljs","^24",34,"^2D",["^2;",[["~$i","^67"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5341,"^29",5341,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$i","^67"]]]]]],"~$es6-entries-iterator",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6460,"^25",7,"^29",6460,"^24",27,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^1:","~$cljs.core/es6-entries-iterator","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6460,"^29",6460,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"~$bit-clear",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2852,"^25",7,"^29",2852,"^24",16,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Clear bit at index n"],"^1:","~$cljs.core/bit-clear","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2852,"^29",2852,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]],"^2A","Clear bit at index n"],"~$Range",["^ ","^3S",5,"^1O",["^19",["^5B","^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]],"^1:","^>K","^23","cljs/core.cljs","^24",15,"^3W",true,"^25",10,"^28",9537,"^3X",false,"^29",9537,"^31","^3Y","^2@",["^19",["^5B","^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^1[","^20","^4K","^21","^5E"]]],"~$filter",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",5099,"^25",7,"^29",5099,"^24",13,"^2:",["^2;",["^2<",["^2;",[["^4<"],["^4<","^2O"]]]]],"^2A","Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/filter","^2C",false,"^23","cljs/core.cljs","^24",13,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^4<"],["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",5099,"^29",5099,"^2G",2,"^2H",true,"^2:",["^2;",[["^4<"],["^4<","^2O"]]],"^2A","Returns a lazy sequence of the items in coll for which\n (pred item) returns logical true. pred must be free of side-effects.\n Returns a transducer when no collection is provided."],"~$->PersistentTreeMapSeq",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",30,"^25",10,"^26","^27","^28",8066,"^29",8066,"^2:",["^2;",["^2<",["^2;",[["^2=","^@","^6V","^67","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/PersistentTreeMapSeq."],"^1O",["^19",["^1P","^1Q","^1S","^1U","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^1:","~$cljs.core/->PersistentTreeMapSeq","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["^2=","^@","^6V","^67","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",8066,"^29",8066,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^@","^6V","^67","^2?"]]]]],"^2@",["^19",["^1P","^1Q","^1S","^1W","^1X","^4?","^4J","^1Y","^1Z","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/PersistentTreeMapSeq."],"~$create-array-node-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",7741,"^25",8,"^29",7741,"^24",29,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]]]],"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]],"^2:",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]],"^2F",["^2;",[null,null]]]],"^59",true,"^1:","~$cljs.core/create-array-node-seq","^2C",false,"^23","cljs/core.cljs","^24",29,"^2K",["^ ","^2C",false,"^2G",4,"^2D",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]],"^2:",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",7741,"^29",7741,"^2G",4,"^2H",true,"^2:",["^2;",[["^OU"],["^2=","^OU","~$i","~$s"]]]],"^H4",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",806,"^25",9,"^29",806,"^24",18,"^31","^5X","^5Y","^?W","^2A","Returns tcoll with value val added at position n.","^2:",["^2;",["^2<",["^2;",[["^2X","~$n","^2Z"]]]]]],"^5Y","^?W","^1:","~$cljs.core/-assoc-n!","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^2X","~$n","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",804,"^3=","^5X","^29",806,"^2G",3,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2X","~$n","^2Z"]]]]],"^2A","Returns tcoll with value val added at position n."],"~$IWithMeta",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",684,"^25",14,"^29",684,"^24",23,"^2A","Protocol for adding metadata to an object.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^5W",[["~$o","^2="]]]]],"^2S",true,"^1:","^21","^23","cljs/core.cljs","^24",23,"^25",1,"^28",684,"^2U",["^ ","^2V",["^ ","^5W",[["~$o","^2="]]]],"^30",null,"^29",684,"^31","^32","^33",["^19",["^4V","^4W","^>R","^4X","^9[","^>T","^5F","^4Y","^4Z","^>V","^8?","^4[","^>W","^4F","^>Y","^>Z","^>[","^;V","^50","^?0","^?1","^?3","^?4","^7E","^51","^?5","^?6","^7F","^?8","^K","^9>","^52"]],"^2A","Protocol for adding metadata to an object.","^2T",["^2;",["@interface"]]],"~$list",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3177,"^25",7,"^29",3177,"^24",11,"^2:",["^2;",["^2<",["^2;",[["~$&","^5:"]]]]],"^2A","Creates a new list containing the items.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^5:"]]],"^2:",["^2;",[["~$&","^5:"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/list","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^5:"]]],"^2:",["^2;",[["~$&","^5:"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^5:"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",3177,"^29",3177,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^5:"]]],"^2A","Creates a new list containing the items."],"~$+",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2579,"^25",15,"^29",2579,"^24",16,"^31","^<","^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]]]],"^2A","Returns the sum of nums. (+) returns 0.","^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]]],"^1:","~$cljs.core/+","^2C",true,"^23","cljs/core.cljs","^24",16,"^2K",["^ ","^2C",true,"^2G",2,"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2F",["^2;",[null,null,null,null]]],"^2D",["^2;",[[],["~$x"],["~$x","~$y"]]],"^2E",null,"^2F",["^2;",[null,null,null,null]],"^25",1,"^28",2579,"^3=","^<","^29",2579,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^6A"]]],"^2A","Returns the sum of nums. (+) returns 0."],"~$IndexedSeqIterator",["^ ","^3S",2,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/IndexedSeqIterator","^23","cljs/core.cljs","^24",28,"^3W",true,"^25",10,"^28",1559,"^3X",false,"^29",1559,"^31","^3Y","^2@",null],"~$split-with",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9664,"^25",7,"^29",9664,"^24",17,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns a vector of [(take-while pred coll) (drop-while pred coll)]"],"^1:","~$cljs.core/split-with","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^4<","^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9664,"^29",9664,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^4<","^2O"]]]]],"^2A","Returns a vector of [(take-while pred coll) (drop-while pred coll)]"],"~$->VectorNode",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",[]],"^23","cljs/core.cljs","^24",20,"^25",10,"^26","^27","^28",5295,"^29",5295,"^2:",["^2;",["^2<",["^2;",[["^=J","^66"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/VectorNode."],"^1O",["^19",[]],"^1:","~$cljs.core/->VectorNode","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^=J","^66"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",5295,"^29",5295,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^=J","^66"]]]]],"^2@",null,"^2A","Positional factory function for cljs.core/VectorNode."],"~$aset",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",503,"^25",7,"^29",503,"^24",11,"^2:",["^2;",["^2<",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]]]],"^2A","Sets the value at the index/indices. Works on JavaScript arrays.\n Returns val.","^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/aset","^2C",true,"^23","cljs/core.cljs","^24",11,"^2K",["^ ","^2C",true,"^2G",3,"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^79","^7:","^2Z"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",503,"^29",503,"^2G",3,"^2H",true,"^2:",["^2;",[["^79","^7:","^2Z"],["^79","^7:","^@=","~$&","^@>"]]],"^2A","Sets the value at the index/indices. Works on JavaScript arrays.\n Returns val."],"~$int-rotate-left",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",890,"^25",15,"^29",890,"^24",30,"^31","^<","^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]]],"^1:","~$cljs.core/int-rotate-left","^2C",false,"^23","cljs/core.cljs","^24",30,"^2D",["^2;",[["~$x","~$n"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",890,"^3=","^<","^29",890,"^2G",2,"^31","^<","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x","~$n"]]]]]],"~$keyword",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3360,"^25",7,"^29",3360,"^24",14,"^2:",["^2;",["^2<",["^2;",[["^:"],["^47","^:"]]]]],"^2A","Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically.","^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^:"],["^47","^:"]]],"^2:",["^2;",[["^:"],["^47","^:"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/keyword","^2C",false,"^23","cljs/core.cljs","^24",14,"^2K",["^ ","^2C",false,"^2G",2,"^2D",["^2;",[["^:"],["^47","^:"]]],"^2:",["^2;",[["^:"],["^47","^:"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^:"],["^47","^:"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3360,"^29",3360,"^2G",2,"^2H",true,"^2:",["^2;",[["^:"],["^47","^:"]]],"^2A","Returns a Keyword with the given namespace and name. Do not use :\n in the keyword strings, it will be added automatically."],"~$->Cons",["^ ","^1M",null,"^1N",["^ ","^1O",["^19",["^A>","^1P","^1Q","^5D","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]],"^23","cljs/core.cljs","^24",14,"^25",10,"^26","^27","^28",3194,"^29",3194,"^2:",["^2;",["^2<",["^2;",[["^2=","^6J","^;P","^2?"]]]]],"^2@",["^19",["^A>","^1P","^1Q","^5D","^1S","^1W","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Cons."],"^1O",["^19",["^A>","^1P","^1Q","^5D","^1S","^1U","^1W","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]],"^1:","~$cljs.core/->Cons","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2=","^6J","^;P","^2?"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^26","^27","^28",3194,"^29",3194,"^2G",4,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2=","^6J","^;P","^2?"]]]]],"^2@",["^19",["^A>","^1P","^1Q","^5D","^1S","^1W","^4?","^4J","^1Y","^1Z","^1[","^4K","^21","^5E"]],"^2A","Positional factory function for cljs.core/Cons."],"~$*ns*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",54,"^25",3,"^29",54,"^24",7,"^6F",true,"^2A","Var bound to the current namespace. Only used for bootstrapping.","^2T",["@type {*}"]],"^1:","~$cljs.core/*ns*","^23","cljs/core.cljs","^24",7,"^25",1,"^6F",true,"^28",50,"^29",54,"^31","^57","^2A","Var bound to the current namespace. Only used for bootstrapping.","^2T",["@type {*}"]],"~$*assert*",["^ ","^1:","~$cljs.core/*assert*","^23","cljs/core.cljs","^28",61,"^25",1,"^29",63,"^24",11,"^6F",true,"^1N",["^ ","^23","cljs/core.cljs","^28",63,"^25",3,"^29",63,"^24",11,"^6F",true],"^31","^3:"],"~$create-tree-map-seq",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8135,"^25",8,"^29",8135,"^24",27,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^5R","^6V","^67"]]]]]],"^59",true,"^1:","~$cljs.core/create-tree-map-seq","^2C",false,"^23","cljs/core.cljs","^24",27,"^2D",["^2;",[["^5R","^6V","^67"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",8135,"^29",8135,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^5R","^6V","^67"]]]]]],"~$ICollection",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",581,"^25",14,"^29",581,"^24",25,"^2A","Protocol for adding to a collection.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","^9X",[["^2O","~$o"]]]]],"^2S",true,"^1:","^1S","^23","cljs/core.cljs","^24",25,"^25",1,"^28",581,"^2U",["^ ","^2V",["^ ","^9X",[["^2O","~$o"]]]],"^30",null,"^29",581,"^31","^32","^33",["^19",["^4V","^4W","^>R","^4X","^9[","^>T","^5F","^4Y","^4Z","^>V","^8?","^4[","^>W","^>Y","^>Z","^>[","^;V","^50","^?0","^?1","^?3","^?4","^7E","^51","^?5","^?6","^7F","^?8","^>K","^9>","^52"]],"^2A","Protocol for adding to a collection.","^2T",["^2;",["@interface"]]],"~$chars",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2799,"^25",7,"^29",2799,"^24",12,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^1:","~$cljs.core/chars","^2C",false,"^23","cljs/core.cljs","^24",12,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2799,"^29",2799,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]]],"^HS",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2937,"^25",7,"^29",2937,"^24",10,"^2:",["^2;",["^2<",["^2;",[[],["~$x"],["~$x","~$&","^5;"]]]]],"^2A","With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args.","^2K",["^ ","^2C",true,"^2G",1,"^2D",["^2;",[[],["~$x"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$&","^5;"]]],"^2F",["^2;",[null,null,null]]]],"^1:","~$cljs.core/str","^2C",true,"^23","cljs/core.cljs","^24",10,"^2K",["^ ","^2C",true,"^2G",1,"^2D",["^2;",[[],["~$x"]]],"^2:",["^2;",[[],["~$x"],["~$x","~$&","^5;"]]],"^2F",["^2;",[null,null,null]]],"^2D",["^2;",[[],["~$x"]]],"^2E",null,"^2F",["^2;",[null,null,null]],"^25",1,"^28",2937,"^29",2937,"^2G",1,"^2H",true,"^2:",["^2;",[[],["~$x"],["~$x","~$&","^5;"]]],"^2A","With no args, returns the empty string. With one arg x, returns\n x.toString(). (str nil) returns the empty string. With more than\n one arg, returns the concatenation of the str values of the args."],"^Z1",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",1249,"^25",12,"^29",1249,"^24",16,"^31","^3P","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil"],"^1:","~$cljs.core/next","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",1249,"^3=","^3P","^29",1249,"^2G",1,"^31","^3P","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a seq of the items after the first. Calls seq on its\n argument. If there are no more items, returns nil"],"~$ASeq",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",598,"^25",14,"^29",598,"^24",18,"^2A","Marker protocol indicating an array sequence.","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ "]]],"^2S",true,"^1:","^5D","^23","cljs/core.cljs","^24",18,"^25",1,"^28",598,"^2U",["^ ","^2V",["^ "]],"^30",null,"^29",598,"^31","^32","^33",["^19",["^>R","^5F","^?0","^?6","^?8"]],"^2A","Marker protocol indicating an array sequence.","^2T",["^2;",["@interface"]]],"~$pr-seq-writer",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10011,"^25",7,"^29",10011,"^24",20,"^2:",["^2;",["^2<",["^2;",[["^6Y","^7K","^2J"]]]]]],"^1:","~$cljs.core/pr-seq-writer","^2C",false,"^23","cljs/core.cljs","^24",20,"^2D",["^2;",[["^6Y","^7K","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10011,"^29",10011,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^6Y","^7K","^2J"]]]]]],"~$SeqIter",["^ ","^3S",2,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/SeqIter","^23","cljs/core.cljs","^24",17,"^3W",true,"^25",10,"^28",3994,"^3X",false,"^29",3994,"^31","^3Y","^2@",null],"~$IFn",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",537,"^25",14,"^29",537,"^24",17,"^2A","Protocol for adding the ability to invoke an object as a function.\n For example, a vector can also be used to look up a value:\n ([1 2 3 4] 1) => 2","^2S",true,"^2T",["^2;",["@interface"]],"^2U",["^ ","^2V",["^ ","~$-invoke",[["^CV"],["^CV","~$a"],["^CV","~$a","~$b"],["^CV","~$a","~$b","~$c"],["^CV","~$a","~$b","~$c","~$d"],["^CV","~$a","~$b","~$c","~$d","~$e"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^;P"]]]]],"^2S",true,"^1:","^1R","^23","cljs/core.cljs","^24",17,"^25",1,"^28",537,"^2U",["^ ","^2V",["^ ","^[E",[["^CV"],["^CV","~$a"],["^CV","~$a","~$b"],["^CV","~$a","~$b","~$c"],["^CV","~$a","~$b","~$c","~$d"],["^CV","~$a","~$b","~$c","~$d","~$e"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^CV","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^;P"]]]],"^30",null,"^29",537,"^31","^32","^33",["^19",["^4V","^FG","^4W","^34","^4X","^>U","^4Y","^4Z","^4[","^4F","^35","^50","^36","^7D","^7E","^51","^7F","^ 2","^2T",["^2;",["@interface"]]],"~$regexp?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",9800,"^25",16,"^29",9800,"^24",23,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a JavaScript RegExp instance."],"^1:","~$cljs.core/regexp?","^2C",false,"^23","cljs/core.cljs","^24",23,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",9800,"^3=","^3:","^29",9800,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is a JavaScript RegExp instance."],"^2>",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",8788,"^25",7,"^29",8788,"^24",15,"^2:",["^2;",["^2<",["^2;",[["~$&","^9T"]]]]],"^2A","keyval => key val\n Returns a new hash map with supplied mappings.","^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^9T"]]],"^2:",["^2;",[["~$&","^9T"]]],"^2F",["^2;",[null]]]],"^1:","~$cljs.core/hash-map","^2C",true,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",true,"^2G",0,"^2D",[["^2;",["^9T"]]],"^2:",["^2;",[["~$&","^9T"]]],"^2F",["^2;",[null]]],"^2D",[["^2;",["^9T"]]],"^2E",null,"^2F",["^2;",[null]],"^25",1,"^28",8788,"^29",8788,"^2G",0,"^2H",true,"^2:",["^2;",[["~$&","^9T"]]],"^2A","keyval => key val\n Returns a new hash map with supplied mappings."],"~$*exec-tap-fn*",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",73,"^25",3,"^29",73,"^24",16,"^2A","Arranges to have tap functions executed via the supplied f, a\n function of no arguments. Returns true if successful, false otherwise.","^6F",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]]],"^1:","~$cljs.core/*exec-tap-fn*","^2C",false,"^23","cljs/core.cljs","^24",16,"^2D",["^2;",[["~$f"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^6F",true,"^28",71,"^29",73,"^2G",1,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$f"]]]]],"^2A","Arranges to have tap functions executed via the supplied f, a\n function of no arguments. Returns true if successful, false otherwise."],"~$underive",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10753,"^25",7,"^29",10753,"^24",15,"^2:",["^2;",["^2<",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]]]],"^2A","Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy.","^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]],"^2:",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]],"^2F",["^2;",[null,null]]]],"^1:","~$cljs.core/underive","^2C",false,"^23","cljs/core.cljs","^24",15,"^2K",["^ ","^2C",false,"^2G",3,"^2D",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]],"^2:",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]],"^2F",["^2;",[null,null]]],"^2D",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10753,"^29",10753,"^2G",3,"^2H",true,"^2:",["^2;",[["^GM","^:6"],["~$h","^GM","^:6"]]],"^2A","Removes a parent/child relationship between parent and\n tag. h must be a hierarchy obtained from make-hierarchy, if not\n supplied defaults to, and modifies, the global hierarchy."],"~$array-copy",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2175,"^25",8,"^29",2175,"^24",18,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^EI","~$i","^EJ","~$j","^5<"]]]]]],"^59",true,"^1:","~$cljs.core/array-copy","^2C",false,"^23","cljs/core.cljs","^24",18,"^2D",["^2;",[["^EI","~$i","^EJ","~$j","^5<"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2175,"^29",2175,"^2G",5,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^EI","~$i","^EJ","~$j","^5<"]]]]]],"~$obj-map-compare-keys",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",6289,"^25",8,"^29",6289,"^24",28,"^59",true,"^2:",["^2;",["^2<",["^2;",[["~$a","~$b"]]]]]],"^59",true,"^1:","~$cljs.core/obj-map-compare-keys","^2C",false,"^23","cljs/core.cljs","^24",28,"^2D",["^2;",[["~$a","~$b"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",6289,"^29",6289,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$a","~$b"]]]]]],"^KR",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",851,"^25",4,"^29",851,"^24",11,"^5Y","^KS","^2A","Sets the value of o to new-value.","^2:",["^2;",["^2<",["^2;",[["~$o","^CP"]]]]]],"^5Y","^KS","^1:","~$cljs.core/-reset!","^2C",false,"^23","cljs/core.cljs","^24",11,"^2D",["^2;",[["~$o","^CP"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",849,"^29",851,"^2G",2,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$o","^CP"]]]]],"^2A","Sets the value of o to new-value."],"^T;",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",605,"^25",9,"^29",605,"^24",14,"^31","^5X","^5Y","^4?","^2A","Returns a new collection of coll without the first item. It should\n always return a seq, e.g.\n (rest []) => ()\n (rest nil) => ()","^2:",["^2;",["^2<",["^2;",[["^2O"]]]]]],"^5Y","^4?","^1:","~$cljs.core/-rest","^2C",false,"^23","cljs/core.cljs","^24",14,"^2D",["^2;",[["^2O"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",601,"^3=","^5X","^29",605,"^2G",1,"^31","^5X","^2H",true,"^2:",["^2;",["^2<",["^2;",[["^2O"]]]]],"^2A","Returns a new collection of coll without the first item. It should\n always return a seq, e.g.\n (rest []) => ()\n (rest nil) => ()"],"~$nil-iter",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",3960,"^25",7,"^29",3960,"^24",15,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"^1:","~$cljs.core/nil-iter","^2C",false,"^23","cljs/core.cljs","^24",15,"^2D",["^2;",[[]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",3960,"^29",3960,"^2G",0,"^2H",true,"^2:",["^2;",["^2<",["^2;",[[]]]]]],"~$pr-writer",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",10002,"^25",8,"^29",10002,"^24",17,"^59",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^7K","^2J"]]]]],"^2A","Prefer this to pr-seq, because it makes the printing function\n configurable, allowing efficient implementations such as appending\n to a StringBuffer."],"^59",true,"^1:","~$cljs.core/pr-writer","^2C",false,"^23","cljs/core.cljs","^24",17,"^2D",["^2;",[["^3;","^7K","^2J"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",10002,"^29",10002,"^2G",3,"^2H",true,"^2:",["^2;",["^2<",["^2;",[["^3;","^7K","^2J"]]]]],"^2A","Prefer this to pr-seq, because it makes the printing function\n configurable, allowing efficient implementations such as appending\n to a StringBuffer."],"~$false?",["^ ","^1M",null,"^1N",["^ ","^23","cljs/core.cljs","^28",2195,"^25",16,"^29",2195,"^24",22,"^31","^3:","^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is the value false, false otherwise."],"^1:","~$cljs.core/false?","^2C",false,"^23","cljs/core.cljs","^24",22,"^2D",["^2;",[["~$x"]]],"^2E",null,"^2F",["^2;",[null,null]],"^25",1,"^28",2195,"^3=","^3:","^29",2195,"^2G",1,"^31","^3:","^2H",true,"^2:",["^2;",["^2<",["^2;",[["~$x"]]]]],"^2A","Returns true if x is the value false, false otherwise."],"~$RangedIterator",["^ ","^3S",6,"^1O",["^19",["^1U"]],"^1:","~$cljs.core/RangedIterator","^23","cljs/core.cljs","^24",24,"^3W",true,"^25",10,"^28",5392,"^3X",false,"^29",5392,"^31","^3Y","^2@",null],"~$*print-readably*",["^ ","^1N",["^ ","^23","cljs/core.cljs","^28",114,"^25",3,"^29",114,"^24",19,"^6F",true,"^2A","When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true"],"^1:","~$cljs.core/*print-readably*","~:file","cljs/core.cljs","~:end-column",19,"~:column",1,"~:dynamic",true,"~:line",108,"~:end-line",114,"~:tag","~$boolean","~:doc","When set to logical false, strings and characters will be printed with\n non-alphanumeric characters converted to the appropriate escape sequences.\n\n Defaults to true"],"~$ints",["^ ","~:protocol-inline",null,"~:meta",["^ ","^1","cljs/core.cljs","^5",2801,"^3",7,"^6",2801,"^2",11,"~:arglists",["~#list",["~$quote",["^>",[["~$x"]]]]]],"~:name","~$cljs.core/ints","~:variadic",false,"^1","cljs/core.cljs","^2",11,"~:method-params",["^>",[["~$x"]]],"~:protocol-impl",null,"~:arglists-meta",["^>",[null,null]],"^3",1,"^5",2801,"^6",2801,"~:max-fixed-arity",1,"~:fn-var",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$some-fn",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4615,"^3",7,"^6",4615,"^2",14,"^=",["^>",["^?",["^>",[["~$p"],["~$p1","~$p2"],["^I","^J","~$p3"],["^I","^J","^K","~$&","~$ps"]]]]],"^9","Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates.","~:top-fn",["^ ","^B",true,"^F",3,"^C",["^>",[["~$p"],["^I","^J"],["^I","^J","^K"]]],"^=",["^>",[["~$p"],["^I","^J"],["^I","^J","^K"],["^I","^J","^K","~$&","^L"]]],"^E",["^>",[null,null,null,null]]]],"^@","~$cljs.core/some-fn","^B",true,"^1","cljs/core.cljs","^2",14,"^M",["^ ","^B",true,"^F",3,"^C",["^>",[["~$p"],["^I","^J"],["^I","^J","^K"]]],"^=",["^>",[["~$p"],["^I","^J"],["^I","^J","^K"],["^I","^J","^K","~$&","^L"]]],"^E",["^>",[null,null,null,null]]],"^C",["^>",[["~$p"],["^I","^J"],["^I","^J","^K"]]],"^D",null,"^E",["^>",[null,null,null,null]],"^3",1,"^5",4615,"^6",4615,"^F",3,"^G",true,"^=",["^>",[["~$p"],["^I","^J"],["^I","^J","^K"],["^I","^J","^K","~$&","^L"]]],"^9","Takes a set of predicates and returns a function f that returns the first logical true value\n returned by one of its composing predicates against any of its arguments, else it returns\n logical false. Note that f is short-circuiting in that it will stop execution on the first\n argument that triggers a logical true result against the original predicates."],"~$demunge-pattern",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",11280,"^3",8,"^6",11280,"^2",23,"~:private",true,"^=",["^>",["^?",["^>",[[]]]]]],"^P",true,"^@","~$cljs.core/demunge-pattern","^B",false,"^1","cljs/core.cljs","^2",23,"^C",["^>",[[]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",11280,"^6",11280,"^F",0,"^G",true,"^=",["^>",["^?",["^>",[[]]]]]],"~$maybe-enable-print!",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",11505,"^3",8,"^6",11505,"^2",27,"^P",true,"^=",["^>",["^?",["^>",[[]]]]]],"^P",true,"^@","~$cljs.core/maybe-enable-print!","^B",false,"^1","cljs/core.cljs","^2",27,"^C",["^>",[[]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",11505,"^6",11505,"^F",0,"^G",true,"^=",["^>",["^?",["^>",[[]]]]]],"~$*flush-on-newline*",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",99,"^3",3,"^6",99,"^2",21,"^4",true,"^9","When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true."],"^@","~$cljs.core/*flush-on-newline*","^1","cljs/core.cljs","^2",21,"^3",1,"^4",true,"^5",94,"^6",99,"^7","^8","^9","When set to true, output will be flushed whenever a newline is printed.\n\n Defaults to true."],"~$to-array",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3609,"^3",7,"^6",3609,"^2",15,"^=",["^>",["^?",["^>",[["~$s"]]]]],"^9","Naive impl of to-array as a start."],"^@","~$cljs.core/to-array","^B",false,"^1","cljs/core.cljs","^2",15,"^C",["^>",[["~$s"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3609,"^6",3609,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$s"]]]]],"^9","Naive impl of to-array as a start."],"~$build-subvec",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",5892,"^3",8,"^6",5892,"^2",20,"^P",true,"^=",["^>",["^?",["^>",[["~$meta","~$v","~$start","~$end","~$__hash"]]]]]],"^P",true,"^@","~$cljs.core/build-subvec","^B",false,"^1","cljs/core.cljs","^2",20,"^C",["^>",[["^Y","~$v","^Z","^[","^10"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",5892,"^6",5892,"^F",5,"^G",true,"^=",["^>",["^?",["^>",[["^Y","~$v","^Z","^[","^10"]]]]]],"~$maybe-warn",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",447,"^3",8,"^6",447,"^2",18,"^P",true,"^=",["^>",["^?",["^>",[["~$e"]]]]]],"^P",true,"^@","~$cljs.core/maybe-warn","^B",false,"^1","cljs/core.cljs","^2",18,"^C",["^>",[["~$e"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",447,"^6",447,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$e"]]]]]],"~$Namespace",["^ ","~:num-fields",2,"~:protocols",["~#set",["~$cljs.core/IEquiv","~$cljs.core/IHash","~$cljs.core/Object"]],"^@","~$cljs.core/Namespace","^1","cljs/core.cljs","^2",19,"~:type",true,"^3",10,"^5",11384,"~:record",false,"^6",11384,"^7","~$function","~:skip-protocol-flag",["^17",["^18","^19"]]],"~$list?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3084,"^3",16,"^6",3084,"^2",21,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x implements IList"],"^@","~$cljs.core/list?","^B",false,"^1","cljs/core.cljs","^2",21,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3084,"~:ret-tag","^8","^6",3084,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x implements IList"],"~$tree-map-remove",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",8603,"^3",8,"^6",8603,"^2",23,"^P",true,"^=",["^>",["^?",["^>",[["~$comp","~$tree","~$k","~$found"]]]]]],"^P",true,"^@","~$cljs.core/tree-map-remove","^B",false,"^1","cljs/core.cljs","^2",23,"^C",["^>",[["^1D","^1E","~$k","^1F"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",8603,"^6",8603,"^F",4,"^G",true,"^=",["^>",["^?",["^>",[["^1D","^1E","~$k","^1F"]]]]]],"~$PersistentQueueIter",["^ ","^15",2,"^16",["^17",["^1:"]],"^@","~$cljs.core/PersistentQueueIter","^1","cljs/core.cljs","^2",29,"^1<",true,"^3",10,"^5",6106,"^1=",false,"^6",6106,"^7","^1>","^1?",null],"~$HashCollisionNode",["^ ","^15",4,"^16",["^17",["^1:","~$cljs.core/IIterable"]],"^@","~$cljs.core/HashCollisionNode","^1","cljs/core.cljs","^2",27,"^1<",true,"^3",10,"^5",7490,"^1=",false,"^6",7490,"^7","^1>","^1?",["^17",["^1K"]]],"~$array?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",234,"^3",16,"^6",234,"^2",22,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x is a JavaScript array."],"^@","~$cljs.core/array?","^B",false,"^1","cljs/core.cljs","^2",22,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",234,"^1B","^8","^6",234,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x is a JavaScript array."],"~$prefers*",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10779,"^3",8,"^6",10779,"^2",16,"^P",true,"^=",["^>",["^?",["^>",[["~$x","~$y","~$prefer-table"]]]]]],"^P",true,"^@","~$cljs.core/prefers*","^B",false,"^1","cljs/core.cljs","^2",16,"^C",["^>",[["~$x","~$y","^1P"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10779,"^6",10779,"^F",3,"^G",true,"^=",["^>",["^?",["^>",[["~$x","~$y","^1P"]]]]]],"~$simple-ident?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3336,"^3",16,"^6",3336,"^2",29,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Return true if x is a symbol or keyword without a namespace"],"^@","~$cljs.core/simple-ident?","^B",false,"^1","cljs/core.cljs","^2",29,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3336,"^1B","^8","^6",3336,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Return true if x is a symbol or keyword without a namespace"],"~$clone",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1192,"^3",7,"^6",1192,"^2",12,"^=",["^>",["^?",["^>",[["~$value"]]]]],"^9","Clone the supplied value which must implement ICloneable."],"^@","~$cljs.core/clone","^B",false,"^1","cljs/core.cljs","^2",12,"^C",["^>",[["^1U"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1192,"^6",1192,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^1U"]]]]],"^9","Clone the supplied value which must implement ICloneable."],"~$scan-array",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",6275,"^3",8,"^6",6275,"^2",18,"^P",true,"^=",["^>",["^?",["^>",[["~$incr","~$k","~$array"]]]]]],"^P",true,"^@","~$cljs.core/scan-array","^B",false,"^1","cljs/core.cljs","^2",18,"^C",["^>",[["^1X","~$k","^1Y"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",6275,"^6",6275,"^F",3,"^G",true,"^=",["^>",["^?",["^>",[["^1X","~$k","^1Y"]]]]]],"~$demunge",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",11335,"^3",7,"^6",11335,"^2",14,"^=",["^>",["^?",["^>",[["~$name"]]]]]],"^@","~$cljs.core/demunge","^B",false,"^1","cljs/core.cljs","^2",14,"^C",["^>",[["^20"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",11335,"^6",11335,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^20"]]]]]],"~$bit-not",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2862,"^3",7,"^6",2862,"^2",14,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Bitwise complement"],"^@","~$cljs.core/bit-not","^B",false,"^1","cljs/core.cljs","^2",14,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2862,"^6",2862,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Bitwise complement"],"~$quote-string",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",9898,"^3",17,"^6",9898,"^2",29,"^P",true,"^=",["^>",["^?",["^>",[["~$s"]]]]]],"^P",true,"^@","~$cljs.core/quote-string","^B",false,"^1","cljs/core.cljs","^2",29,"^C",["^>",[["~$s"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",9898,"^6",9898,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$s"]]]]]],"~$byte",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2676,"^3",15,"^6",2676,"^2",19,"^7","~$number","^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/byte","^B",false,"^1","cljs/core.cljs","^2",19,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2676,"^1B","^27","^6",2676,"^F",1,"^7","^27","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$max",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2662,"^3",15,"^6",2662,"^2",18,"^7","^27","^=",["^>",["^?",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","~$more"]]]]],"^9","Returns the greatest of the nums.","^M",["^ ","^B",true,"^F",2,"^C",["^>",[["~$x"],["~$x","~$y"]]],"^=",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]],"^E",["^>",[null,null,null]]]],"^@","~$cljs.core/max","^B",true,"^1","cljs/core.cljs","^2",18,"^M",["^ ","^B",true,"^F",2,"^C",["^>",[["~$x"],["~$x","~$y"]]],"^=",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]],"^E",["^>",[null,null,null]]],"^C",["^>",[["~$x"],["~$x","~$y"]]],"^D",null,"^E",["^>",[null,null,null]],"^3",1,"^5",2662,"^1B","^27","^6",2662,"^F",2,"^7","^27","^G",true,"^=",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]],"^9","Returns the greatest of the nums."],"~$->Repeat",["^ ","^;",null,"^<",["^ ","^16",["^17",["^18","^19","~$cljs.core/ICollection","^1:","~$cljs.core/IPending","~$cljs.core/IEmptyableCollection","~$cljs.core/ISeq","~$cljs.core/INext","~$cljs.core/ISeqable","~$cljs.core/IMeta","~$cljs.core/ISequential","~$cljs.core/IWithMeta","~$cljs.core/IReduce"]],"^1","cljs/core.cljs","^2",16,"^3",10,"~:factory","~:positional","^5",4861,"^6",4861,"^=",["^>",["^?",["^>",[["^Y","~$count","~$val","~$next","^10"]]]]],"^1?",["^17",["^18","^19","^2=","^2>","^2?","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^9","Positional factory function for cljs.core/Repeat."],"^16",["^17",["^18","^19","^2=","^1:","^2>","^2?","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^@","~$cljs.core/->Repeat","^B",false,"^1","cljs/core.cljs","^2",16,"^C",["^>",[["^Y","^2I","^2J","^2K","^10"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",4861,"^6",4861,"^F",5,"^G",true,"^=",["^>",["^?",["^>",[["^Y","^2I","^2J","^2K","^10"]]]]],"^1?",["^17",["^18","^19","^2=","^2>","^2?","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^9","Positional factory function for cljs.core/Repeat."],"~$IComparable",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",816,"^3",14,"^6",816,"^2",25,"^9","Protocol for values that can be compared.","~:protocol-symbol",true,"~:jsdoc",["^>",["@interface"]],"~:protocol-info",["^ ","~:methods",["^ ","~$-compare",[["~$x","~$y"]]]]],"^2N",true,"^@","~$cljs.core/IComparable","^1","cljs/core.cljs","^2",25,"^3",1,"^5",816,"^2P",["^ ","^2Q",["^ ","^2R",[["~$x","~$y"]]]],"~:info",null,"^6",816,"^7","~$any","~:impls",["^17",["~$js/Date","~$cljs.core/Keyword","~$cljs.core/BlackNode","~$cljs.core/MapEntry","~$cljs.core/Subvec","~$cljs.core/PersistentVector","~$cljs.core/Symbol","~$cljs.core/UUID","~$cljs.core/RedNode"]],"^9","Protocol for values that can be compared.","^2O",["^>",["@interface"]]],"~$==",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2899,"^3",16,"^6",2899,"^2",18,"^7","^8","^=",["^>",["^?",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]]]],"^9","Returns non-nil if nums all have the equivalent\n value, otherwise false. Behavior on non nums is\n undefined.","^M",["^ ","^B",true,"^F",2,"^C",["^>",[["~$x"],["~$x","~$y"]]],"^=",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]],"^E",["^>",[null,null,null]]]],"^@","~$cljs.core/==","^B",true,"^1","cljs/core.cljs","^2",18,"^M",["^ ","^B",true,"^F",2,"^C",["^>",[["~$x"],["~$x","~$y"]]],"^=",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]],"^E",["^>",[null,null,null]]],"^C",["^>",[["~$x"],["~$x","~$y"]]],"^D",null,"^E",["^>",[null,null,null]],"^3",1,"^5",2899,"^1B","^8","^6",2899,"^F",2,"^7","^8","^G",true,"^=",["^>",[["~$x"],["~$x","~$y"],["~$x","~$y","~$&","^2:"]]],"^9","Returns non-nil if nums all have the equivalent\n value, otherwise false. Behavior on non nums is\n undefined."],"~$parents",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10694,"^3",7,"^6",10694,"^2",14,"^=",["^>",["^?",["^>",[["~$tag"],["~$h","^37"]]]]],"^9","Returns the immediate parents of tag, either via a JavaScript type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy","^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^37"],["~$h","^37"]]],"^=",["^>",[["^37"],["~$h","^37"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/parents","^B",false,"^1","cljs/core.cljs","^2",14,"^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^37"],["~$h","^37"]]],"^=",["^>",[["^37"],["~$h","^37"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^37"],["~$h","^37"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10694,"^6",10694,"^F",2,"^G",true,"^=",["^>",[["^37"],["~$h","^37"]]],"^9","Returns the immediate parents of tag, either via a JavaScript type\n inheritance relationship or a relationship established via derive. h\n must be a hierarchy obtained from make-hierarchy, if not supplied\n defaults to the global hierarchy"],"^2I",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1800,"^3",7,"^6",1800,"^2",12,"^=",["^>",["^?",["^>",[["~$coll"]]]]],"^9","Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Maps"],"^@","~$cljs.core/count","^B",false,"^1","cljs/core.cljs","^2",12,"^C",["^>",[["^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1800,"^6",1800,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Returns the number of items in the collection. (count nil) returns\n 0. Also works on strings, arrays, and Maps"],"~$-disjoin!",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",813,"^3",9,"^6",813,"^2",18,"^7","~$clj","~:protocol","~$cljs.core/ITransientSet","^9","Returns tcoll without v.","^=",["^>",["^?",["^>",[["~$tcoll","~$v"]]]]]],"^3=","^3>","^@","~$cljs.core/-disjoin!","^B",false,"^1","cljs/core.cljs","^2",18,"^C",["^>",[["^3?","~$v"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",811,"^1B","^3<","^6",813,"^F",2,"^7","^3<","^G",true,"^=",["^>",["^?",["^>",[["^3?","~$v"]]]]],"^9","Returns tcoll without v."],"~$*loaded-libs*",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",174,"^3",3,"^6",174,"^2",16,"^4",true,"^2O",["@type {*}"]],"^@","~$cljs.core/*loaded-libs*","^1","cljs/core.cljs","^2",16,"^3",1,"^4",true,"^5",171,"^6",174,"^7","~$clj-nil","^2O",["@type {*}"]],"~$EMPTY",["^ ","^@","~$cljs.core/EMPTY","^1","cljs/core.cljs","^5",4068,"^3",1,"^6",4068,"^2",21,"^P",true,"^<",["^ ","^1","cljs/core.cljs","^5",4068,"^3",16,"^6",4068,"^2",21,"^P",true],"^7","~$cljs.core/Empty"],"~$->TransientHashMap",["^ ","^;",null,"^<",["^ ","^16",["^17",["~$cljs.core/IFn","~$cljs.core/ITransientMap","^1:","~$cljs.core/ICounted","~$cljs.core/ITransientCollection","~$cljs.core/ITransientAssociative","~$cljs.core/ILookup"]],"^1","cljs/core.cljs","^2",26,"^3",10,"^2G","^2H","^5",7942,"^6",7942,"^=",["^>",["^?",["^>",[["~$edit","~$root","^2I","~$has-nil?","~$nil-val"]]]]],"^1?",["^17",["^3H","^3I","^3J","^3K","^3L","^3M"]],"^9","Positional factory function for cljs.core/TransientHashMap."],"^16",["^17",["^3H","^3I","^1:","^3J","^3K","^3L","^3M"]],"^@","~$cljs.core/->TransientHashMap","^B",false,"^1","cljs/core.cljs","^2",26,"^C",["^>",[["^3N","^3O","^2I","^3P","^3Q"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",7942,"^6",7942,"^F",5,"^G",true,"^=",["^>",["^?",["^>",[["^3N","^3O","^2I","^3P","^3Q"]]]]],"^1?",["^17",["^3H","^3I","^3J","^3K","^3L","^3M"]],"^9","Positional factory function for cljs.core/TransientHashMap."],"~$array-index-of-symbol?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",6496,"^3",8,"^6",6496,"^2",30,"^P",true,"^=",["^>",["^?",["^>",[["~$arr","~$k"]]]]]],"^P",true,"^@","~$cljs.core/array-index-of-symbol?","^B",false,"^1","cljs/core.cljs","^2",30,"^C",["^>",[["^3T","~$k"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",6496,"^6",6496,"^F",2,"^G",true,"^=",["^>",["^?",["^>",[["^3T","~$k"]]]]]],"~$ArrayChunk",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",3462,"^3",10,"^6",3462,"^2",20,"~:declared",true],"^15",3,"^16",["^17",["~$cljs.core/IIndexed","^3J","~$cljs.core/IChunk","^2F"]],"^@","~$cljs.core/ArrayChunk","^1","cljs/core.cljs","^2",20,"^1<",true,"^3",10,"^5",3481,"^1=",false,"^3W",true,"^6",3481,"^7","^1>","^1?",["^17",["^3X","^3J","^2F"]]],"~$sorted-map-by",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",8828,"^3",7,"^6",8828,"^2",20,"^=",["^>",["^?",["^>",[["~$comparator","~$&","~$keyvals"]]]]],"^9","keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied comparator.","^M",["^ ","^B",true,"^F",1,"^C",[["^>",["^40","^41"]]],"^=",["^>",[["^40","~$&","^41"]]],"^E",["^>",[null]]]],"^@","~$cljs.core/sorted-map-by","^B",true,"^1","cljs/core.cljs","^2",20,"^M",["^ ","^B",true,"^F",1,"^C",[["^>",["^40","^41"]]],"^=",["^>",[["^40","~$&","^41"]]],"^E",["^>",[null]]],"^C",[["^>",["^40","^41"]]],"^D",null,"^E",["^>",[null]],"^3",1,"^5",8828,"^6",8828,"^F",1,"^G",true,"^=",["^>",[["^40","~$&","^41"]]],"^9","keyval => key val\n Returns a new sorted map with supplied mappings, using the supplied comparator."],"~$apply",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3883,"^3",7,"^6",3883,"^2",12,"^=",["^>",["^?",["^>",[["~$f","~$args"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"],["~$f","~$a","~$b","~$c","~$d","~$&","^44"]]]]],"^9","Applies fn f to the argument list formed by prepending intervening arguments to args.","^M",["^ ","^B",true,"^F",5,"^C",["^>",[["~$f","^44"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"]]],"^=",["^>",[["~$f","^44"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"],["~$f","~$a","~$b","~$c","~$d","~$&","^44"]]],"^E",["^>",[null,null,null,null,null]]]],"^@","~$cljs.core/apply","^B",true,"^1","cljs/core.cljs","^2",12,"^M",["^ ","^B",true,"^F",5,"^C",["^>",[["~$f","^44"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"]]],"^=",["^>",[["~$f","^44"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"],["~$f","~$a","~$b","~$c","~$d","~$&","^44"]]],"^E",["^>",[null,null,null,null,null]]],"^C",["^>",[["~$f","^44"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"]]],"^D",null,"^E",["^>",[null,null,null,null,null]],"^3",1,"^5",3883,"^6",3883,"^F",5,"^G",true,"^=",["^>",[["~$f","^44"],["~$f","~$x","^44"],["~$f","~$x","~$y","^44"],["~$f","~$x","~$y","~$z","^44"],["~$f","~$a","~$b","~$c","~$d","~$&","^44"]]],"^9","Applies fn f to the argument list formed by prepending intervening arguments to args."],"~$get-global-hierarchy",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10666,"^3",8,"^6",10666,"^2",28,"^P",true,"^=",["^>",["^?",["^>",[[]]]]]],"^P",true,"^@","~$cljs.core/get-global-hierarchy","^B",false,"^1","cljs/core.cljs","^2",28,"^C",["^>",[[]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10666,"^6",10666,"^F",0,"^G",true,"^=",["^>",["^?",["^>",[[]]]]]],"~$add-to-string-hash-cache",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",970,"^3",7,"^6",970,"^2",31,"^=",["^>",["^?",["^>",[["~$k"]]]]]],"^@","~$cljs.core/add-to-string-hash-cache","^B",false,"^1","cljs/core.cljs","^2",31,"^C",["^>",[["~$k"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",970,"^6",970,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$k"]]]]]],"~$clj->js",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10533,"^3",7,"^6",10533,"^2",14,"^=",["^>",["^?",["^>",[["~$x","~$&",["^ ","~:keys",["~$keyword-fn"],"~:or",["^ ","^4<","^20"],"~:as","~$options"]]]]]],"^9","Recursively transforms ClojureScript values to JavaScript.\n sets/vectors/lists become Arrays, Keywords and Symbol become Strings,\n Maps become Objects. Arbitrary keys are encoded to by `key->js`.\n Options is a key-value pair, where the only valid key is\n :keyword-fn, which should point to a single-argument function to be\n called on keyword keys. Default to `name`.","^M",["^ ","^B",true,"^F",1,"^C",[["^>",["~$x",["^ ","^4;",["^4<"],"^4=",["^ ","^4<","^20"],"^4>","^4?"]]]],"^=",["^>",[["~$x","~$&",["^ ","^4;",["^4<"],"^4=",["^ ","^4<","^20"],"^4>","^4?"]]]],"^E",["^>",[null]]]],"^@","~$cljs.core/clj->js","^B",true,"^1","cljs/core.cljs","^2",14,"^M",["^ ","^B",true,"^F",1,"^C",[["^>",["~$x",["^ ","^4;",["^4<"],"^4=",["^ ","^4<","^20"],"^4>","^4?"]]]],"^=",["^>",[["~$x","~$&",["^ ","^4;",["^4<"],"^4=",["^ ","^4<","^20"],"^4>","^4?"]]]],"^E",["^>",[null]]],"^C",[["^>",["~$x",["^ ","^4;",["^4<"],"^4=",["^ ","^4<","^20"],"^4>","^4?"]]]],"^D",null,"^E",["^>",[null]],"^3",1,"^5",10533,"^6",10533,"^F",1,"^G",true,"^=",["^>",[["~$x","~$&",["^ ","^4;",["^4<"],"^4=",["^ ","^4<","^20"],"^4>","^4?"]]]],"^9","Recursively transforms ClojureScript values to JavaScript.\n sets/vectors/lists become Arrays, Keywords and Symbol become Strings,\n Maps become Objects. Arbitrary keys are encoded to by `key->js`.\n Options is a key-value pair, where the only valid key is\n :keyword-fn, which should point to a single-argument function to be\n called on keyword keys. Default to `name`."],"~$TransientArrayMap",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",6553,"^3",10,"^6",6553,"^2",27,"^3W",true],"^15",3,"^16",["^17",["^3H","^3I","^3J","^3K","^3L","^3M"]],"^@","~$cljs.core/TransientArrayMap","^1","cljs/core.cljs","^2",27,"^1<",true,"^3",10,"^5",6953,"^1=",false,"^3W",true,"^6",6953,"^7","^1>","^1?",["^17",["^3H","^3I","^3J","^3K","^3L","^3M"]]],"~$->TransientVector",["^ ","^;",null,"^<",["^ ","^16",["^17",["^3X","^3H","^3J","^3K","~$cljs.core/ITransientVector","^3L","^3M"]],"^1","cljs/core.cljs","^2",25,"^3",10,"^2G","^2H","^5",5973,"^6",5973,"^=",["^>",["^?",["^>",[["~$cnt","~$shift","^3O","~$tail"]]]]],"^1?",["^17",["^3X","^3H","^3J","^3K","^4D","^3L","^3M"]],"^9","Positional factory function for cljs.core/TransientVector."],"^16",["^17",["^3X","^3H","^3J","^3K","^4D","^3L","^3M"]],"^@","~$cljs.core/->TransientVector","^B",false,"^1","cljs/core.cljs","^2",25,"^C",["^>",[["^4E","^4F","^3O","^4G"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",5973,"^6",5973,"^F",4,"^G",true,"^=",["^>",["^?",["^>",[["^4E","^4F","^3O","^4G"]]]]],"^1?",["^17",["^3X","^3H","^3J","^3K","^4D","^3L","^3M"]],"^9","Positional factory function for cljs.core/TransientVector."],"~$IChunkedNext",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",834,"^3",14,"^6",834,"^2",26,"^9","Protocol for accessing the chunks of a collection.","^2N",true,"^2O",["^>",["@interface"]],"^2P",["^ ","^2Q",["^ ","~$-chunked-next",[["^39"]]]]],"^2N",true,"^@","~$cljs.core/IChunkedNext","^1","cljs/core.cljs","^2",26,"^3",1,"^5",834,"^2P",["^ ","^2Q",["^ ","^4J",[["^39"]]]],"^2T",null,"^6",834,"^7","^2U","^2V",["^17",["~$cljs.core/ChunkedSeq","~$cljs.core/ChunkedCons"]],"^9","Protocol for accessing the chunks of a collection.","^2O",["^>",["@interface"]]],"~$interpose",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",5053,"^3",7,"^6",5053,"^2",16,"^=",["^>",["^?",["^>",[["~$sep"],["^4O","^39"]]]]],"^9","Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided.","^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^4O"],["^4O","^39"]]],"^=",["^>",[["^4O"],["^4O","^39"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/interpose","^B",false,"^1","cljs/core.cljs","^2",16,"^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^4O"],["^4O","^39"]]],"^=",["^>",[["^4O"],["^4O","^39"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^4O"],["^4O","^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",5053,"^6",5053,"^F",2,"^G",true,"^=",["^>",[["^4O"],["^4O","^39"]]],"^9","Returns a lazy seq of the elements of coll separated by sep.\n Returns a stateful transducer when no collection is provided."],"~$TransformerIterator",["^ ","^15",6,"^16",["^17",["^1:"]],"^@","~$cljs.core/TransformerIterator","^1","cljs/core.cljs","^2",29,"^1<",true,"^3",10,"^5",4097,"^1=",false,"^6",4097,"^7","^1>","^1?",null],"~$->BlackNode",["^ ","^;",null,"^<",["^ ","^16",["^17",["^3X","~$cljs.core/IVector","~$cljs.core/IReversible","^18","^19","^3H","^2=","^1:","~$cljs.core/IFind","^2?","^3J","^2B","^2C","~$cljs.core/IStack","~$cljs.core/IMapEntry","^2D","^2E","~$cljs.core/IAssociative","^3M","^2F"]],"^1","cljs/core.cljs","^2",19,"^3",10,"^2G","^2H","^5",8238,"^6",8238,"^=",["^>",["^?",["^>",[["~$key","^2J","~$left","~$right","^10"]]]]],"^1?",["^17",["^3X","^4T","^4U","^18","^19","^3H","^2=","^2?","^3J","^2B","^2C","^4W","^4X","^2D","^2E","^4Y","^3M","^2F"]],"^9","Positional factory function for cljs.core/BlackNode."],"^16",["^17",["^3X","^4T","^4U","^18","^19","^3H","^2=","^1:","^4V","^2?","^3J","^2B","^2C","^4W","^4X","^2D","^2E","^4Y","^3M","^2F"]],"^@","~$cljs.core/->BlackNode","^B",false,"^1","cljs/core.cljs","^2",19,"^C",["^>",[["^4Z","^2J","^4[","^50","^10"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",8238,"^6",8238,"^F",5,"^G",true,"^=",["^>",["^?",["^>",[["^4Z","^2J","^4[","^50","^10"]]]]],"^1?",["^17",["^3X","^4T","^4U","^18","^19","^3H","^2=","^2?","^3J","^2B","^2C","^4W","^4X","^2D","^2E","^4Y","^3M","^2F"]],"^9","Positional factory function for cljs.core/BlackNode."],"~$deref",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1443,"^3",7,"^6",1443,"^2",12,"^=",["^>",["^?",["^>",[["~$o"]]]]],"^9","Also reader macro: @var/@atom/@delay. Returns the\n most-recently-committed value of ref. When applied to a var\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. See also - realized?."],"^@","~$cljs.core/deref","^B",false,"^1","cljs/core.cljs","^2",12,"^C",["^>",[["~$o"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1443,"^6",1443,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$o"]]]]],"^9","Also reader macro: @var/@atom/@delay. Returns the\n most-recently-committed value of ref. When applied to a var\n or atom, returns its current state. When applied to a delay, forces\n it if not already forced. See also - realized?."],"~$pv-aget",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",5300,"^3",8,"^6",5300,"^2",15,"^P",true,"^=",["^>",["^?",["^>",[["~$node","~$idx"]]]]]],"^P",true,"^@","~$cljs.core/pv-aget","^B",false,"^1","cljs/core.cljs","^2",15,"^C",["^>",[["^55","^56"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",5300,"^6",5300,"^F",2,"^G",true,"^=",["^>",["^?",["^>",[["^55","^56"]]]]]],"~$assoc",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1961,"^3",7,"^6",1961,"^2",12,"^=",["^>",["^?",["^>",[["^39","~$k","~$v"],["^39","~$k","~$v","~$&","~$kvs"]]]]],"^9","assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index.","^M",["^ ","^B",true,"^F",3,"^C",["^>",[["^39","~$k","~$v"]]],"^=",["^>",[["^39","~$k","~$v"],["^39","~$k","~$v","~$&","^59"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/assoc","^B",true,"^1","cljs/core.cljs","^2",12,"^M",["^ ","^B",true,"^F",3,"^C",["^>",[["^39","~$k","~$v"]]],"^=",["^>",[["^39","~$k","~$v"],["^39","~$k","~$v","~$&","^59"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^39","~$k","~$v"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1961,"^6",1961,"^F",3,"^G",true,"^=",["^>",[["^39","~$k","~$v"],["^39","~$k","~$v","~$&","^59"]]],"^9","assoc[iate]. When applied to a map, returns a new map of the\n same (hashed/sorted) type, that contains the mapping of key(s) to\n val(s). When applied to a vector, returns a new vector that\n contains val at index."],"~$transient",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3777,"^3",7,"^6",3777,"^2",16,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Returns a new, transient version of the collection, in constant time."],"^@","~$cljs.core/transient","^B",false,"^1","cljs/core.cljs","^2",16,"^C",["^>",[["^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3777,"^6",3777,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Returns a new, transient version of the collection, in constant time."],"~$-disjoin",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",653,"^3",9,"^6",653,"^2",17,"^7","^3<","^3=","~$cljs.core/ISet","^9","Returns a new collection of coll that does not contain v.","^=",["^>",["^?",["^>",[["^39","~$v"]]]]]],"^3=","^5>","^@","~$cljs.core/-disjoin","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["^39","~$v"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",651,"^1B","^3<","^6",653,"^F",2,"^7","^3<","^G",true,"^=",["^>",["^?",["^>",[["^39","~$v"]]]]],"^9","Returns a new collection of coll that does not contain v."],"~$chunk-cons",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3585,"^3",7,"^6",3585,"^2",17,"^=",["^>",["^?",["^>",[["~$chunk","~$rest"]]]]]],"^@","~$cljs.core/chunk-cons","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["^5A","^5B"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3585,"^6",3585,"^F",2,"^G",true,"^=",["^>",["^?",["^>",[["^5A","^5B"]]]]]],"~$ArrayIter",["^ ","^15",2,"^16",["^17",["^1:"]],"^@","~$cljs.core/ArrayIter","^1","cljs/core.cljs","^2",19,"^1<",true,"^3",10,"^5",3979,"^1=",false,"^6",3979,"^7","^1>","^1?",null],"^40",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",11185,"^3",7,"^6",11185,"^2",17,"^=",["^>",["^?",["^>",[["~$pred"]]]]],"^9","Returns an JavaScript compatible comparator based upon pred."],"^@","~$cljs.core/comparator","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["^5F"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",11185,"^6",11185,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^5F"]]]]],"^9","Returns an JavaScript compatible comparator based upon pred."],"~$print-prefix-map",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10126,"^3",7,"^6",10126,"^2",23,"^=",["^>",["^?",["^>",[["~$prefix","~$m","~$print-one","~$writer","~$opts"]]]]]],"^@","~$cljs.core/print-prefix-map","^B",false,"^1","cljs/core.cljs","^2",23,"^C",["^>",[["^5I","~$m","^5J","^5K","^5L"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10126,"^6",10126,"^F",5,"^G",true,"^=",["^>",["^?",["^>",[["^5I","~$m","^5J","^5K","^5L"]]]]]],"~$sorted-map",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",8819,"^3",7,"^6",8819,"^2",17,"^=",["^>",["^?",["^>",[["~$&","^41"]]]]],"^9","keyval => key val\n Returns a new sorted map with supplied mappings.","^M",["^ ","^B",true,"^F",0,"^C",[["^>",["^41"]]],"^=",["^>",[["~$&","^41"]]],"^E",["^>",[null]]]],"^@","~$cljs.core/sorted-map","^B",true,"^1","cljs/core.cljs","^2",17,"^M",["^ ","^B",true,"^F",0,"^C",[["^>",["^41"]]],"^=",["^>",[["~$&","^41"]]],"^E",["^>",[null]]],"^C",[["^>",["^41"]]],"^D",null,"^E",["^>",[null]],"^3",1,"^5",8819,"^6",8819,"^F",0,"^G",true,"^=",["^>",[["~$&","^41"]]],"^9","keyval => key val\n Returns a new sorted map with supplied mappings."],"~$drop-while",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4767,"^3",7,"^6",4767,"^2",17,"^=",["^>",["^?",["^>",[["^5F"],["^5F","^39"]]]]],"^9","Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided.","^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^5F"],["^5F","^39"]]],"^=",["^>",[["^5F"],["^5F","^39"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/drop-while","^B",false,"^1","cljs/core.cljs","^2",17,"^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^5F"],["^5F","^39"]]],"^=",["^>",[["^5F"],["^5F","^39"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^5F"],["^5F","^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4767,"^6",4767,"^F",2,"^G",true,"^=",["^>",[["^5F"],["^5F","^39"]]],"^9","Returns a lazy sequence of the items in coll starting from the\n first item for which (pred item) returns logical false. Returns a\n stateful transducer when no collection is provided."],"~$IWriter",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",750,"^3",14,"^6",750,"^2",21,"^9","Protocol for writing. Currently only implemented by StringBufferWriter.","^2N",true,"^2O",["^>",["@interface"]],"^2P",["^ ","^2Q",["^ ","~$-write",[["^5K","~$s"]],"~$-flush",[["^5K"]]]]],"^2N",true,"^@","~$cljs.core/IWriter","^1","cljs/core.cljs","^2",21,"^3",1,"^5",750,"^2P",["^ ","^2Q",["^ ","^5S",[["^5K","~$s"]],"^5T",[["^5K"]]]],"^2T",null,"^6",750,"^7","^2U","^2V",["^17",["~$cljs.core/StringBufferWriter"]],"^9","Protocol for writing. Currently only implemented by StringBufferWriter.","^2O",["^>",["@interface"]]],"~$KeySeq",["^ ","^15",2,"^16",["^17",["^18","^19","^2=","^1:","^2?","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^@","~$cljs.core/KeySeq","^1","cljs/core.cljs","^2",16,"^1<",true,"^3",10,"^5",8838,"^1=",false,"^6",8838,"^7","^1>","^1?",["^17",["^18","^19","^2=","^2?","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]]],"~$realized?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10394,"^3",16,"^6",10394,"^2",25,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if a value has been produced for a delay or lazy sequence."],"^@","~$cljs.core/realized?","^B",false,"^1","cljs/core.cljs","^2",25,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10394,"^1B","^8","^6",10394,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if a value has been produced for a delay or lazy sequence."],"~$*print-fn*",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",69,"^3",3,"^6",69,"^2",13,"^9","Each runtime environment provides a different way to print output.\n Whatever function *print-fn* is bound to will be passed any\n Strings which should be printed.","^4",true],"^@","~$cljs.core/*print-fn*","^1","cljs/core.cljs","^2",13,"^3",1,"^4",true,"^5",65,"^6",69,"^7","^3C","^9","Each runtime environment provides a different way to print output.\n Whatever function *print-fn* is bound to will be passed any\n Strings which should be printed."],"~$compare",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2356,"^3",15,"^6",2356,"^2",22,"^7","^27","^=",["^>",["^?",["^>",[["~$x","~$y"]]]]],"^9","Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Uses IComparable if available and google.array.defaultCompare for objects\n of the same type and special-cases nil to be less than any other object."],"^@","~$cljs.core/compare","^B",false,"^1","cljs/core.cljs","^2",22,"^C",["^>",[["~$x","~$y"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2356,"^1B","^27","^6",2356,"^F",2,"^7","^27","^G",true,"^=",["^>",["^?",["^>",[["~$x","~$y"]]]]],"^9","Comparator. Returns a negative number, zero, or a positive number\n when x is logically 'less than', 'equal to', or 'greater than'\n y. Uses IComparable if available and google.array.defaultCompare for objects\n of the same type and special-cases nil to be less than any other object."],"~$complement",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4216,"^3",7,"^6",4216,"^2",17,"^=",["^>",["^?",["^>",[["~$f"]]]]],"^9","Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value."],"^@","~$cljs.core/complement","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["~$f"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4216,"^6",4216,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$f"]]]]],"^9","Takes a fn f and returns a fn that takes the same arguments as f,\n has the same effects, if any, and returns the opposite truth value."],"~$lookup-sentinel",["^ ","^@","~$cljs.core/lookup-sentinel","^1","cljs/core.cljs","^5",2193,"^3",1,"^6",2193,"^2",31,"^P",true,"^<",["^ ","^1","cljs/core.cljs","^5",2193,"^3",16,"^6",2193,"^2",31,"^P",true],"^7","~$object"],"~$-assoc!",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",795,"^3",9,"^6",795,"^2",16,"^7","^3<","^3=","^3L","^9","Returns a new transient collection of tcoll with a mapping from key to\n val added to it.","^=",["^>",["^?",["^>",[["^3?","^4Z","^2J"]]]]]],"^3=","^3L","^@","~$cljs.core/-assoc!","^B",false,"^1","cljs/core.cljs","^2",16,"^C",["^>",[["^3?","^4Z","^2J"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",793,"^1B","^3<","^6",795,"^F",3,"^7","^3<","^G",true,"^=",["^>",["^?",["^>",[["^3?","^4Z","^2J"]]]]],"^9","Returns a new transient collection of tcoll with a mapping from key to\n val added to it."],"~$*print-dup*",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",130,"^3",3,"^6",130,"^2",14,"^4",true,"^9","When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false."],"^@","~$cljs.core/*print-dup*","^1","cljs/core.cljs","^2",14,"^3",1,"^4",true,"^5",124,"^6",130,"^7","^8","^9","When set to logical true, objects will be printed in a way that preserves\n their type when read in later.\n\n Defaults to false."],"~$string-iter",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3976,"^3",7,"^6",3976,"^2",18,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/string-iter","^B",false,"^1","cljs/core.cljs","^2",18,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3976,"^6",3976,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$-key->js",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10517,"^3",4,"^6",10517,"^2",12,"^3=","~$cljs.core/IEncodeJS","^9","Transforms map keys to valid JavaScript keys. Arbitrary keys are\n encoded to their string representation via (pr-str x)","^=",["^>",["^?",["^>",[["~$x"]]]]]],"^3=","^6?","^@","~$cljs.core/-key->js","^B",false,"^1","cljs/core.cljs","^2",12,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10515,"^6",10517,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Transforms map keys to valid JavaScript keys. Arbitrary keys are\n encoded to their string representation via (pr-str x)"],"~$IDeref",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",671,"^3",14,"^6",671,"^2",20,"^9","Protocol for adding dereference functionality to a reference.","^2N",true,"^2O",["^>",["@interface"]],"^2P",["^ ","^2Q",["^ ","~$-deref",[["~$o"]]]]],"^2N",true,"^@","~$cljs.core/IDeref","^1","cljs/core.cljs","^2",20,"^3",1,"^5",671,"^2P",["^ ","^2Q",["^ ","^6B",[["~$o"]]]],"^2T",null,"^6",671,"^7","^2U","^2V",["^17",["~$cljs.core/Reduced","~$cljs.core/Volatile","~$cljs.core/Delay","~$cljs.core/Var","~$cljs.core/Atom"]],"^9","Protocol for adding dereference functionality to a reference.","^2O",["^>",["@interface"]]],"~$sequence",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4156,"^3",7,"^6",4156,"^2",15,"^=",["^>",["^?",["^>",[["^39"],["~$xform","^39"],["^6J","^39","~$&","~$colls"]]]]],"^9","Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments","^M",["^ ","^B",true,"^F",2,"^C",["^>",[["^39"],["^6J","^39"]]],"^=",["^>",[["^39"],["^6J","^39"],["^6J","^39","~$&","^6K"]]],"^E",["^>",[null,null,null]]]],"^@","~$cljs.core/sequence","^B",true,"^1","cljs/core.cljs","^2",15,"^M",["^ ","^B",true,"^F",2,"^C",["^>",[["^39"],["^6J","^39"]]],"^=",["^>",[["^39"],["^6J","^39"],["^6J","^39","~$&","^6K"]]],"^E",["^>",[null,null,null]]],"^C",["^>",[["^39"],["^6J","^39"]]],"^D",null,"^E",["^>",[null,null,null]],"^3",1,"^5",4156,"^6",4156,"^F",2,"^G",true,"^=",["^>",[["^39"],["^6J","^39"],["^6J","^39","~$&","^6K"]]],"^9","Coerces coll to a (possibly empty) sequence, if it is not already\n one. Will not force a lazy seq. (sequence nil) yields (), When a\n transducer is supplied, returns a lazy sequence of applications of\n the transform to the items in coll(s), i.e. to the set of first\n items of each coll, followed by the set of second\n items in each coll, until any one of the colls is exhausted. Any\n remaining items in other colls are ignored. The transform should accept\n number-of-colls arguments"],"~$constantly",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4226,"^3",7,"^6",4226,"^2",17,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns a function that takes any number of arguments and returns x."],"^@","~$cljs.core/constantly","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4226,"^6",4226,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns a function that takes any number of arguments and returns x."],"~$->RangedIterator",["^ ","^;",null,"^<",["^ ","^16",["^17",["^1:"]],"^1","cljs/core.cljs","^2",24,"^3",10,"^2G","^2H","^5",5392,"^6",5392,"^=",["^>",["^?",["^>",[["~$i","~$base","^3T","~$v","^Z","^["]]]]],"^1?",null,"^9","Positional factory function for cljs.core/RangedIterator."],"^16",["^17",["^1:"]],"^@","~$cljs.core/->RangedIterator","^B",false,"^1","cljs/core.cljs","^2",24,"^C",["^>",[["~$i","^6P","^3T","~$v","^Z","^["]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",5392,"^6",5392,"^F",6,"^G",true,"^=",["^>",["^?",["^>",[["~$i","^6P","^3T","~$v","^Z","^["]]]]],"^1?",null,"^9","Positional factory function for cljs.core/RangedIterator."],"~$chunked-seq",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",5751,"^3",7,"^6",5751,"^2",18,"^=",["^>",["^?",["^>",[["~$vec","~$i","~$off"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]]]],"^M",["^ ","^B",false,"^F",5,"^C",["^>",[["^6S","~$i","^6T"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]],"^=",["^>",[["^6S","~$i","^6T"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]],"^E",["^>",[null,null,null]]]],"^@","~$cljs.core/chunked-seq","^B",false,"^1","cljs/core.cljs","^2",18,"^M",["^ ","^B",false,"^F",5,"^C",["^>",[["^6S","~$i","^6T"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]],"^=",["^>",[["^6S","~$i","^6T"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]],"^E",["^>",[null,null,null]]],"^C",["^>",[["^6S","~$i","^6T"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]],"^D",null,"^E",["^>",[null,null,null]],"^3",1,"^5",5751,"^6",5751,"^F",5,"^G",true,"^=",["^>",[["^6S","~$i","^6T"],["^6S","^55","~$i","^6T"],["^6S","^55","~$i","^6T","^Y"]]]],"~$ISorted",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",733,"^3",14,"^6",733,"^2",21,"^9","Protocol for a collection which can represent their items\n in a sorted manner. ","^2N",true,"^2O",["^>",["@interface"]],"^2P",["^ ","^2Q",["^ ","~$-sorted-seq",[["^39","~$ascending?"]],"~$-sorted-seq-from",[["^39","~$k","^6X"]],"~$-entry-key",[["^39","~$entry"]],"~$-comparator",[["^39"]]]]],"^2N",true,"^@","~$cljs.core/ISorted","^1","cljs/core.cljs","^2",21,"^3",1,"^5",733,"^2P",["^ ","^2Q",["^ ","^6W",[["^39","^6X"]],"^6Y",[["^39","~$k","^6X"]],"^6Z",[["^39","^6["]],"^70",[["^39"]]]],"^2T",null,"^6",733,"^7","^2U","^2V",["^17",["~$cljs.core/PersistentTreeMap","~$cljs.core/PersistentTreeSet"]],"^9","Protocol for a collection which can represent their items\n in a sorted manner. ","^2O",["^>",["@interface"]]],"~$make-array",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",410,"^3",14,"^6",410,"^2",24,"^7","^1Y","^=",["^>",["^?",["^>",[["~$size"],["~$type","^75"],["^76","^75","~$&","~$more-sizes"]]]]],"^9","Construct a JavaScript array of the specified dimensions. Accepts ignored\n type argument for compatibility with Clojure. Note that there is no efficient\n way to allocate multi-dimensional arrays in JavaScript; as such, this function\n will run in polynomial time when called with 3 or more arguments.","^M",["^ ","^B",true,"^F",2,"^C",["^>",[["^75"],["^76","^75"]]],"^=",["^>",[["^75"],["^76","^75"],["^76","^75","~$&","^77"]]],"^E",["^>",[null,null,null]]]],"^@","~$cljs.core/make-array","^B",true,"^1","cljs/core.cljs","^2",24,"^M",["^ ","^B",true,"^F",2,"^C",["^>",[["^75"],["^76","^75"]]],"^=",["^>",[["^75"],["^76","^75"],["^76","^75","~$&","^77"]]],"^E",["^>",[null,null,null]]],"^C",["^>",[["^75"],["^76","^75"]]],"^D",null,"^E",["^>",[null,null,null]],"^3",1,"^5",410,"^1B","^1Y","^6",410,"^F",2,"^7","^1Y","^G",true,"^=",["^>",[["^75"],["^76","^75"],["^76","^75","~$&","^77"]]],"^9","Construct a JavaScript array of the specified dimensions. Accepts ignored\n type argument for compatibility with Clojure. Note that there is no efficient\n way to allocate multi-dimensional arrays in JavaScript; as such, this function\n will run in polynomial time when called with 3 or more arguments."],"~$checked-aget",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",452,"^3",8,"^6",452,"^2",20,"^P",true,"^=",["^>",["^?",["^>",[["^1Y","^56"],["^1Y","^56","~$&","~$idxs"]]]]],"^M",["^ ","^B",true,"^F",2,"^C",["^>",[["^1Y","^56"]]],"^=",["^>",[["^1Y","^56"],["^1Y","^56","~$&","^7:"]]],"^E",["^>",[null,null]]]],"^P",true,"^@","~$cljs.core/checked-aget","^B",true,"^1","cljs/core.cljs","^2",20,"^M",["^ ","^B",true,"^F",2,"^C",["^>",[["^1Y","^56"]]],"^=",["^>",[["^1Y","^56"],["^1Y","^56","~$&","^7:"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^1Y","^56"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",452,"^6",452,"^F",2,"^G",true,"^=",["^>",[["^1Y","^56"],["^1Y","^56","~$&","^7:"]]]],"~$shorts",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2800,"^3",7,"^6",2800,"^2",13,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/shorts","^B",false,"^1","cljs/core.cljs","^2",13,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2800,"^6",2800,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$*unchecked-if*",["^ ","^@","~$cljs.core/*unchecked-if*","^1","cljs/core.cljs","^5",26,"^3",1,"^6",26,"^2",20,"^<",["^ ","^1","cljs/core.cljs","^5",26,"^3",6,"^6",26,"^2",20],"^7","^8"],"~$->RSeq",["^ ","^;",null,"^<",["^ ","^16",["^17",["^18","^19","^2=","^1:","^2?","^3J","^2@","^2A","^2B","^2C","~$cljs.core/ICloneable","^2D","^2E","^2F"]],"^1","cljs/core.cljs","^2",14,"^3",10,"^2G","^2H","^5",1673,"^6",1673,"^=",["^>",["^?",["^>",[["~$ci","~$i","^Y"]]]]],"^1?",["^17",["^18","^19","^2=","^2?","^3J","^2@","^2A","^2B","^2C","^7A","^2D","^2E","^2F"]],"^9","Positional factory function for cljs.core/RSeq."],"^16",["^17",["^18","^19","^2=","^1:","^2?","^3J","^2@","^2A","^2B","^2C","^7A","^2D","^2E","^2F"]],"^@","~$cljs.core/->RSeq","^B",false,"^1","cljs/core.cljs","^2",14,"^C",["^>",[["^7B","~$i","^Y"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",1673,"^6",1673,"^F",3,"^G",true,"^=",["^>",["^?",["^>",[["^7B","~$i","^Y"]]]]],"^1?",["^17",["^18","^19","^2=","^2?","^3J","^2@","^2A","^2B","^2C","^7A","^2D","^2E","^2F"]],"^9","Positional factory function for cljs.core/RSeq."],"~$enable-console-print!",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",185,"^3",7,"^6",185,"^2",28,"^=",["^>",["^?",["^>",[[]]]]],"^9","Set *print-fn* to console.log"],"^@","~$cljs.core/enable-console-print!","^B",false,"^1","cljs/core.cljs","^2",28,"^C",["^>",[[]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",185,"^6",185,"^F",0,"^G",true,"^=",["^>",["^?",["^>",[[]]]]],"^9","Set *print-fn* to console.log"],"^5T",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",754,"^3",4,"^6",754,"^2",10,"^3=","^5U","^9","Flush writer.","^=",["^>",["^?",["^>",[["^5K"]]]]]],"^3=","^5U","^@","~$cljs.core/-flush","^B",false,"^1","cljs/core.cljs","^2",10,"^C",["^>",[["^5K"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",750,"^6",754,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^5K"]]]]],"^9","Flush writer."],"~$-lastIndexOf",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1542,"^3",8,"^6",1542,"^2",20,"^P",true,"^=",["^>",["^?",["^>",[["^39","~$x"],["^39","~$x","^Z"]]]]],"^M",["^ ","^B",false,"^F",3,"^C",["^>",[["^39","~$x"],["^39","~$x","^Z"]]],"^=",["^>",[["^39","~$x"],["^39","~$x","^Z"]]],"^E",["^>",[null,null]]]],"^P",true,"^@","~$cljs.core/-lastIndexOf","^B",false,"^1","cljs/core.cljs","^2",20,"^M",["^ ","^B",false,"^F",3,"^C",["^>",[["^39","~$x"],["^39","~$x","^Z"]]],"^=",["^>",[["^39","~$x"],["^39","~$x","^Z"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^39","~$x"],["^39","~$x","^Z"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1542,"^6",1542,"^F",3,"^G",true,"^=",["^>",[["^39","~$x"],["^39","~$x","^Z"]]]],"~$completing",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2550,"^3",7,"^6",2550,"^2",17,"^=",["^>",["^?",["^>",[["~$f"],["~$f","~$cf"]]]]],"^9","Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument.","^M",["^ ","^B",false,"^F",2,"^C",["^>",[["~$f"],["~$f","^7J"]]],"^=",["^>",[["~$f"],["~$f","^7J"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/completing","^B",false,"^1","cljs/core.cljs","^2",17,"^M",["^ ","^B",false,"^F",2,"^C",["^>",[["~$f"],["~$f","^7J"]]],"^=",["^>",[["~$f"],["~$f","^7J"]]],"^E",["^>",[null,null]]],"^C",["^>",[["~$f"],["~$f","^7J"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2550,"^6",2550,"^F",2,"^G",true,"^=",["^>",[["~$f"],["~$f","^7J"]]],"^9","Takes a reducing function f of 2 args and returns a fn suitable for\n transduce by adding an arity-1 signature that calls cf (default -\n identity) on the result argument."],"~$unchecked-negate-int",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2750,"^3",7,"^6",2750,"^2",27,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/unchecked-negate-int","^B",false,"^1","cljs/core.cljs","^2",27,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2750,"^6",2750,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$->PersistentVector",["^ ","^;",null,"^<",["^ ","^16",["^17",["~$cljs.core/APersistentVector","^3X","^4T","^4U","~$cljs.core/IKVReduce","^18","^19","^3H","^2=","~$cljs.core/IEditableCollection","^1:","^4V","^2?","^3J","^2B","^2C","^7A","^4W","^1K","^2D","^2E","^4Y","^3M","^2F"]],"^1","cljs/core.cljs","^2",26,"^3",10,"^2G","^2H","^5",5433,"^6",5433,"^=",["^>",["^?",["^>",[["^Y","^4E","^4F","^3O","^4G","^10"]]]]],"^1?",["^17",["^3X","^4T","^4U","^7P","^18","^19","^3H","^2=","^7Q","^2?","^3J","^2B","^2C","^7A","^4W","^1K","^2D","^2E","^4Y","^3M","^2F"]],"^9","Positional factory function for cljs.core/PersistentVector."],"^16",["^17",["^7O","^3X","^4T","^4U","^7P","^18","^19","^3H","^2=","^7Q","^1:","^4V","^2?","^3J","^2B","^2C","^7A","^4W","^1K","^2D","^2E","^4Y","^3M","^2F"]],"^@","~$cljs.core/->PersistentVector","^B",false,"^1","cljs/core.cljs","^2",26,"^C",["^>",[["^Y","^4E","^4F","^3O","^4G","^10"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",5433,"^6",5433,"^F",6,"^G",true,"^=",["^>",["^?",["^>",[["^Y","^4E","^4F","^3O","^4G","^10"]]]]],"^1?",["^17",["^3X","^4T","^4U","^7P","^18","^19","^3H","^2=","^7Q","^2?","^3J","^2B","^2C","^7A","^4W","^1K","^2D","^2E","^4Y","^3M","^2F"]],"^9","Positional factory function for cljs.core/PersistentVector."],"~$equiv-sequential",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2959,"^3",8,"^6",2959,"^2",24,"^P",true,"^=",["^>",["^?",["^>",[["~$x","~$y"]]]]],"^9","Assumes x is sequential. Returns true if x equals y, otherwise\n returns false."],"^P",true,"^@","~$cljs.core/equiv-sequential","^B",false,"^1","cljs/core.cljs","^2",24,"^C",["^>",[["~$x","~$y"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2959,"^6",2959,"^F",2,"^G",true,"^=",["^>",["^?",["^>",[["~$x","~$y"]]]]],"^9","Assumes x is sequential. Returns true if x equals y, otherwise\n returns false."],"~$hash-unordered-coll",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1339,"^3",15,"^6",1339,"^2",34,"^7","^27","^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://clojure.org/data_structures#hash for full algorithms."],"^@","~$cljs.core/hash-unordered-coll","^B",false,"^1","cljs/core.cljs","^2",34,"^C",["^>",[["^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1339,"^1B","^27","^6",1339,"^F",1,"^7","^27","^G",true,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Returns the hash code, consistent with =, for an external unordered\n collection implementing Iterable. For maps, the iterator should\n return map entries whose hash is computed as\n (hash-ordered-coll [k v]).\n See http://clojure.org/data_structures#hash for full algorithms."],"~$repeat",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4955,"^3",7,"^6",4955,"^2",13,"^=",["^>",["^?",["^>",[["~$x"],["~$n","~$x"]]]]],"^9","Returns a lazy (infinite!, or length n if supplied) sequence of xs.","^M",["^ ","^B",false,"^F",2,"^C",["^>",[["~$x"],["~$n","~$x"]]],"^=",["^>",[["~$x"],["~$n","~$x"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/repeat","^B",false,"^1","cljs/core.cljs","^2",13,"^M",["^ ","^B",false,"^F",2,"^C",["^>",[["~$x"],["~$n","~$x"]]],"^=",["^>",[["~$x"],["~$n","~$x"]]],"^E",["^>",[null,null]]],"^C",["^>",[["~$x"],["~$n","~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4955,"^6",4955,"^F",2,"^G",true,"^=",["^>",[["~$x"],["~$n","~$x"]]],"^9","Returns a lazy (infinite!, or length n if supplied) sequence of xs."],"~$unchecked-inc",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2727,"^3",7,"^6",2727,"^2",20,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/unchecked-inc","^B",false,"^1","cljs/core.cljs","^2",20,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2727,"^6",2727,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$nthnext",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2927,"^3",7,"^6",2927,"^2",14,"^=",["^>",["^?",["^>",[["^39","~$n"]]]]],"^9","Returns the nth next of coll, (seq coll) when n is 0."],"^@","~$cljs.core/nthnext","^B",false,"^1","cljs/core.cljs","^2",14,"^C",["^>",[["^39","~$n"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2927,"^6",2927,"^F",2,"^G",true,"^=",["^>",["^?",["^>",[["^39","~$n"]]]]],"^9","Returns the nth next of coll, (seq coll) when n is 0."],"~$preserving-reduced",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10399,"^3",8,"^6",10399,"^2",26,"^P",true,"^=",["^>",["^?",["^>",[["~$rf"]]]]]],"^P",true,"^@","~$cljs.core/preserving-reduced","^B",false,"^1","cljs/core.cljs","^2",26,"^C",["^>",[["^82"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",10399,"^6",10399,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^82"]]]]]],"~$get-validator",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4513,"^3",7,"^6",4513,"^2",20,"^=",["^>",["^?",["^>",[["~$iref"]]]]],"^9","Gets the validator-fn for a var/ref/agent/atom."],"^@","~$cljs.core/get-validator","^B",false,"^1","cljs/core.cljs","^2",20,"^C",["^>",[["^85"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4513,"^6",4513,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^85"]]]]],"^9","Gets the validator-fn for a var/ref/agent/atom."],"~$StringIter",["^ ","^15",2,"^16",["^17",["^1:"]],"^@","~$cljs.core/StringIter","^1","cljs/core.cljs","^2",20,"^1<",true,"^3",10,"^5",3967,"^1=",false,"^6",3967,"^7","^1>","^1?",null],"~$number?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",241,"^3",16,"^6",241,"^2",23,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x is a JavaScript number."],"^@","~$cljs.core/number?","^B",false,"^1","cljs/core.cljs","^2",23,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",241,"^1B","^8","^6",241,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x is a JavaScript number."],"~$-conj!",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",788,"^3",9,"^6",788,"^2",15,"^7","^3<","^3=","^3K","^9","Adds value val to tcoll and returns tcoll.","^=",["^>",["^?",["^>",[["^3?","^2J"]]]]]],"^3=","^3K","^@","~$cljs.core/-conj!","^B",false,"^1","cljs/core.cljs","^2",15,"^C",["^>",[["^3?","^2J"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",786,"^1B","^3<","^6",788,"^F",2,"^7","^3<","^G",true,"^=",["^>",["^?",["^>",[["^3?","^2J"]]]]],"^9","Adds value val to tcoll and returns tcoll."],"~$->PersistentArrayMapSeq",["^ ","^;",null,"^<",["^ ","^16",["^17",["^18","^19","^2=","^1:","^2?","^3J","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^1","cljs/core.cljs","^2",31,"^3",10,"^2G","^2H","^5",6655,"^6",6655,"^=",["^>",["^?",["^>",[["^3T","~$i","~$_meta"]]]]],"^1?",["^17",["^18","^19","^2=","^2?","^3J","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^9","Positional factory function for cljs.core/PersistentArrayMapSeq."],"^16",["^17",["^18","^19","^2=","^1:","^2?","^3J","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^@","~$cljs.core/->PersistentArrayMapSeq","^B",false,"^1","cljs/core.cljs","^2",31,"^C",["^>",[["^3T","~$i","^8>"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",6655,"^6",6655,"^F",3,"^G",true,"^=",["^>",["^?",["^>",[["^3T","~$i","^8>"]]]]],"^1?",["^17",["^18","^19","^2=","^2?","^3J","^2@","^2A","^2B","^2C","^2D","^2E","^2F"]],"^9","Positional factory function for cljs.core/PersistentArrayMapSeq."],"~$chunk-next",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3602,"^3",7,"^6",3602,"^2",17,"^=",["^>",["^?",["^>",[["~$s"]]]]]],"^@","~$cljs.core/chunk-next","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["~$s"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3602,"^6",3602,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$s"]]]]]],"~$ArrayList",["^ ","^15",1,"^16",["^17",["^1:"]],"^@","~$cljs.core/ArrayList","^1","cljs/core.cljs","^2",19,"^1<",true,"^3",10,"^5",9429,"^1=",false,"^6",9429,"^7","^1>","^1?",null],"~$print-str",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",10080,"^3",7,"^6",10080,"^2",16,"^=",["^>",["^?",["^>",[["~$&","~$objs"]]]]],"^9","print to a string, returning it","^M",["^ ","^B",true,"^F",0,"^C",[["^>",["^8E"]]],"^=",["^>",[["~$&","^8E"]]],"^E",["^>",[null]]]],"^@","~$cljs.core/print-str","^B",true,"^1","cljs/core.cljs","^2",16,"^M",["^ ","^B",true,"^F",0,"^C",[["^>",["^8E"]]],"^=",["^>",[["~$&","^8E"]]],"^E",["^>",[null]]],"^C",[["^>",["^8E"]]],"^D",null,"^E",["^>",[null]],"^3",1,"^5",10080,"^6",10080,"^F",0,"^G",true,"^=",["^>",[["~$&","^8E"]]],"^9","print to a string, returning it"],"~$not-any?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4201,"^3",16,"^6",4201,"^2",24,"^7","^8","^=",["^>",["^?",["^>",[["^5F","^39"]]]]],"^9","Returns false if (pred x) is logical true for any x in coll,\n else true."],"^@","~$cljs.core/not-any?","^B",false,"^1","cljs/core.cljs","^2",24,"^C",["^>",[["^5F","^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4201,"^1B","^8","^6",4201,"^F",2,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["^5F","^39"]]]]],"^9","Returns false if (pred x) is logical true for any x in coll,\n else true."],"~$into-array",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",518,"^3",14,"^6",518,"^2",24,"^7","^1Y","^=",["^>",["^?",["^>",[["~$aseq"],["^76","^8J"]]]]],"^9","Returns an array with components set to the values in aseq. Optional type\n argument accepted for compatibility with Clojure.","^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^8J"],["^76","^8J"]]],"^=",["^>",[["^8J"],["^76","^8J"]]],"^E",["^>",[null,null]]]],"^@","~$cljs.core/into-array","^B",false,"^1","cljs/core.cljs","^2",24,"^M",["^ ","^B",false,"^F",2,"^C",["^>",[["^8J"],["^76","^8J"]]],"^=",["^>",[["^8J"],["^76","^8J"]]],"^E",["^>",[null,null]]],"^C",["^>",[["^8J"],["^76","^8J"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",518,"^1B","^1Y","^6",518,"^F",2,"^7","^1Y","^G",true,"^=",["^>",[["^8J"],["^76","^8J"]]],"^9","Returns an array with components set to the values in aseq. Optional type\n argument accepted for compatibility with Clojure."],"~$-hash",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",711,"^3",4,"^6",711,"^2",9,"^3=","^19","^9","Returns the hash code of o.","^=",["^>",["^?",["^>",[["~$o"]]]]]],"^3=","^19","^@","~$cljs.core/-hash","^B",false,"^1","cljs/core.cljs","^2",9,"^C",["^>",[["~$o"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",709,"^6",711,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$o"]]]]],"^9","Returns the hash code of o."],"~$qualified-symbol?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3348,"^3",16,"^6",3348,"^2",33,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Return true if x is a symbol with a namespace"],"^@","~$cljs.core/qualified-symbol?","^B",false,"^1","cljs/core.cljs","^2",33,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3348,"^1B","^8","^6",3348,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Return true if x is a symbol with a namespace"],"~$-dissoc!",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",801,"^3",9,"^6",801,"^2",17,"^7","^3<","^3=","^3I","^9","Returns a new transient collection of tcoll without the mapping for key.","^=",["^>",["^?",["^>",[["^3?","^4Z"]]]]]],"^3=","^3I","^@","~$cljs.core/-dissoc!","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["^3?","^4Z"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",799,"^1B","^3<","^6",801,"^F",2,"^7","^3<","^G",true,"^=",["^>",["^?",["^>",[["^3?","^4Z"]]]]],"^9","Returns a new transient collection of tcoll without the mapping for key."],"~$->Reduced",["^ ","^;",null,"^<",["^ ","^16",["^17",["^6C"]],"^1","cljs/core.cljs","^2",17,"^3",10,"^2G","^2H","^5",1417,"^6",1417,"^=",["^>",["^?",["^>",[["^2J"]]]]],"^1?",["^17",["^6C"]],"^9","Positional factory function for cljs.core/Reduced."],"^16",["^17",["^6C"]],"^@","~$cljs.core/->Reduced","^B",false,"^1","cljs/core.cljs","^2",17,"^C",["^>",[["^2J"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",1417,"^6",1417,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^2J"]]]]],"^1?",["^17",["^6C"]],"^9","Positional factory function for cljs.core/Reduced."],"~$chunk-buffer",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",3478,"^3",7,"^6",3478,"^2",19,"^=",["^>",["^?",["^>",[["~$capacity"]]]]]],"^@","~$cljs.core/chunk-buffer","^B",false,"^1","cljs/core.cljs","^2",19,"^C",["^>",[["^8U"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",3478,"^6",3478,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^8U"]]]]]],"~$seqable?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2219,"^3",16,"^6",2219,"^2",24,"^7","^8","^=",["^>",["^?",["^>",[["~$s"]]]]],"^9","Return true if the seq function is supported for s"],"^@","~$cljs.core/seqable?","^B",false,"^1","cljs/core.cljs","^2",24,"^C",["^>",[["~$s"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2219,"^1B","^8","^6",2219,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$s"]]]]],"^9","Return true if the seq function is supported for s"],"~$symbol?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1036,"^3",16,"^6",1036,"^2",23,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Return true if x is a Symbol"],"^@","~$cljs.core/symbol?","^B",false,"^1","cljs/core.cljs","^2",23,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1036,"^1B","^8","^6",1036,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Return true if x is a Symbol"],"~$m3-hash-unencoded-chars",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",936,"^3",15,"^6",936,"^2",38,"^7","^27","^=",["^>",["^?",["^>",[["~$in"]]]]]],"^@","~$cljs.core/m3-hash-unencoded-chars","^B",false,"^1","cljs/core.cljs","^2",38,"^C",["^>",[["^90"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",936,"^1B","^27","^6",936,"^F",1,"^7","^27","^G",true,"^=",["^>",["^?",["^>",[["^90"]]]]]],"~$unchecked-char",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2691,"^3",15,"^6",2691,"^2",29,"^7","^27","^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/unchecked-char","^B",false,"^1","cljs/core.cljs","^2",29,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2691,"^1B","^27","^6",2691,"^F",1,"^7","^27","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$system-time",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",391,"^3",7,"^6",391,"^2",18,"^=",["^>",["^?",["^>",[[]]]]],"^9","Returns highest resolution time offered by host in milliseconds."],"^@","~$cljs.core/system-time","^B",false,"^1","cljs/core.cljs","^2",18,"^C",["^>",[[]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",391,"^6",391,"^F",0,"^G",true,"^=",["^>",["^?",["^>",[[]]]]],"^9","Returns highest resolution time offered by host in milliseconds."],"~$NeverEquiv",["^ ","^15",0,"^16",["^17",["^18","^1:"]],"^@","~$cljs.core/NeverEquiv","^1","cljs/core.cljs","^2",20,"^1<",true,"^3",10,"^5",6246,"^1=",false,"^6",6246,"^7","^1>","^1?",["^17",["^18"]]],"~$chunkIteratorSeq",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",4086,"^3",8,"^6",4086,"^2",24,"^P",true,"^=",["^>",["^?",["^>",[["~$iter"]]]]]],"^P",true,"^@","~$cljs.core/chunkIteratorSeq","^B",false,"^1","cljs/core.cljs","^2",24,"^C",["^>",[["^99"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",4086,"^6",4086,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^99"]]]]]],"~$-invoke",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",541,"^3",4,"^6",541,"^2",11,"^3=","^3H","^9",null,"^=",["^>",["^?",["^>",[["~$this"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]]]],"^M",["^ ","^B",false,"^F",22,"^C",["^>",[["^9<"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]],"^=",["^>",[["^9<"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]],"^E",["^>",[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]]]],"^3=","^3H","^@","~$cljs.core/-invoke","^B",false,"^1","cljs/core.cljs","^2",11,"^M",["^ ","^B",false,"^F",22,"^C",["^>",[["^9<"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]],"^=",["^>",[["^9<"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]],"^E",["^>",[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]]],"^C",["^>",[["^9<"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]],"^D",null,"^E",["^>",[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]],"^3",1,"^5",537,"^6",541,"^F",22,"^G",true,"^=",["^>",[["^9<"],["^9<","~$a"],["^9<","~$a","~$b"],["^9<","~$a","~$b","~$c"],["^9<","~$a","~$b","~$c","~$d"],["^9<","~$a","~$b","~$c","~$d","~$e"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t"],["^9<","~$a","~$b","~$c","~$d","~$e","~$f","~$g","~$h","~$i","~$j","~$k","~$l","~$m","~$n","~$o","~$p","~$q","~$r","~$s","~$t","^5B"]]],"^9",null],"~$coll?",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2099,"^3",16,"^6",2099,"^2",21,"^7","^8","^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x satisfies ICollection"],"^@","~$cljs.core/coll?","^B",false,"^1","cljs/core.cljs","^2",21,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2099,"^1B","^8","^6",2099,"^F",1,"^7","^8","^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]],"^9","Returns true if x satisfies ICollection"],"~$get-in",["^ ","^;",null,"^<",["^ ","~:added","1.2","^1","cljs/core.cljs","^2",13,"~:static",true,"^M",["^ ","^B",false,"^F",3,"^C",["^>",[["~$m","~$ks"],["~$m","^9C","~$not-found"]]],"^=",["^>",[["~$m","^9C"],["~$m","^9C","^9D"]]],"^E",["^>",[null,null]]],"^3",7,"^5",5222,"^6",5222,"^=",["^>",["^?",["^>",[["~$m","^9C"],["~$m","^9C","^9D"]]]]],"^9","Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key is not present,\n or the not-found value if supplied."],"^9A","1.2","^@","~$cljs.core/get-in","^B",false,"^1","cljs/core.cljs","^2",13,"^9B",true,"^M",["^ ","^B",false,"^F",3,"^C",["^>",[["~$m","^9C"],["~$m","^9C","^9D"]]],"^=",["^>",[["~$m","^9C"],["~$m","^9C","^9D"]]],"^E",["^>",[null,null]]],"^C",["^>",[["~$m","^9C"],["~$m","^9C","^9D"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",5222,"^6",5222,"^F",3,"^G",true,"^=",["^>",[["~$m","^9C"],["~$m","^9C","^9D"]]],"^9","Returns the value in a nested associative structure,\n where ks is a sequence of keys. Returns nil if the key is not present,\n or the not-found value if supplied."],"~$fnext",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1751,"^3",7,"^6",1751,"^2",12,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Same as (first (next x))"],"^@","~$cljs.core/fnext","^B",false,"^1","cljs/core.cljs","^2",12,"^C",["^>",[["^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1751,"^6",1751,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Same as (first (next x))"],"~$IList",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",722,"^3",14,"^6",722,"^2",19,"^9","Marker interface indicating a persistent list","^2N",true,"^2O",["^>",["@interface"]],"^2P",["^ ","^2Q",["^ "]]],"^2N",true,"^@","~$cljs.core/IList","^1","cljs/core.cljs","^2",19,"^3",1,"^5",722,"^2P",["^ ","^2Q",["^ "]],"^2T",null,"^6",722,"^7","^2U","^2V",["^17",["~$cljs.core/Cons","~$cljs.core/EmptyList","~$cljs.core/List"]],"^9","Marker interface indicating a persistent list","^2O",["^>",["@interface"]]],"~$ArrayNodeIterator",["^ ","^15",3,"^16",["^17",["^1:"]],"^@","~$cljs.core/ArrayNodeIterator","^1","cljs/core.cljs","^2",27,"^1<",true,"^3",10,"^5",7360,"^1=",false,"^6",7360,"^7","^1>","^1?",null],"~$List",["^ ","^<",["^ ","^1","cljs/core.cljs","^5",1515,"^3",45,"^6",1515,"^2",49,"^3W",true],"^15",5,"^16",["^17",["^9I","^18","^19","~$cljs.core/ASeq","^2=","^1:","^2?","^3J","^2@","^2A","^2B","^2C","^7A","^4W","^2D","^2E","^2F"]],"^@","^9L","^1","cljs/core.cljs","^2",14,"^1<",true,"^3",10,"^5",3017,"^1=",false,"^3W",true,"^6",3017,"^7","^1>","^1?",["^17",["^9I","^18","^19","^9P","^2=","^2?","^3J","^2@","^2A","^2B","^2C","^7A","^4W","^2D","^2E","^2F"]]],"~$-val",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",648,"^3",4,"^6",648,"^2",8,"^3=","^4X","^9","Returns the value of the map entry.","^=",["^>",["^?",["^>",[["^39"]]]]]],"^3=","^4X","^@","~$cljs.core/-val","^B",false,"^1","cljs/core.cljs","^2",8,"^C",["^>",[["^39"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",644,"^6",648,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["^39"]]]]],"^9","Returns the value of the map entry."],"~$bytes",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",2798,"^3",7,"^6",2798,"^2",12,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"^@","~$cljs.core/bytes","^B",false,"^1","cljs/core.cljs","^2",12,"^C",["^>",[["~$x"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",2798,"^6",2798,"^F",1,"^G",true,"^=",["^>",["^?",["^>",[["~$x"]]]]]],"~$->ObjMap",["^ ","^;",null,"^<",["^ ","^16",["^17",["^7P","^18","^19","^3H","^2=","^7Q","^1:","^4V","^2?","^3J","^2B","^2C","^2E","^4Y","~$cljs.core/IMap","^3M"]],"^1","cljs/core.cljs","^2",16,"^3",10,"^2G","^2H","^5",6321,"^6",6321,"^=",["^>",["^?",["^>",[["^Y","~$keys","~$strobj","~$update-count","^10"]]]]],"^1?",["^17",["^7P","^18","^19","^3H","^2=","^7Q","^2?","^3J","^2B","^2C","^2E","^4Y","^9V","^3M"]],"^9","Positional factory function for cljs.core/ObjMap."],"^16",["^17",["^7P","^18","^19","^3H","^2=","^7Q","^1:","^4V","^2?","^3J","^2B","^2C","^2E","^4Y","^9V","^3M"]],"^@","~$cljs.core/->ObjMap","^B",false,"^1","cljs/core.cljs","^2",16,"^C",["^>",[["^Y","^9W","^9X","^9Y","^10"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^2G","^2H","^5",6321,"^6",6321,"^F",5,"^G",true,"^=",["^>",["^?",["^>",[["^Y","^9W","^9X","^9Y","^10"]]]]],"^1?",["^17",["^7P","^18","^19","^3H","^2=","^7Q","^2?","^3J","^2B","^2C","^2E","^4Y","^9V","^3M"]],"^9","Positional factory function for cljs.core/ObjMap."],"~$compare-symbols",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",1046,"^3",8,"^6",1046,"^2",23,"^P",true,"^=",["^>",["^?",["^>",[["~$a","~$b"]]]]]],"^P",true,"^@","~$cljs.core/compare-symbols","^B",false,"^1","cljs/core.cljs","^2",23,"^C",["^>",[["~$a","~$b"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",1046,"^6",1046,"^F",2,"^G",true,"^=",["^>",["^?",["^>",[["~$a","~$b"]]]]]],"~$t_cljs$core9266",["^ ","^15",1,"^16",["^17",["^1:","^2C","^2E"]],"^@","~$cljs.core/t_cljs$core9266","^1","cljs/core.cljs","^1<",true,"~:anonymous",true,"^3",3,"^5",3961,"^1=",false,"^7","^1>","^1?",["^17",["^2C","^2E"]]],"~$-seq",["^ ","^;",null,"^<",["^ ","^1","cljs/core.cljs","^5",716,"^3",16,"^6",716,"^2",20,"^7","~$clj-or-nil","^3=","^2B","^9","Returns a seq of o, or nil if o is empty.","^=",["^>",["^?",["^>",[["~$o"]]]]]],"^3=","^2B","^@","~$cljs.core/-seq","^B",false,"^1","cljs/core.cljs","^2",20,"^C",["^>",[["~$o"]]],"^D",null,"^E",["^>",[null,null]],"^3",1,"^5",714,"^1B","^:5","^6",716,"^F",1,"^7","^:5","^G",true,"^=",["^>",["^?",["^>",[["~$o"]]]]],"^9","Returns a seq of o, or nil if o is empty."]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^17",["~$form","^37","~$&","~$uuid","~$case*","^[","~$defrecord*","^6P","~$obj","~$fqn","~$first","~$try","^3P","~$rear","~$hierarchy","^99","~$step","^8","^9Y","~$method-table","^5A","~$i","^5B","^<","~:dup","^1D","~$dispatch-fn","~$buffer","~:else","^4[","~$ns*","~:cljs.core/none","^4F","~$iters","^6J","~:validator","~$finally","~:default","^1P","~$loop*","~$watches","~:ns","~$bitmap","~$_seq","^3Q","~$v","~$riter","^10","^Y","^8>","~$afn","^1E","~$fn","~$front","~$buf","~$next-entry","~:val","^4Z","~$_next","~$root-iter","~$do","^6S","~:fallback-impl","~:keyword-fn","~:flush-on-newline","~$default-dispatch-val","~:no-test","~$validator","~$letfn*","~$if","^3T","~$new","~:descendants","~$ns","~$completed","~:ancestors","^1U","^20","~:readably","~$meta9267","~:more-marker","~$fields","~$method-cache","^3N","~$editable?","~$base-count","~$collision-hash","~$deftype*","~$let*","^Z","~$sourceIter","^39","~$not-native","~$js*","^9X","~$_rest","~$fn*","^2J","^6X","~$recur","~$xf","^7B","~:print-length","~$state","~:ok","~$vals","~$meta1501","~$all","~:cljs.core/halt","~$cached-hierarchy","~$s","~:parents","^4E","^55","~$sym","~$sb","~$seed","~$prev-seed","~$_hash","^9W","~$set!","^7","~$tree-map","~$.","~$var","~:mutable","^?","^3O","~$multi","~$str","^2K","~$nodes","~$seen","~$hash-map","~$catch","~:alt-impl","~$ext-map-iter","^4G","~$record","~$meta10806","~$mseq","^2I","~:keywordize-keys","~$current","^6T","~$stack","~$transient-map","~$prev","~$len","^50","~$throw","~$fseq","~:cljs.core/not-found","^2:","~$def","~$f","~$next-iter"]],"~:order",["^;6","^;A","^<","^:G","^;R","^:J","^<0","^:P","^;>","^20","^<9","^<3","^<7","^8>","^2J","^;[","~$s","^1U","^99","^;N","^3T","~$i","^Y","^7B","^:W","^:A","^5B","^2I","^10","^:@","^:X","^:Z","^[","^6T","^5A","^2:","^;B","^:U","^;1","^;U","^:M","^:I","^;?","^;Q","^;K","^<8","^;S","^;9","^:R","^:N","^;W","^","^;4","^;0","^;X","^6J","^39","^;5","^","^:B","^:K","^:O","^:Q","^;3","^;:","^;;","^;<","^;I","^;J","^;M","^;O","^;P","^<4","~$.","^<6","^?","^<=","^": "_GT_"}); +/** + * @enum {string} + */ +cljs.core.DEMUNGE_MAP = ({"_RBRACE_": "}", "_COLON_": ":", "_BANG_": "!", "_QMARK_": "?", "_BSLASH_": "\\\\", "_SLASH_": "/", "_PERCENT_": "%", "_PLUS_": "+", "_SHARP_": "#", "_LBRACE_": "{", "_BAR_": "|", "_LBRACK_": "[", "_EQ_": "=", "_": "-", "_TILDE_": "~", "_RBRACK_": "]", "_GT_": ">", "_SINGLEQUOTE_": "'", "_CIRCA_": "@", "_AMPERSAND_": "&", "_DOUBLEQUOTE_": "\\\"", "_CARET_": "^", "_LT_": "<", "_STAR_": "*"}); +cljs.core.DEMUNGE_PATTERN = null; +/** + * Returns highest resolution time offered by host in milliseconds. + */ +cljs.core.system_time = (function cljs$core$system_time(){ +if((((typeof performance !== 'undefined')) && (!((performance.now == null))))){ +return performance.now(); +} else { +if((((typeof process !== 'undefined')) && (!((process.hrtime == null))))){ +var t = process.hrtime(); +return ((((t[(0)]) * 1.0E9) + (t[(1)])) / 1000000.0); +} else { +return (new Date()).getTime(); + +} +} +}); +/** + * Construct a JavaScript array of the specified dimensions. Accepts ignored + * type argument for compatibility with Clojure. Note that there is no efficient + * way to allocate multi-dimensional arrays in JavaScript; as such, this function + * will run in polynomial time when called with 3 or more arguments. + */ +cljs.core.make_array = (function cljs$core$make_array(var_args){ +var G__534 = arguments.length; +switch (G__534) { +case 1: +return cljs.core.make_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.make_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___536 = arguments.length; +var i__4519__auto___537 = (0); +while(true){ +if((i__4519__auto___537 < len__4518__auto___536)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___537])); + +var G__538 = (i__4519__auto___537 + (1)); +i__4519__auto___537 = G__538; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.make_array.cljs$core$IFn$_invoke$arity$1 = (function (size){ +return (new Array(size)); +}); + +cljs.core.make_array.cljs$core$IFn$_invoke$arity$2 = (function (type,size){ +return (new Array(size)); +}); + +cljs.core.make_array.cljs$core$IFn$_invoke$arity$variadic = (function (type,size,more_sizes){ +var dims = more_sizes; +var dimarray = (new Array(size)); +var n__4395__auto___539 = dimarray.length; +var i_540 = (0); +while(true){ +if((i_540 < n__4395__auto___539)){ +(dimarray[i_540] = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.make_array,null,dims)); + +var G__541 = (i_540 + (1)); +i_540 = G__541; +continue; +} else { +} +break; +} + +return dimarray; +}); + +/** @this {Function} */ +cljs.core.make_array.cljs$lang$applyTo = (function (seq531){ +var G__532 = cljs.core.first(seq531); +var seq531__$1 = cljs.core.next(seq531); +var G__533 = cljs.core.first(seq531__$1); +var seq531__$2 = cljs.core.next(seq531__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__532,G__533,seq531__$2); +}); + +cljs.core.make_array.cljs$lang$maxFixedArity = (2); + +/** + * Returns a javascript array, cloned from the passed in array + */ +cljs.core.aclone = (function cljs$core$aclone(arr){ +var len = arr.length; +var new_arr = (new Array(len)); +var n__4395__auto___542 = len; +var i_543 = (0); +while(true){ +if((i_543 < n__4395__auto___542)){ +(new_arr[i_543] = (arr[i_543])); + +var G__544 = (i_543 + (1)); +i_543 = G__544; +continue; +} else { +} +break; +} + +return new_arr; +}); +/** + * Creates a new javascript array. + * @param {...*} var_args + */ +cljs.core.array = (function cljs$core$array(var_args){ +var a = (new Array(arguments.length)); +var i = (0); +while(true){ +if((i < a.length)){ +(a[i] = (arguments[i])); + +var G__545 = (i + (1)); +i = G__545; +continue; +} else { +return a; +} +break; +} +}); +cljs.core.maybe_warn = (function cljs$core$maybe_warn(e){ +if(cljs.core.truth_(cljs.core._STAR_print_err_fn_STAR_)){ +return (cljs.core._STAR_print_err_fn_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.core._STAR_print_err_fn_STAR_.cljs$core$IFn$_invoke$arity$1(e) : cljs.core._STAR_print_err_fn_STAR_.call(null,e)); +} else { +return null; +} +}); +cljs.core.checked_aget = (function cljs$core$checked_aget(var_args){ +var G__550 = arguments.length; +switch (G__550) { +case 2: +return cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___553 = arguments.length; +var i__4519__auto___554 = (0); +while(true){ +if((i__4519__auto___554 < len__4518__auto___553)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___554])); + +var G__555 = (i__4519__auto___554 + (1)); +i__4519__auto___554 = G__555; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2 = (function (array,idx){ +try{if(cljs.core.truth_((function (){var or__3936__auto__ = cljs.core.array_QMARK_(array); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return goog.isArrayLike(array); +} +})())){ +} else { +throw (new Error("Assert failed: (or (array? array) (goog/isArrayLike array))")); +} + +if(typeof idx === 'number'){ +} else { +throw (new Error("Assert failed: (number? idx)")); +} + +if(!((idx < (0)))){ +} else { +throw (new Error("Assert failed: (not (neg? idx))")); +} + +if((idx < array.length)){ +} else { +throw (new Error("Assert failed: (< idx (alength array))")); +} +}catch (e551){var e_556 = e551; +cljs.core.maybe_warn(e_556); +} +return (array[idx]); +}); + +cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$variadic = (function (array,idx,idxs){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.checked_aget,cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2(array,idx),idxs); +}); + +/** @this {Function} */ +cljs.core.checked_aget.cljs$lang$applyTo = (function (seq547){ +var G__548 = cljs.core.first(seq547); +var seq547__$1 = cljs.core.next(seq547); +var G__549 = cljs.core.first(seq547__$1); +var seq547__$2 = cljs.core.next(seq547__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__548,G__549,seq547__$2); +}); + +cljs.core.checked_aget.cljs$lang$maxFixedArity = (2); + +cljs.core.checked_aset = (function cljs$core$checked_aset(var_args){ +var G__562 = arguments.length; +switch (G__562) { +case 3: +return cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___565 = arguments.length; +var i__4519__auto___566 = (0); +while(true){ +if((i__4519__auto___566 < len__4518__auto___565)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___566])); + +var G__567 = (i__4519__auto___566 + (1)); +i__4519__auto___566 = G__567; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$3 = (function (array,idx,val){ +try{if(cljs.core.truth_((function (){var or__3936__auto__ = cljs.core.array_QMARK_(array); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return goog.isArrayLike(array); +} +})())){ +} else { +throw (new Error("Assert failed: (or (array? array) (goog/isArrayLike array))")); +} + +if(typeof idx === 'number'){ +} else { +throw (new Error("Assert failed: (number? idx)")); +} + +if(!((idx < (0)))){ +} else { +throw (new Error("Assert failed: (not (neg? idx))")); +} + +if((idx < array.length)){ +} else { +throw (new Error("Assert failed: (< idx (alength array))")); +} +}catch (e563){var e_568 = e563; +cljs.core.maybe_warn(e_568); +} +return (array[idx] = val); +}); + +cljs.core.checked_aset.cljs$core$IFn$_invoke$arity$variadic = (function (array,idx,idx2,idxv){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core.checked_aset,cljs.core.checked_aget.cljs$core$IFn$_invoke$arity$2(array,idx),idx2,idxv); +}); + +/** @this {Function} */ +cljs.core.checked_aset.cljs$lang$applyTo = (function (seq558){ +var G__559 = cljs.core.first(seq558); +var seq558__$1 = cljs.core.next(seq558); +var G__560 = cljs.core.first(seq558__$1); +var seq558__$2 = cljs.core.next(seq558__$1); +var G__561 = cljs.core.first(seq558__$2); +var seq558__$3 = cljs.core.next(seq558__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__559,G__560,G__561,seq558__$3); +}); + +cljs.core.checked_aset.cljs$lang$maxFixedArity = (3); + +cljs.core.checked_aget_SINGLEQUOTE_ = (function cljs$core$checked_aget_SINGLEQUOTE_(var_args){ +var G__573 = arguments.length; +switch (G__573) { +case 2: +return cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___575 = arguments.length; +var i__4519__auto___576 = (0); +while(true){ +if((i__4519__auto___576 < len__4518__auto___575)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___576])); + +var G__577 = (i__4519__auto___576 + (1)); +i__4519__auto___576 = G__577; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2 = (function (array,idx){ +if(cljs.core.truth_((function (){var or__3936__auto__ = cljs.core.array_QMARK_(array); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return goog.isArrayLike(array); +} +})())){ +} else { +throw (new Error("Assert failed: (or (array? array) (goog/isArrayLike array))")); +} + +if(typeof idx === 'number'){ +} else { +throw (new Error("Assert failed: (number? idx)")); +} + +if(!((idx < (0)))){ +} else { +throw (new Error("Assert failed: (not (neg? idx))")); +} + +if((idx < array.length)){ +} else { +throw (new Error("Assert failed: (< idx (alength array))")); +} + +return (array[idx]); +}); + +cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic = (function (array,idx,idxs){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.checked_aget_SINGLEQUOTE_,cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2(array,idx),idxs); +}); + +/** @this {Function} */ +cljs.core.checked_aget_SINGLEQUOTE_.cljs$lang$applyTo = (function (seq570){ +var G__571 = cljs.core.first(seq570); +var seq570__$1 = cljs.core.next(seq570); +var G__572 = cljs.core.first(seq570__$1); +var seq570__$2 = cljs.core.next(seq570__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__571,G__572,seq570__$2); +}); + +cljs.core.checked_aget_SINGLEQUOTE_.cljs$lang$maxFixedArity = (2); + +cljs.core.checked_aset_SINGLEQUOTE_ = (function cljs$core$checked_aset_SINGLEQUOTE_(var_args){ +var G__583 = arguments.length; +switch (G__583) { +case 3: +return cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___585 = arguments.length; +var i__4519__auto___586 = (0); +while(true){ +if((i__4519__auto___586 < len__4518__auto___585)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___586])); + +var G__587 = (i__4519__auto___586 + (1)); +i__4519__auto___586 = G__587; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$3 = (function (array,idx,val){ +if(cljs.core.truth_((function (){var or__3936__auto__ = cljs.core.array_QMARK_(array); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return goog.isArrayLike(array); +} +})())){ +} else { +throw (new Error("Assert failed: (or (array? array) (goog/isArrayLike array))")); +} + +if(typeof idx === 'number'){ +} else { +throw (new Error("Assert failed: (number? idx)")); +} + +if(!((idx < (0)))){ +} else { +throw (new Error("Assert failed: (not (neg? idx))")); +} + +if((idx < array.length)){ +} else { +throw (new Error("Assert failed: (< idx (alength array))")); +} + +return (array[idx] = val); +}); + +cljs.core.checked_aset_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$variadic = (function (array,idx,idx2,idxv){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core.checked_aset_SINGLEQUOTE_,cljs.core.checked_aget_SINGLEQUOTE_.cljs$core$IFn$_invoke$arity$2(array,idx),idx2,idxv); +}); + +/** @this {Function} */ +cljs.core.checked_aset_SINGLEQUOTE_.cljs$lang$applyTo = (function (seq579){ +var G__580 = cljs.core.first(seq579); +var seq579__$1 = cljs.core.next(seq579); +var G__581 = cljs.core.first(seq579__$1); +var seq579__$2 = cljs.core.next(seq579__$1); +var G__582 = cljs.core.first(seq579__$2); +var seq579__$3 = cljs.core.next(seq579__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__580,G__581,G__582,seq579__$3); +}); + +cljs.core.checked_aset_SINGLEQUOTE_.cljs$lang$maxFixedArity = (3); + +/** + * Returns the value at the index/indices. Works on JavaScript arrays. + */ +cljs.core.aget = (function cljs$core$aget(var_args){ +var G__592 = arguments.length; +switch (G__592) { +case 2: +return cljs.core.aget.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___594 = arguments.length; +var i__4519__auto___595 = (0); +while(true){ +if((i__4519__auto___595 < len__4518__auto___594)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___595])); + +var G__596 = (i__4519__auto___595 + (1)); +i__4519__auto___595 = G__596; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.aget.cljs$core$IFn$_invoke$arity$2 = (function (array,idx){ +return (array[idx]); +}); + +cljs.core.aget.cljs$core$IFn$_invoke$arity$variadic = (function (array,idx,idxs){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.aget,(array[idx]),idxs); +}); + +/** @this {Function} */ +cljs.core.aget.cljs$lang$applyTo = (function (seq589){ +var G__590 = cljs.core.first(seq589); +var seq589__$1 = cljs.core.next(seq589); +var G__591 = cljs.core.first(seq589__$1); +var seq589__$2 = cljs.core.next(seq589__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__590,G__591,seq589__$2); +}); + +cljs.core.aget.cljs$lang$maxFixedArity = (2); + +/** + * Sets the value at the index/indices. Works on JavaScript arrays. + * Returns val. + */ +cljs.core.aset = (function cljs$core$aset(var_args){ +var G__602 = arguments.length; +switch (G__602) { +case 3: +return cljs.core.aset.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___604 = arguments.length; +var i__4519__auto___605 = (0); +while(true){ +if((i__4519__auto___605 < len__4518__auto___604)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___605])); + +var G__606 = (i__4519__auto___605 + (1)); +i__4519__auto___605 = G__606; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.aset.cljs$core$IFn$_invoke$arity$3 = (function (array,idx,val){ +return (array[idx] = val); +}); + +cljs.core.aset.cljs$core$IFn$_invoke$arity$variadic = (function (array,idx,idx2,idxv){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core.aset,(array[idx]),idx2,idxv); +}); + +/** @this {Function} */ +cljs.core.aset.cljs$lang$applyTo = (function (seq598){ +var G__599 = cljs.core.first(seq598); +var seq598__$1 = cljs.core.next(seq598); +var G__600 = cljs.core.first(seq598__$1); +var seq598__$2 = cljs.core.next(seq598__$1); +var G__601 = cljs.core.first(seq598__$2); +var seq598__$3 = cljs.core.next(seq598__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__599,G__600,G__601,seq598__$3); +}); + +cljs.core.aset.cljs$lang$maxFixedArity = (3); + +/** + * Returns the length of the array. Works on arrays of all types. + */ +cljs.core.alength = (function cljs$core$alength(array){ +return array.length; +}); +/** + * Returns an array with components set to the values in aseq. Optional type + * argument accepted for compatibility with Clojure. + */ +cljs.core.into_array = (function cljs$core$into_array(var_args){ +var G__608 = arguments.length; +switch (G__608) { +case 1: +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.into_array.cljs$core$IFn$_invoke$arity$1 = (function (aseq){ +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$2(null,aseq); +}); + +cljs.core.into_array.cljs$core$IFn$_invoke$arity$2 = (function (type,aseq){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (a,x){ +a.push(x); + +return a; +}),[],aseq); +}); + +cljs.core.into_array.cljs$lang$maxFixedArity = 2; + +/** + * Invoke JavaScript object method via string. Needed when the + * string is not a valid unquoted property name. + */ +cljs.core.js_invoke = (function cljs$core$js_invoke(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___613 = arguments.length; +var i__4519__auto___614 = (0); +while(true){ +if((i__4519__auto___614 < len__4518__auto___613)){ +args__4521__auto__.push((arguments[i__4519__auto___614])); + +var G__615 = (i__4519__auto___614 + (1)); +i__4519__auto___614 = G__615; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((2) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((2)),(0),null)):null); +return cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4522__auto__); +}); + +cljs.core.js_invoke.cljs$core$IFn$_invoke$arity$variadic = (function (obj,s,args){ +return (obj[s]).apply(obj,cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(args)); +}); + +cljs.core.js_invoke.cljs$lang$maxFixedArity = (2); + +/** @this {Function} */ +cljs.core.js_invoke.cljs$lang$applyTo = (function (seq610){ +var G__611 = cljs.core.first(seq610); +var seq610__$1 = cljs.core.next(seq610); +var G__612 = cljs.core.first(seq610__$1); +var seq610__$2 = cljs.core.next(seq610__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__611,G__612,seq610__$2); +}); + + +/** + * Marker protocol + * @interface + */ +cljs.core.Fn = function(){}; + + +/** + * Protocol for adding the ability to invoke an object as a function. + * For example, a vector can also be used to look up a value: + * ([1 2 3 4] 1) => 2 + * @interface + */ +cljs.core.IFn = function(){}; + +cljs.core._invoke = (function cljs$core$_invoke(var_args){ +var G__617 = arguments.length; +switch (G__617) { +case 1: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +case 6: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +case 7: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$7((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)])); + +break; +case 8: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$8((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)])); + +break; +case 9: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$9((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)])); + +break; +case 10: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$10((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)])); + +break; +case 11: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$11((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)])); + +break; +case 12: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$12((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)])); + +break; +case 13: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$13((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)])); + +break; +case 14: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$14((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)])); + +break; +case 15: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$15((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)])); + +break; +case 16: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$16((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)])); + +break; +case 17: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$17((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)]),(arguments[(16)])); + +break; +case 18: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$18((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)]),(arguments[(16)]),(arguments[(17)])); + +break; +case 19: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$19((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)]),(arguments[(16)]),(arguments[(17)]),(arguments[(18)])); + +break; +case 20: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$20((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)]),(arguments[(16)]),(arguments[(17)]),(arguments[(18)]),(arguments[(19)])); + +break; +case 21: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$21((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)]),(arguments[(16)]),(arguments[(17)]),(arguments[(18)]),(arguments[(19)]),(arguments[(20)])); + +break; +case 22: +return cljs.core._invoke.cljs$core$IFn$_invoke$arity$22((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)]),(arguments[(7)]),(arguments[(8)]),(arguments[(9)]),(arguments[(10)]),(arguments[(11)]),(arguments[(12)]),(arguments[(13)]),(arguments[(14)]),(arguments[(15)]),(arguments[(16)]),(arguments[(17)]),(arguments[(18)]),(arguments[(19)]),(arguments[(20)]),(arguments[(21)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$1 = (function (this$){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$1 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$1(this$); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(this$) : m__4231__auto__.call(null,this$)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(this$) : m__4231__auto____$1.call(null,this$)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$2 = (function (this$,a){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$2 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$2(this$,a); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(this$,a) : m__4231__auto__.call(null,this$,a)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(this$,a) : m__4231__auto____$1.call(null,this$,a)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$3 = (function (this$,a,b){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$3 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$3(this$,a,b); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(this$,a,b) : m__4231__auto__.call(null,this$,a,b)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(this$,a,b) : m__4231__auto____$1.call(null,this$,a,b)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$4 = (function (this$,a,b,c){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$4 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$4(this$,a,b,c); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$4 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$4(this$,a,b,c) : m__4231__auto__.call(null,this$,a,b,c)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$4 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$4(this$,a,b,c) : m__4231__auto____$1.call(null,this$,a,b,c)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$5 = (function (this$,a,b,c,d){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$5 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$5 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d) : m__4231__auto__.call(null,this$,a,b,c,d)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$5 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d) : m__4231__auto____$1.call(null,this$,a,b,c,d)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$6 = (function (this$,a,b,c,d,e){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$6 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$6 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e) : m__4231__auto__.call(null,this$,a,b,c,d,e)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$6 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e) : m__4231__auto____$1.call(null,this$,a,b,c,d,e)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$7 = (function (this$,a,b,c,d,e,f){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$7 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$7 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f) : m__4231__auto__.call(null,this$,a,b,c,d,e,f)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$7 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$8 = (function (this$,a,b,c,d,e,f,g){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$8 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$8 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$8 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$9 = (function (this$,a,b,c,d,e,f,g,h){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$9 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$9 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$9 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$10 = (function (this$,a,b,c,d,e,f,g,h,i){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$10 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$10 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$10 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$11 = (function (this$,a,b,c,d,e,f,g,h,i,j){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$11 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$11 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$11 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$12 = (function (this$,a,b,c,d,e,f,g,h,i,j,k){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$12 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$12 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$12 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$13 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$13 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$13(this$,a,b,c,d,e,f,g,h,i,j,k,l); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$13 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$13(this$,a,b,c,d,e,f,g,h,i,j,k,l) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$13 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$13(this$,a,b,c,d,e,f,g,h,i,j,k,l) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$14 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$14 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$14(this$,a,b,c,d,e,f,g,h,i,j,k,l,m); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$14 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$14(this$,a,b,c,d,e,f,g,h,i,j,k,l,m) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$14 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$14(this$,a,b,c,d,e,f,g,h,i,j,k,l,m) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$15 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$15 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$15(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$15 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$15(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$15 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$15(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$16 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$16 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$16(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$16 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$16(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$16 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$16(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$17 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$17 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$17(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$17 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$17(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$17 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$17(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$18 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$18 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$18(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$18 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$18(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$18 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$18(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$19 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$19 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$19(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$19 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$19(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$19 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$19(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$20 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$20 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$20(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$20 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$20(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$20 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$20(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$21 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$21 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$21(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$21 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$21(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$21 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$21(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$core$IFn$_invoke$arity$22 = (function (this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +if(((!((this$ == null))) && (!((this$.cljs$core$IFn$_invoke$arity$22 == null))))){ +return this$.cljs$core$IFn$_invoke$arity$22(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._invoke[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$22 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$22(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest) : m__4231__auto__.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest)); +} else { +var m__4231__auto____$1 = (cljs.core._invoke["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$22 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$22(this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest) : m__4231__auto____$1.call(null,this$,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest)); +} else { +throw cljs.core.missing_protocol("IFn.-invoke",this$); +} +} +} +}); + +cljs.core._invoke.cljs$lang$maxFixedArity = 22; + + + +/** + * Protocol for cloning a value. + * @interface + */ +cljs.core.ICloneable = function(){}; + +/** + * Creates a clone of value. + */ +cljs.core._clone = (function cljs$core$_clone(value){ +if(((!((value == null))) && (!((value.cljs$core$ICloneable$_clone$arity$1 == null))))){ +return value.cljs$core$ICloneable$_clone$arity$1(value); +} else { +var x__4230__auto__ = (((value == null))?null:value); +var m__4231__auto__ = (cljs.core._clone[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(value) : m__4231__auto__.call(null,value)); +} else { +var m__4231__auto____$1 = (cljs.core._clone["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(value) : m__4231__auto____$1.call(null,value)); +} else { +throw cljs.core.missing_protocol("ICloneable.-clone",value); +} +} +} +}); + + +/** + * Protocol for adding the ability to count a collection in constant time. + * @interface + */ +cljs.core.ICounted = function(){}; + +/** + * Calculates the count of coll in constant time. Used by cljs.core/count. + */ +cljs.core._count = (function cljs$core$_count(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$ICounted$_count$arity$1 == null))))){ +return coll.cljs$core$ICounted$_count$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._count[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._count["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("ICounted.-count",coll); +} +} +} +}); + + +/** + * Protocol for creating an empty collection. + * @interface + */ +cljs.core.IEmptyableCollection = function(){}; + +/** + * Returns an empty collection of the same category as coll. Used + * by cljs.core/empty. + */ +cljs.core._empty = (function cljs$core$_empty(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IEmptyableCollection$_empty$arity$1 == null))))){ +return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._empty[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._empty["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IEmptyableCollection.-empty",coll); +} +} +} +}); + + +/** + * Protocol for adding to a collection. + * @interface + */ +cljs.core.ICollection = function(){}; + +/** + * Returns a new collection of coll with o added to it. The new item + * should be added to the most efficient place, e.g. + * (conj [1 2 3 4] 5) => [1 2 3 4 5] + * (conj '(2 3 4 5) 1) => '(1 2 3 4 5) + */ +cljs.core._conj = (function cljs$core$_conj(coll,o){ +if(((!((coll == null))) && (!((coll.cljs$core$ICollection$_conj$arity$2 == null))))){ +return coll.cljs$core$ICollection$_conj$arity$2(coll,o); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._conj[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,o) : m__4231__auto__.call(null,coll,o)); +} else { +var m__4231__auto____$1 = (cljs.core._conj["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,o) : m__4231__auto____$1.call(null,coll,o)); +} else { +throw cljs.core.missing_protocol("ICollection.-conj",coll); +} +} +} +}); + + +/** + * Protocol for collections to provide indexed-based access to their items. + * @interface + */ +cljs.core.IIndexed = function(){}; + +/** + * Returns the value at the index n in the collection coll. + * Returns not-found if index n is out of bounds and not-found is supplied. + */ +cljs.core._nth = (function cljs$core$_nth(var_args){ +var G__620 = arguments.length; +switch (G__620) { +case 2: +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._nth.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._nth.cljs$core$IFn$_invoke$arity$2 = (function (coll,n){ +if(((!((coll == null))) && (!((coll.cljs$core$IIndexed$_nth$arity$2 == null))))){ +return coll.cljs$core$IIndexed$_nth$arity$2(coll,n); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._nth[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,n) : m__4231__auto__.call(null,coll,n)); +} else { +var m__4231__auto____$1 = (cljs.core._nth["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,n) : m__4231__auto____$1.call(null,coll,n)); +} else { +throw cljs.core.missing_protocol("IIndexed.-nth",coll); +} +} +} +}); + +cljs.core._nth.cljs$core$IFn$_invoke$arity$3 = (function (coll,n,not_found){ +if(((!((coll == null))) && (!((coll.cljs$core$IIndexed$_nth$arity$3 == null))))){ +return coll.cljs$core$IIndexed$_nth$arity$3(coll,n,not_found); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._nth[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(coll,n,not_found) : m__4231__auto__.call(null,coll,n,not_found)); +} else { +var m__4231__auto____$1 = (cljs.core._nth["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(coll,n,not_found) : m__4231__auto____$1.call(null,coll,n,not_found)); +} else { +throw cljs.core.missing_protocol("IIndexed.-nth",coll); +} +} +} +}); + +cljs.core._nth.cljs$lang$maxFixedArity = 3; + + + +/** + * Marker protocol indicating an array sequence. + * @interface + */ +cljs.core.ASeq = function(){}; + + +/** + * Protocol for collections to provide access to their items as sequences. + * @interface + */ +cljs.core.ISeq = function(){}; + +/** + * Returns the first item in the collection coll. Used by cljs.core/first. + */ +cljs.core._first = (function cljs$core$_first(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$ISeq$_first$arity$1 == null))))){ +return coll.cljs$core$ISeq$_first$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._first[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._first["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("ISeq.-first",coll); +} +} +} +}); + +/** + * Returns a new collection of coll without the first item. It should + * always return a seq, e.g. + * (rest []) => () + * (rest nil) => () + */ +cljs.core._rest = (function cljs$core$_rest(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$ISeq$_rest$arity$1 == null))))){ +return coll.cljs$core$ISeq$_rest$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._rest[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._rest["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("ISeq.-rest",coll); +} +} +} +}); + + +/** + * Protocol for accessing the next items of a collection. + * @interface + */ +cljs.core.INext = function(){}; + +/** + * Returns a new collection of coll without the first item. In contrast to + * rest, it should return nil if there are no more items, e.g. + * (next []) => nil + * (next nil) => nil + */ +cljs.core._next = (function cljs$core$_next(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$INext$_next$arity$1 == null))))){ +return coll.cljs$core$INext$_next$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._next[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._next["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("INext.-next",coll); +} +} +} +}); + + +/** + * Protocol for looking up a value in a data structure. + * @interface + */ +cljs.core.ILookup = function(){}; + +/** + * Use k to look up a value in o. If not-found is supplied and k is not + * a valid value that can be used for look up, not-found is returned. + */ +cljs.core._lookup = (function cljs$core$_lookup(var_args){ +var G__623 = arguments.length; +switch (G__623) { +case 2: +return cljs.core._lookup.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._lookup.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._lookup.cljs$core$IFn$_invoke$arity$2 = (function (o,k){ +if(((!((o == null))) && (!((o.cljs$core$ILookup$_lookup$arity$2 == null))))){ +return o.cljs$core$ILookup$_lookup$arity$2(o,k); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._lookup[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(o,k) : m__4231__auto__.call(null,o,k)); +} else { +var m__4231__auto____$1 = (cljs.core._lookup["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(o,k) : m__4231__auto____$1.call(null,o,k)); +} else { +throw cljs.core.missing_protocol("ILookup.-lookup",o); +} +} +} +}); + +cljs.core._lookup.cljs$core$IFn$_invoke$arity$3 = (function (o,k,not_found){ +if(((!((o == null))) && (!((o.cljs$core$ILookup$_lookup$arity$3 == null))))){ +return o.cljs$core$ILookup$_lookup$arity$3(o,k,not_found); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._lookup[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(o,k,not_found) : m__4231__auto__.call(null,o,k,not_found)); +} else { +var m__4231__auto____$1 = (cljs.core._lookup["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(o,k,not_found) : m__4231__auto____$1.call(null,o,k,not_found)); +} else { +throw cljs.core.missing_protocol("ILookup.-lookup",o); +} +} +} +}); + +cljs.core._lookup.cljs$lang$maxFixedArity = 3; + + + +/** + * Protocol for adding associativity to collections. + * @interface + */ +cljs.core.IAssociative = function(){}; + +/** + * Returns true if k is a key in coll. + */ +cljs.core._contains_key_QMARK_ = (function cljs$core$_contains_key_QMARK_(coll,k){ +if(((!((coll == null))) && (!((coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 == null))))){ +return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll,k); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._contains_key_QMARK_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__4231__auto__.call(null,coll,k)); +} else { +var m__4231__auto____$1 = (cljs.core._contains_key_QMARK_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,k) : m__4231__auto____$1.call(null,coll,k)); +} else { +throw cljs.core.missing_protocol("IAssociative.-contains-key?",coll); +} +} +} +}); + +/** + * Returns a new collection of coll with a mapping from key k to + * value v added to it. + */ +cljs.core._assoc = (function cljs$core$_assoc(coll,k,v){ +if(((!((coll == null))) && (!((coll.cljs$core$IAssociative$_assoc$arity$3 == null))))){ +return coll.cljs$core$IAssociative$_assoc$arity$3(coll,k,v); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._assoc[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,v) : m__4231__auto__.call(null,coll,k,v)); +} else { +var m__4231__auto____$1 = (cljs.core._assoc["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(coll,k,v) : m__4231__auto____$1.call(null,coll,k,v)); +} else { +throw cljs.core.missing_protocol("IAssociative.-assoc",coll); +} +} +} +}); + + +/** + * Protocol for implementing entry finding in collections. + * @interface + */ +cljs.core.IFind = function(){}; + +/** + * Returns the map entry for key, or nil if key not present. + */ +cljs.core._find = (function cljs$core$_find(coll,k){ +if(((!((coll == null))) && (!((coll.cljs$core$IFind$_find$arity$2 == null))))){ +return coll.cljs$core$IFind$_find$arity$2(coll,k); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._find[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__4231__auto__.call(null,coll,k)); +} else { +var m__4231__auto____$1 = (cljs.core._find["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,k) : m__4231__auto____$1.call(null,coll,k)); +} else { +throw cljs.core.missing_protocol("IFind.-find",coll); +} +} +} +}); + + +/** + * Protocol for adding mapping functionality to collections. + * @interface + */ +cljs.core.IMap = function(){}; + +/** + * Returns a new collection of coll without the mapping for key k. + */ +cljs.core._dissoc = (function cljs$core$_dissoc(coll,k){ +if(((!((coll == null))) && (!((coll.cljs$core$IMap$_dissoc$arity$2 == null))))){ +return coll.cljs$core$IMap$_dissoc$arity$2(coll,k); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._dissoc[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,k) : m__4231__auto__.call(null,coll,k)); +} else { +var m__4231__auto____$1 = (cljs.core._dissoc["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,k) : m__4231__auto____$1.call(null,coll,k)); +} else { +throw cljs.core.missing_protocol("IMap.-dissoc",coll); +} +} +} +}); + + +/** + * Protocol for examining a map entry. + * @interface + */ +cljs.core.IMapEntry = function(){}; + +/** + * Returns the key of the map entry. + */ +cljs.core._key = (function cljs$core$_key(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IMapEntry$_key$arity$1 == null))))){ +return coll.cljs$core$IMapEntry$_key$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._key[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._key["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IMapEntry.-key",coll); +} +} +} +}); + +/** + * Returns the value of the map entry. + */ +cljs.core._val = (function cljs$core$_val(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IMapEntry$_val$arity$1 == null))))){ +return coll.cljs$core$IMapEntry$_val$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._val[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._val["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IMapEntry.-val",coll); +} +} +} +}); + + +/** + * Protocol for adding set functionality to a collection. + * @interface + */ +cljs.core.ISet = function(){}; + +/** + * Returns a new collection of coll that does not contain v. + */ +cljs.core._disjoin = (function cljs$core$_disjoin(coll,v){ +if(((!((coll == null))) && (!((coll.cljs$core$ISet$_disjoin$arity$2 == null))))){ +return coll.cljs$core$ISet$_disjoin$arity$2(coll,v); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._disjoin[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,v) : m__4231__auto__.call(null,coll,v)); +} else { +var m__4231__auto____$1 = (cljs.core._disjoin["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,v) : m__4231__auto____$1.call(null,coll,v)); +} else { +throw cljs.core.missing_protocol("ISet.-disjoin",coll); +} +} +} +}); + + +/** + * Protocol for collections to provide access to their items as stacks. The top + * of the stack should be accessed in the most efficient way for the different + * data structures. + * @interface + */ +cljs.core.IStack = function(){}; + +/** + * Returns the item from the top of the stack. Is used by cljs.core/peek. + */ +cljs.core._peek = (function cljs$core$_peek(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IStack$_peek$arity$1 == null))))){ +return coll.cljs$core$IStack$_peek$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._peek[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._peek["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IStack.-peek",coll); +} +} +} +}); + +/** + * Returns a new stack without the item on top of the stack. Is used + * by cljs.core/pop. + */ +cljs.core._pop = (function cljs$core$_pop(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IStack$_pop$arity$1 == null))))){ +return coll.cljs$core$IStack$_pop$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._pop[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._pop["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IStack.-pop",coll); +} +} +} +}); + + +/** + * Protocol for adding vector functionality to collections. + * @interface + */ +cljs.core.IVector = function(){}; + +/** + * Returns a new vector with value val added at position n. + */ +cljs.core._assoc_n = (function cljs$core$_assoc_n(coll,n,val){ +if(((!((coll == null))) && (!((coll.cljs$core$IVector$_assoc_n$arity$3 == null))))){ +return coll.cljs$core$IVector$_assoc_n$arity$3(coll,n,val); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._assoc_n[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(coll,n,val) : m__4231__auto__.call(null,coll,n,val)); +} else { +var m__4231__auto____$1 = (cljs.core._assoc_n["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(coll,n,val) : m__4231__auto____$1.call(null,coll,n,val)); +} else { +throw cljs.core.missing_protocol("IVector.-assoc-n",coll); +} +} +} +}); + + +/** + * Protocol for adding dereference functionality to a reference. + * @interface + */ +cljs.core.IDeref = function(){}; + +/** + * Returns the value of the reference o. + */ +cljs.core._deref = (function cljs$core$_deref(o){ +if(((!((o == null))) && (!((o.cljs$core$IDeref$_deref$arity$1 == null))))){ +return o.cljs$core$IDeref$_deref$arity$1(o); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._deref[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto__.call(null,o)); +} else { +var m__4231__auto____$1 = (cljs.core._deref["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto____$1.call(null,o)); +} else { +throw cljs.core.missing_protocol("IDeref.-deref",o); +} +} +} +}); + + +/** + * @interface + */ +cljs.core.IDerefWithTimeout = function(){}; + +cljs.core._deref_with_timeout = (function cljs$core$_deref_with_timeout(o,msec,timeout_val){ +if(((!((o == null))) && (!((o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3 == null))))){ +return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o,msec,timeout_val); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._deref_with_timeout[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(o,msec,timeout_val) : m__4231__auto__.call(null,o,msec,timeout_val)); +} else { +var m__4231__auto____$1 = (cljs.core._deref_with_timeout["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(o,msec,timeout_val) : m__4231__auto____$1.call(null,o,msec,timeout_val)); +} else { +throw cljs.core.missing_protocol("IDerefWithTimeout.-deref-with-timeout",o); +} +} +} +}); + + +/** + * Protocol for accessing the metadata of an object. + * @interface + */ +cljs.core.IMeta = function(){}; + +/** + * Returns the metadata of object o. + */ +cljs.core._meta = (function cljs$core$_meta(o){ +if(((!((o == null))) && (!((o.cljs$core$IMeta$_meta$arity$1 == null))))){ +return o.cljs$core$IMeta$_meta$arity$1(o); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._meta[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto__.call(null,o)); +} else { +var m__4231__auto____$1 = (cljs.core._meta["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto____$1.call(null,o)); +} else { +throw cljs.core.missing_protocol("IMeta.-meta",o); +} +} +} +}); + + +/** + * Protocol for adding metadata to an object. + * @interface + */ +cljs.core.IWithMeta = function(){}; + +/** + * Returns a new object with value of o and metadata meta added to it. + */ +cljs.core._with_meta = (function cljs$core$_with_meta(o,meta){ +if(((!((o == null))) && (!((o.cljs$core$IWithMeta$_with_meta$arity$2 == null))))){ +return o.cljs$core$IWithMeta$_with_meta$arity$2(o,meta); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._with_meta[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(o,meta) : m__4231__auto__.call(null,o,meta)); +} else { +var m__4231__auto____$1 = (cljs.core._with_meta["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(o,meta) : m__4231__auto____$1.call(null,o,meta)); +} else { +throw cljs.core.missing_protocol("IWithMeta.-with-meta",o); +} +} +} +}); + + +/** + * Protocol for seq types that can reduce themselves. + * Called by cljs.core/reduce. + * @interface + */ +cljs.core.IReduce = function(){}; + +/** + * f should be a function of 2 arguments. If start is not supplied, + * returns the result of applying f to the first 2 items in coll, then + * applying f to that result and the 3rd item, etc. + */ +cljs.core._reduce = (function cljs$core$_reduce(var_args){ +var G__626 = arguments.length; +switch (G__626) { +case 2: +return cljs.core._reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._reduce.cljs$core$IFn$_invoke$arity$2 = (function (coll,f){ +if(((!((coll == null))) && (!((coll.cljs$core$IReduce$_reduce$arity$2 == null))))){ +return coll.cljs$core$IReduce$_reduce$arity$2(coll,f); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._reduce[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,f) : m__4231__auto__.call(null,coll,f)); +} else { +var m__4231__auto____$1 = (cljs.core._reduce["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,f) : m__4231__auto____$1.call(null,coll,f)); +} else { +throw cljs.core.missing_protocol("IReduce.-reduce",coll); +} +} +} +}); + +cljs.core._reduce.cljs$core$IFn$_invoke$arity$3 = (function (coll,f,start){ +if(((!((coll == null))) && (!((coll.cljs$core$IReduce$_reduce$arity$3 == null))))){ +return coll.cljs$core$IReduce$_reduce$arity$3(coll,f,start); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._reduce[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(coll,f,start) : m__4231__auto__.call(null,coll,f,start)); +} else { +var m__4231__auto____$1 = (cljs.core._reduce["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(coll,f,start) : m__4231__auto____$1.call(null,coll,f,start)); +} else { +throw cljs.core.missing_protocol("IReduce.-reduce",coll); +} +} +} +}); + +cljs.core._reduce.cljs$lang$maxFixedArity = 3; + + + +/** + * Protocol for associative types that can reduce themselves + * via a function of key and val. Called by cljs.core/reduce-kv. + * @interface + */ +cljs.core.IKVReduce = function(){}; + +/** + * Reduces an associative collection and returns the result. f should be + * a function that takes three arguments. + */ +cljs.core._kv_reduce = (function cljs$core$_kv_reduce(coll,f,init){ +if(((!((coll == null))) && (!((coll.cljs$core$IKVReduce$_kv_reduce$arity$3 == null))))){ +return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll,f,init); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._kv_reduce[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(coll,f,init) : m__4231__auto__.call(null,coll,f,init)); +} else { +var m__4231__auto____$1 = (cljs.core._kv_reduce["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(coll,f,init) : m__4231__auto____$1.call(null,coll,f,init)); +} else { +throw cljs.core.missing_protocol("IKVReduce.-kv-reduce",coll); +} +} +} +}); + + +/** + * Protocol for adding value comparison functionality to a type. + * @interface + */ +cljs.core.IEquiv = function(){}; + +/** + * Returns true if o and other are equal, false otherwise. + */ +cljs.core._equiv = (function cljs$core$_equiv(o,other){ +if(((!((o == null))) && (!((o.cljs$core$IEquiv$_equiv$arity$2 == null))))){ +return o.cljs$core$IEquiv$_equiv$arity$2(o,other); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._equiv[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(o,other) : m__4231__auto__.call(null,o,other)); +} else { +var m__4231__auto____$1 = (cljs.core._equiv["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(o,other) : m__4231__auto____$1.call(null,o,other)); +} else { +throw cljs.core.missing_protocol("IEquiv.-equiv",o); +} +} +} +}); + + +/** + * Protocol for adding hashing functionality to a type. + * @interface + */ +cljs.core.IHash = function(){}; + +/** + * Returns the hash code of o. + */ +cljs.core._hash = (function cljs$core$_hash(o){ +if(((!((o == null))) && (!((o.cljs$core$IHash$_hash$arity$1 == null))))){ +return o.cljs$core$IHash$_hash$arity$1(o); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._hash[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto__.call(null,o)); +} else { +var m__4231__auto____$1 = (cljs.core._hash["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto____$1.call(null,o)); +} else { +throw cljs.core.missing_protocol("IHash.-hash",o); +} +} +} +}); + + +/** + * Protocol for adding the ability to a type to be transformed into a sequence. + * @interface + */ +cljs.core.ISeqable = function(){}; + +/** + * Returns a seq of o, or nil if o is empty. + */ +cljs.core._seq = (function cljs$core$_seq(o){ +if(((!((o == null))) && (!((o.cljs$core$ISeqable$_seq$arity$1 == null))))){ +return o.cljs$core$ISeqable$_seq$arity$1(o); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._seq[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto__.call(null,o)); +} else { +var m__4231__auto____$1 = (cljs.core._seq["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(o) : m__4231__auto____$1.call(null,o)); +} else { +throw cljs.core.missing_protocol("ISeqable.-seq",o); +} +} +} +}); + + +/** + * Marker interface indicating a persistent collection of sequential items + * @interface + */ +cljs.core.ISequential = function(){}; + + +/** + * Marker interface indicating a persistent list + * @interface + */ +cljs.core.IList = function(){}; + + +/** + * Marker interface indicating a record object + * @interface + */ +cljs.core.IRecord = function(){}; + + +/** + * Protocol for reversing a seq. + * @interface + */ +cljs.core.IReversible = function(){}; + +/** + * Returns a seq of the items in coll in reversed order. + */ +cljs.core._rseq = (function cljs$core$_rseq(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IReversible$_rseq$arity$1 == null))))){ +return coll.cljs$core$IReversible$_rseq$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._rseq[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._rseq["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IReversible.-rseq",coll); +} +} +} +}); + + +/** + * Protocol for a collection which can represent their items + * in a sorted manner. + * @interface + */ +cljs.core.ISorted = function(){}; + +/** + * Returns a sorted seq from coll in either ascending or descending order. + */ +cljs.core._sorted_seq = (function cljs$core$_sorted_seq(coll,ascending_QMARK_){ +if(((!((coll == null))) && (!((coll.cljs$core$ISorted$_sorted_seq$arity$2 == null))))){ +return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll,ascending_QMARK_); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._sorted_seq[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,ascending_QMARK_) : m__4231__auto__.call(null,coll,ascending_QMARK_)); +} else { +var m__4231__auto____$1 = (cljs.core._sorted_seq["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,ascending_QMARK_) : m__4231__auto____$1.call(null,coll,ascending_QMARK_)); +} else { +throw cljs.core.missing_protocol("ISorted.-sorted-seq",coll); +} +} +} +}); + +/** + * Returns a sorted seq from coll in either ascending or descending order. + * If ascending is true, the result should contain all items which are > or >= + * than k. If ascending is false, the result should contain all items which + * are < or <= than k, e.g. + * (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 true) => (3 4 5) + * (-sorted-seq-from (sorted-set 1 2 3 4 5) 3 false) => (3 2 1) + */ +cljs.core._sorted_seq_from = (function cljs$core$_sorted_seq_from(coll,k,ascending_QMARK_){ +if(((!((coll == null))) && (!((coll.cljs$core$ISorted$_sorted_seq_from$arity$3 == null))))){ +return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll,k,ascending_QMARK_); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._sorted_seq_from[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(coll,k,ascending_QMARK_) : m__4231__auto__.call(null,coll,k,ascending_QMARK_)); +} else { +var m__4231__auto____$1 = (cljs.core._sorted_seq_from["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(coll,k,ascending_QMARK_) : m__4231__auto____$1.call(null,coll,k,ascending_QMARK_)); +} else { +throw cljs.core.missing_protocol("ISorted.-sorted-seq-from",coll); +} +} +} +}); + +/** + * Returns the key for entry. + */ +cljs.core._entry_key = (function cljs$core$_entry_key(coll,entry){ +if(((!((coll == null))) && (!((coll.cljs$core$ISorted$_entry_key$arity$2 == null))))){ +return coll.cljs$core$ISorted$_entry_key$arity$2(coll,entry); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._entry_key[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(coll,entry) : m__4231__auto__.call(null,coll,entry)); +} else { +var m__4231__auto____$1 = (cljs.core._entry_key["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(coll,entry) : m__4231__auto____$1.call(null,coll,entry)); +} else { +throw cljs.core.missing_protocol("ISorted.-entry-key",coll); +} +} +} +}); + +/** + * Returns the comparator for coll. + */ +cljs.core._comparator = (function cljs$core$_comparator(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$ISorted$_comparator$arity$1 == null))))){ +return coll.cljs$core$ISorted$_comparator$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._comparator[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._comparator["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("ISorted.-comparator",coll); +} +} +} +}); + + +/** + * Protocol for writing. Currently only implemented by StringBufferWriter. + * @interface + */ +cljs.core.IWriter = function(){}; + +/** + * Writes s with writer and returns the result. + */ +cljs.core._write = (function cljs$core$_write(writer,s){ +if(((!((writer == null))) && (!((writer.cljs$core$IWriter$_write$arity$2 == null))))){ +return writer.cljs$core$IWriter$_write$arity$2(writer,s); +} else { +var x__4230__auto__ = (((writer == null))?null:writer); +var m__4231__auto__ = (cljs.core._write[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(writer,s) : m__4231__auto__.call(null,writer,s)); +} else { +var m__4231__auto____$1 = (cljs.core._write["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(writer,s) : m__4231__auto____$1.call(null,writer,s)); +} else { +throw cljs.core.missing_protocol("IWriter.-write",writer); +} +} +} +}); + +/** + * Flush writer. + */ +cljs.core._flush = (function cljs$core$_flush(writer){ +if(((!((writer == null))) && (!((writer.cljs$core$IWriter$_flush$arity$1 == null))))){ +return writer.cljs$core$IWriter$_flush$arity$1(writer); +} else { +var x__4230__auto__ = (((writer == null))?null:writer); +var m__4231__auto__ = (cljs.core._flush[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(writer) : m__4231__auto__.call(null,writer)); +} else { +var m__4231__auto____$1 = (cljs.core._flush["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(writer) : m__4231__auto____$1.call(null,writer)); +} else { +throw cljs.core.missing_protocol("IWriter.-flush",writer); +} +} +} +}); + + +/** + * The old IPrintable protocol's implementation consisted of building a giant + * list of strings to concatenate. This involved lots of concat calls, + * intermediate vectors, and lazy-seqs, and was very slow in some older JS + * engines. IPrintWithWriter implements printing via the IWriter protocol, so it + * be implemented efficiently in terms of e.g. a StringBuffer append. + * @interface + */ +cljs.core.IPrintWithWriter = function(){}; + +cljs.core._pr_writer = (function cljs$core$_pr_writer(o,writer,opts){ +if(((!((o == null))) && (!((o.cljs$core$IPrintWithWriter$_pr_writer$arity$3 == null))))){ +return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o,writer,opts); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._pr_writer[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(o,writer,opts) : m__4231__auto__.call(null,o,writer,opts)); +} else { +var m__4231__auto____$1 = (cljs.core._pr_writer["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(o,writer,opts) : m__4231__auto____$1.call(null,o,writer,opts)); +} else { +throw cljs.core.missing_protocol("IPrintWithWriter.-pr-writer",o); +} +} +} +}); + + +/** + * Protocol for types which can have a deferred realization. Currently only + * implemented by Delay and LazySeq. + * @interface + */ +cljs.core.IPending = function(){}; + +/** + * Returns true if a value for x has been produced, false otherwise. + */ +cljs.core._realized_QMARK_ = (function cljs$core$_realized_QMARK_(x){ +if(((!((x == null))) && (!((x.cljs$core$IPending$_realized_QMARK_$arity$1 == null))))){ +return x.cljs$core$IPending$_realized_QMARK_$arity$1(x); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._realized_QMARK_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto__.call(null,x)); +} else { +var m__4231__auto____$1 = (cljs.core._realized_QMARK_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto____$1.call(null,x)); +} else { +throw cljs.core.missing_protocol("IPending.-realized?",x); +} +} +} +}); + + +/** + * Protocol for types that can be watched. Currently only implemented by Atom. + * @interface + */ +cljs.core.IWatchable = function(){}; + +/** + * Calls all watchers with this, oldval and newval. + */ +cljs.core._notify_watches = (function cljs$core$_notify_watches(this$,oldval,newval){ +if(((!((this$ == null))) && (!((this$.cljs$core$IWatchable$_notify_watches$arity$3 == null))))){ +return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$,oldval,newval); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._notify_watches[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(this$,oldval,newval) : m__4231__auto__.call(null,this$,oldval,newval)); +} else { +var m__4231__auto____$1 = (cljs.core._notify_watches["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(this$,oldval,newval) : m__4231__auto____$1.call(null,this$,oldval,newval)); +} else { +throw cljs.core.missing_protocol("IWatchable.-notify-watches",this$); +} +} +} +}); + +/** + * Adds a watcher function f to this. Keys must be unique per reference, + * and can be used to remove the watch with -remove-watch. + */ +cljs.core._add_watch = (function cljs$core$_add_watch(this$,key,f){ +if(((!((this$ == null))) && (!((this$.cljs$core$IWatchable$_add_watch$arity$3 == null))))){ +return this$.cljs$core$IWatchable$_add_watch$arity$3(this$,key,f); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._add_watch[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(this$,key,f) : m__4231__auto__.call(null,this$,key,f)); +} else { +var m__4231__auto____$1 = (cljs.core._add_watch["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(this$,key,f) : m__4231__auto____$1.call(null,this$,key,f)); +} else { +throw cljs.core.missing_protocol("IWatchable.-add-watch",this$); +} +} +} +}); + +/** + * Removes watcher that corresponds to key from this. + */ +cljs.core._remove_watch = (function cljs$core$_remove_watch(this$,key){ +if(((!((this$ == null))) && (!((this$.cljs$core$IWatchable$_remove_watch$arity$2 == null))))){ +return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$,key); +} else { +var x__4230__auto__ = (((this$ == null))?null:this$); +var m__4231__auto__ = (cljs.core._remove_watch[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(this$,key) : m__4231__auto__.call(null,this$,key)); +} else { +var m__4231__auto____$1 = (cljs.core._remove_watch["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(this$,key) : m__4231__auto____$1.call(null,this$,key)); +} else { +throw cljs.core.missing_protocol("IWatchable.-remove-watch",this$); +} +} +} +}); + + +/** + * Protocol for collections which can transformed to transients. + * @interface + */ +cljs.core.IEditableCollection = function(){}; + +/** + * Returns a new, transient version of the collection, in constant time. + */ +cljs.core._as_transient = (function cljs$core$_as_transient(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IEditableCollection$_as_transient$arity$1 == null))))){ +return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._as_transient[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._as_transient["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IEditableCollection.-as-transient",coll); +} +} +} +}); + + +/** + * Protocol for adding basic functionality to transient collections. + * @interface + */ +cljs.core.ITransientCollection = function(){}; + +/** + * Adds value val to tcoll and returns tcoll. + */ +cljs.core._conj_BANG_ = (function cljs$core$_conj_BANG_(tcoll,val){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2 == null))))){ +return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll,val); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._conj_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,val) : m__4231__auto__.call(null,tcoll,val)); +} else { +var m__4231__auto____$1 = (cljs.core._conj_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(tcoll,val) : m__4231__auto____$1.call(null,tcoll,val)); +} else { +throw cljs.core.missing_protocol("ITransientCollection.-conj!",tcoll); +} +} +} +}); + +/** + * Creates a persistent data structure from tcoll and returns it. + */ +cljs.core._persistent_BANG_ = (function cljs$core$_persistent_BANG_(tcoll){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 == null))))){ +return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._persistent_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(tcoll) : m__4231__auto__.call(null,tcoll)); +} else { +var m__4231__auto____$1 = (cljs.core._persistent_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(tcoll) : m__4231__auto____$1.call(null,tcoll)); +} else { +throw cljs.core.missing_protocol("ITransientCollection.-persistent!",tcoll); +} +} +} +}); + + +/** + * Protocol for adding associativity to transient collections. + * @interface + */ +cljs.core.ITransientAssociative = function(){}; + +/** + * Returns a new transient collection of tcoll with a mapping from key to + * val added to it. + */ +cljs.core._assoc_BANG_ = (function cljs$core$_assoc_BANG_(tcoll,key,val){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 == null))))){ +return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll,key,val); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._assoc_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(tcoll,key,val) : m__4231__auto__.call(null,tcoll,key,val)); +} else { +var m__4231__auto____$1 = (cljs.core._assoc_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(tcoll,key,val) : m__4231__auto____$1.call(null,tcoll,key,val)); +} else { +throw cljs.core.missing_protocol("ITransientAssociative.-assoc!",tcoll); +} +} +} +}); + + +/** + * Protocol for adding mapping functionality to transient collections. + * @interface + */ +cljs.core.ITransientMap = function(){}; + +/** + * Returns a new transient collection of tcoll without the mapping for key. + */ +cljs.core._dissoc_BANG_ = (function cljs$core$_dissoc_BANG_(tcoll,key){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 == null))))){ +return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll,key); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._dissoc_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,key) : m__4231__auto__.call(null,tcoll,key)); +} else { +var m__4231__auto____$1 = (cljs.core._dissoc_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(tcoll,key) : m__4231__auto____$1.call(null,tcoll,key)); +} else { +throw cljs.core.missing_protocol("ITransientMap.-dissoc!",tcoll); +} +} +} +}); + + +/** + * Protocol for adding vector functionality to transient collections. + * @interface + */ +cljs.core.ITransientVector = function(){}; + +/** + * Returns tcoll with value val added at position n. + */ +cljs.core._assoc_n_BANG_ = (function cljs$core$_assoc_n_BANG_(tcoll,n,val){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 == null))))){ +return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll,n,val); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._assoc_n_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(tcoll,n,val) : m__4231__auto__.call(null,tcoll,n,val)); +} else { +var m__4231__auto____$1 = (cljs.core._assoc_n_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(tcoll,n,val) : m__4231__auto____$1.call(null,tcoll,n,val)); +} else { +throw cljs.core.missing_protocol("ITransientVector.-assoc-n!",tcoll); +} +} +} +}); + +/** + * Returns tcoll with the last item removed from it. + */ +cljs.core._pop_BANG_ = (function cljs$core$_pop_BANG_(tcoll){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1 == null))))){ +return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._pop_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(tcoll) : m__4231__auto__.call(null,tcoll)); +} else { +var m__4231__auto____$1 = (cljs.core._pop_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(tcoll) : m__4231__auto____$1.call(null,tcoll)); +} else { +throw cljs.core.missing_protocol("ITransientVector.-pop!",tcoll); +} +} +} +}); + + +/** + * Protocol for adding set functionality to a transient collection. + * @interface + */ +cljs.core.ITransientSet = function(){}; + +/** + * Returns tcoll without v. + */ +cljs.core._disjoin_BANG_ = (function cljs$core$_disjoin_BANG_(tcoll,v){ +if(((!((tcoll == null))) && (!((tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2 == null))))){ +return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll,v); +} else { +var x__4230__auto__ = (((tcoll == null))?null:tcoll); +var m__4231__auto__ = (cljs.core._disjoin_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(tcoll,v) : m__4231__auto__.call(null,tcoll,v)); +} else { +var m__4231__auto____$1 = (cljs.core._disjoin_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(tcoll,v) : m__4231__auto____$1.call(null,tcoll,v)); +} else { +throw cljs.core.missing_protocol("ITransientSet.-disjoin!",tcoll); +} +} +} +}); + + +/** + * Protocol for values that can be compared. + * @interface + */ +cljs.core.IComparable = function(){}; + +/** + * Returns a negative number, zero, or a positive number when x is logically + * 'less than', 'equal to', or 'greater than' y. + */ +cljs.core._compare = (function cljs$core$_compare(x,y){ +if(((!((x == null))) && (!((x.cljs$core$IComparable$_compare$arity$2 == null))))){ +return x.cljs$core$IComparable$_compare$arity$2(x,y); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._compare[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(x,y) : m__4231__auto__.call(null,x,y)); +} else { +var m__4231__auto____$1 = (cljs.core._compare["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(x,y) : m__4231__auto____$1.call(null,x,y)); +} else { +throw cljs.core.missing_protocol("IComparable.-compare",x); +} +} +} +}); + + +/** + * Protocol for accessing the items of a chunk. + * @interface + */ +cljs.core.IChunk = function(){}; + +/** + * Return a new chunk of coll with the first item removed. + */ +cljs.core._drop_first = (function cljs$core$_drop_first(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IChunk$_drop_first$arity$1 == null))))){ +return coll.cljs$core$IChunk$_drop_first$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._drop_first[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._drop_first["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IChunk.-drop-first",coll); +} +} +} +}); + + +/** + * Protocol for accessing a collection as sequential chunks. + * @interface + */ +cljs.core.IChunkedSeq = function(){}; + +/** + * Returns the first chunk in coll. + */ +cljs.core._chunked_first = (function cljs$core$_chunked_first(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IChunkedSeq$_chunked_first$arity$1 == null))))){ +return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._chunked_first[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._chunked_first["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IChunkedSeq.-chunked-first",coll); +} +} +} +}); + +/** + * Return a new collection of coll with the first chunk removed. + */ +cljs.core._chunked_rest = (function cljs$core$_chunked_rest(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1 == null))))){ +return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._chunked_rest[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._chunked_rest["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IChunkedSeq.-chunked-rest",coll); +} +} +} +}); + + +/** + * Protocol for accessing the chunks of a collection. + * @interface + */ +cljs.core.IChunkedNext = function(){}; + +/** + * Returns a new collection of coll without the first chunk. + */ +cljs.core._chunked_next = (function cljs$core$_chunked_next(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IChunkedNext$_chunked_next$arity$1 == null))))){ +return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._chunked_next[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._chunked_next["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IChunkedNext.-chunked-next",coll); +} +} +} +}); + + +/** + * Protocol for adding a name. + * @interface + */ +cljs.core.INamed = function(){}; + +/** + * Returns the name String of x. + */ +cljs.core._name = (function cljs$core$_name(x){ +if(((!((x == null))) && (!((x.cljs$core$INamed$_name$arity$1 == null))))){ +return x.cljs$core$INamed$_name$arity$1(x); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._name[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto__.call(null,x)); +} else { +var m__4231__auto____$1 = (cljs.core._name["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto____$1.call(null,x)); +} else { +throw cljs.core.missing_protocol("INamed.-name",x); +} +} +} +}); + +/** + * Returns the namespace String of x. + */ +cljs.core._namespace = (function cljs$core$_namespace(x){ +if(((!((x == null))) && (!((x.cljs$core$INamed$_namespace$arity$1 == null))))){ +return x.cljs$core$INamed$_namespace$arity$1(x); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._namespace[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto__.call(null,x)); +} else { +var m__4231__auto____$1 = (cljs.core._namespace["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto____$1.call(null,x)); +} else { +throw cljs.core.missing_protocol("INamed.-namespace",x); +} +} +} +}); + + +/** + * Marker protocol indicating an atom. + * @interface + */ +cljs.core.IAtom = function(){}; + + +/** + * Protocol for adding resetting functionality. + * @interface + */ +cljs.core.IReset = function(){}; + +/** + * Sets the value of o to new-value. + */ +cljs.core._reset_BANG_ = (function cljs$core$_reset_BANG_(o,new_value){ +if(((!((o == null))) && (!((o.cljs$core$IReset$_reset_BANG_$arity$2 == null))))){ +return o.cljs$core$IReset$_reset_BANG_$arity$2(o,new_value); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._reset_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__4231__auto__.call(null,o,new_value)); +} else { +var m__4231__auto____$1 = (cljs.core._reset_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__4231__auto____$1.call(null,o,new_value)); +} else { +throw cljs.core.missing_protocol("IReset.-reset!",o); +} +} +} +}); + + +/** + * Protocol for adding swapping functionality. + * @interface + */ +cljs.core.ISwap = function(){}; + +/** + * Swaps the value of o to be (apply f current-value-of-atom args). + */ +cljs.core._swap_BANG_ = (function cljs$core$_swap_BANG_(var_args){ +var G__629 = arguments.length; +switch (G__629) { +case 2: +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (o,f){ +if(((!((o == null))) && (!((o.cljs$core$ISwap$_swap_BANG_$arity$2 == null))))){ +return o.cljs$core$ISwap$_swap_BANG_$arity$2(o,f); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(o,f) : m__4231__auto__.call(null,o,f)); +} else { +var m__4231__auto____$1 = (cljs.core._swap_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(o,f) : m__4231__auto____$1.call(null,o,f)); +} else { +throw cljs.core.missing_protocol("ISwap.-swap!",o); +} +} +} +}); + +cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3 = (function (o,f,a){ +if(((!((o == null))) && (!((o.cljs$core$ISwap$_swap_BANG_$arity$3 == null))))){ +return o.cljs$core$ISwap$_swap_BANG_$arity$3(o,f,a); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(o,f,a) : m__4231__auto__.call(null,o,f,a)); +} else { +var m__4231__auto____$1 = (cljs.core._swap_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(o,f,a) : m__4231__auto____$1.call(null,o,f,a)); +} else { +throw cljs.core.missing_protocol("ISwap.-swap!",o); +} +} +} +}); + +cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4 = (function (o,f,a,b){ +if(((!((o == null))) && (!((o.cljs$core$ISwap$_swap_BANG_$arity$4 == null))))){ +return o.cljs$core$ISwap$_swap_BANG_$arity$4(o,f,a,b); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$4 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$4(o,f,a,b) : m__4231__auto__.call(null,o,f,a,b)); +} else { +var m__4231__auto____$1 = (cljs.core._swap_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$4 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$4(o,f,a,b) : m__4231__auto____$1.call(null,o,f,a,b)); +} else { +throw cljs.core.missing_protocol("ISwap.-swap!",o); +} +} +} +}); + +cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5 = (function (o,f,a,b,xs){ +if(((!((o == null))) && (!((o.cljs$core$ISwap$_swap_BANG_$arity$5 == null))))){ +return o.cljs$core$ISwap$_swap_BANG_$arity$5(o,f,a,b,xs); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$5 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$5(o,f,a,b,xs) : m__4231__auto__.call(null,o,f,a,b,xs)); +} else { +var m__4231__auto____$1 = (cljs.core._swap_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$5 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$5(o,f,a,b,xs) : m__4231__auto____$1.call(null,o,f,a,b,xs)); +} else { +throw cljs.core.missing_protocol("ISwap.-swap!",o); +} +} +} +}); + +cljs.core._swap_BANG_.cljs$lang$maxFixedArity = 5; + + + +/** + * Protocol for adding volatile functionality. + * @interface + */ +cljs.core.IVolatile = function(){}; + +/** + * Sets the value of volatile o to new-value without regard for the + * current value. Returns new-value. + */ +cljs.core._vreset_BANG_ = (function cljs$core$_vreset_BANG_(o,new_value){ +if(((!((o == null))) && (!((o.cljs$core$IVolatile$_vreset_BANG_$arity$2 == null))))){ +return o.cljs$core$IVolatile$_vreset_BANG_$arity$2(o,new_value); +} else { +var x__4230__auto__ = (((o == null))?null:o); +var m__4231__auto__ = (cljs.core._vreset_BANG_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__4231__auto__.call(null,o,new_value)); +} else { +var m__4231__auto____$1 = (cljs.core._vreset_BANG_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(o,new_value) : m__4231__auto____$1.call(null,o,new_value)); +} else { +throw cljs.core.missing_protocol("IVolatile.-vreset!",o); +} +} +} +}); + + +/** + * Protocol for iterating over a collection. + * @interface + */ +cljs.core.IIterable = function(){}; + +/** + * Returns an iterator for coll. + */ +cljs.core._iterator = (function cljs$core$_iterator(coll){ +if(((!((coll == null))) && (!((coll.cljs$core$IIterable$_iterator$arity$1 == null))))){ +return coll.cljs$core$IIterable$_iterator$arity$1(coll); +} else { +var x__4230__auto__ = (((coll == null))?null:coll); +var m__4231__auto__ = (cljs.core._iterator[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto__.call(null,coll)); +} else { +var m__4231__auto____$1 = (cljs.core._iterator["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(coll) : m__4231__auto____$1.call(null,coll)); +} else { +throw cljs.core.missing_protocol("IIterable.-iterator",coll); +} +} +} +}); + + +/** +* @constructor + * @implements {cljs.core.IWriter} +*/ +cljs.core.StringBufferWriter = (function (sb){ +this.sb = sb; +this.cljs$lang$protocol_mask$partition0$ = 1073741824; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_write$arity$2 = (function (_,s){ +var self__ = this; +var ___$1 = this; +return self__.sb.append(s); +}); + +cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_flush$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return null; +}); + +cljs.core.StringBufferWriter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$sb], null); +}); + +cljs.core.StringBufferWriter.cljs$lang$type = true; + +cljs.core.StringBufferWriter.cljs$lang$ctorStr = "cljs.core/StringBufferWriter"; + +cljs.core.StringBufferWriter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/StringBufferWriter"); +}); + +/** + * Positional factory function for cljs.core/StringBufferWriter. + */ +cljs.core.__GT_StringBufferWriter = (function cljs$core$__GT_StringBufferWriter(sb){ +return (new cljs.core.StringBufferWriter(sb)); +}); + +/** + * Support so that collections can implement toString without + * loading all the printing machinery. + */ +cljs.core.pr_str_STAR_ = (function cljs$core$pr_str_STAR_(obj){ +var sb = (new goog.string.StringBuffer()); +var writer = (new cljs.core.StringBufferWriter(sb)); +obj.cljs$core$IPrintWithWriter$_pr_writer$arity$3(null,writer,cljs.core.pr_opts()); + +writer.cljs$core$IWriter$_flush$arity$1(null); + +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)].join(''); +}); +cljs.core.int_rotate_left = (function cljs$core$int_rotate_left(x,n){ +return ((x << n) | (x >>> (- n))); +}); +if((((typeof Math !== 'undefined') && (typeof Math.imul !== 'undefined')) && (!((Math.imul((4294967295),(5)) === (0)))))){ +cljs.core.imul = (function cljs$core$imul(a,b){ +return Math.imul(a,b); +}); +} else { +cljs.core.imul = (function cljs$core$imul(a,b){ +var ah = ((a >>> (16)) & (65535)); +var al = (a & (65535)); +var bh = ((b >>> (16)) & (65535)); +var bl = (b & (65535)); +return (((al * bl) + ((((ah * bl) + (al * bh)) << (16)) >>> (0))) | (0)); +}); +} +cljs.core.m3_seed = (0); +cljs.core.m3_C1 = ((3432918353) | (0)); +cljs.core.m3_C2 = ((461845907) | (0)); +cljs.core.m3_mix_K1 = (function cljs$core$m3_mix_K1(k1){ +return cljs.core.imul(cljs.core.int_rotate_left(cljs.core.imul((k1 | (0)),cljs.core.m3_C1),(15)),cljs.core.m3_C2); +}); +cljs.core.m3_mix_H1 = (function cljs$core$m3_mix_H1(h1,k1){ +return ((cljs.core.imul(cljs.core.int_rotate_left(((h1 | (0)) ^ (k1 | (0))),(13)),(5)) + ((3864292196) | (0))) | (0)); +}); +cljs.core.m3_fmix = (function cljs$core$m3_fmix(h1,len){ +var h1__$1 = (h1 | (0)); +var h1__$2 = (h1__$1 ^ len); +var h1__$3 = (h1__$2 ^ (h1__$2 >>> (16))); +var h1__$4 = cljs.core.imul(h1__$3,((2246822507) | (0))); +var h1__$5 = (h1__$4 ^ (h1__$4 >>> (13))); +var h1__$6 = cljs.core.imul(h1__$5,((3266489909) | (0))); +return (h1__$6 ^ (h1__$6 >>> (16))); +}); +cljs.core.m3_hash_int = (function cljs$core$m3_hash_int(in$){ +if((in$ === (0))){ +return in$; +} else { +var k1 = cljs.core.m3_mix_K1(in$); +var h1 = cljs.core.m3_mix_H1(cljs.core.m3_seed,k1); +return cljs.core.m3_fmix(h1,(4)); +} +}); +cljs.core.m3_hash_unencoded_chars = (function cljs$core$m3_hash_unencoded_chars(in$){ +var h1 = (function (){var i = (1); +var h1 = cljs.core.m3_seed; +while(true){ +if((i < in$.length)){ +var G__631 = (i + (2)); +var G__632 = cljs.core.m3_mix_H1(h1,cljs.core.m3_mix_K1((in$.charCodeAt((i - (1))) | (in$.charCodeAt(i) << (16))))); +i = G__631; +h1 = G__632; +continue; +} else { +return h1; +} +break; +} +})(); +var h1__$1 = ((((in$.length & (1)) === (1)))?(h1 ^ cljs.core.m3_mix_K1(in$.charCodeAt((in$.length - (1))))):h1); +return cljs.core.m3_fmix(h1__$1,cljs.core.imul((2),in$.length)); +}); + + + +cljs.core.string_hash_cache = {}; +cljs.core.string_hash_cache_count = (0); +cljs.core.hash_string_STAR_ = (function cljs$core$hash_string_STAR_(s){ +if(!((s == null))){ +var len = s.length; +if((len > (0))){ +var i = (0); +var hash = (0); +while(true){ +if((i < len)){ +var G__635 = (i + (1)); +var G__636 = (cljs.core.imul((31),hash) + s.charCodeAt(i)); +i = G__635; +hash = G__636; +continue; +} else { +return hash; +} +break; +} +} else { +return (0); +} +} else { +return (0); +} +}); +cljs.core.add_to_string_hash_cache = (function cljs$core$add_to_string_hash_cache(k){ +var h = cljs.core.hash_string_STAR_(k); +goog.object.set(cljs.core.string_hash_cache,k,h); + +cljs.core.string_hash_cache_count = (cljs.core.string_hash_cache_count + (1)); + +return h; +}); +cljs.core.hash_string = (function cljs$core$hash_string(k){ +if((cljs.core.string_hash_cache_count > (255))){ +cljs.core.string_hash_cache = {}; + +cljs.core.string_hash_cache_count = (0); +} else { +} + +if((k == null)){ +return (0); +} else { +var h = (cljs.core.string_hash_cache[k]); +if(typeof h === 'number'){ +return h; +} else { +return cljs.core.add_to_string_hash_cache(k); +} +} +}); +/** + * Returns the hash code of its argument. Note this is the hash code + * consistent with =. + */ +cljs.core.hash = (function cljs$core$hash(o){ +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (4194304))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IHash$))))?true:false):false)){ +return (o.cljs$core$IHash$_hash$arity$1(null) ^ (0)); +} else { +if(typeof o === 'number'){ +if(cljs.core.truth_(isFinite(o))){ +return (Math.floor(o) % (2147483647)); +} else { +var G__640 = o; +switch (G__640) { +case Infinity: +return (2146435072); + +break; +case -Infinity: +return (-1048576); + +break; +default: +return (2146959360); + +} +} +} else { +if(o === true){ +return (1231); +} else { +if(o === false){ +return (1237); +} else { +if(typeof o === 'string'){ +return cljs.core.m3_hash_int(cljs.core.hash_string(o)); +} else { +if((o instanceof Date)){ +return (o.valueOf() ^ (0)); +} else { +if((o == null)){ +return (0); +} else { +return (cljs.core._hash(o) ^ (0)); + +} +} +} +} +} +} +} +}); +cljs.core.hash_combine = (function cljs$core$hash_combine(seed,hash){ +return (seed ^ (((hash + (2654435769)) + (seed << (6))) + (seed >> (2)))); +}); +/** + * Evaluates x and tests if it is an instance of the type + * c. Returns true or false + */ +cljs.core.instance_QMARK_ = (function cljs$core$instance_QMARK_(c,x){ +return (x instanceof c); +}); +/** + * Return true if x is a Symbol + */ +cljs.core.symbol_QMARK_ = (function cljs$core$symbol_QMARK_(x){ +return (x instanceof cljs.core.Symbol); +}); +cljs.core.hash_symbol = (function cljs$core$hash_symbol(sym){ +return cljs.core.hash_combine(cljs.core.m3_hash_unencoded_chars(sym.name),cljs.core.hash_string(sym.ns)); +}); +cljs.core.compare_symbols = (function cljs$core$compare_symbols(a,b){ +if((a.str === b.str)){ +return (0); +} else { +if(cljs.core.truth_((function (){var and__3925__auto__ = cljs.core.not(a.ns); +if(and__3925__auto__){ +return b.ns; +} else { +return and__3925__auto__; +} +})())){ +return (-1); +} else { +if(cljs.core.truth_(a.ns)){ +if(cljs.core.not(b.ns)){ +return (1); +} else { +var nsc = (function (){var G__642 = a.ns; +var G__643 = b.ns; +return goog.array.defaultCompare(G__642,G__643); +})(); +if(((0) === nsc)){ +var G__644 = a.name; +var G__645 = b.name; +return goog.array.defaultCompare(G__644,G__645); +} else { +return nsc; +} +} +} else { +var G__646 = a.name; +var G__647 = b.name; +return goog.array.defaultCompare(G__646,G__647); + +} +} +} +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.INamed} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IPrintWithWriter} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.Symbol = (function (ns,name,str,_hash,_meta){ +this.ns = ns; +this.name = name; +this.str = str; +this._hash = _hash; +this._meta = _meta; +this.cljs$lang$protocol_mask$partition0$ = 2154168321; +this.cljs$lang$protocol_mask$partition1$ = 4096; +}); +cljs.core.Symbol.prototype.toString = (function (){ +var self__ = this; +var _ = this; +return self__.str; +}); + +cljs.core.Symbol.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Symbol.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (_,other){ +var self__ = this; +var ___$1 = this; +if((other instanceof cljs.core.Symbol)){ +return (self__.str === other.str); +} else { +return false; +} +}); + +cljs.core.Symbol.prototype.call = (function() { +var G__649 = null; +var G__649__2 = (function (self__,coll){ +var self__ = this; +var self____$1 = this; +var sym = self____$1; +return cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,sym); +}); +var G__649__3 = (function (self__,coll,not_found){ +var self__ = this; +var self____$1 = this; +var sym = self____$1; +return cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,sym,not_found); +}); +G__649 = function(self__,coll,not_found){ +switch(arguments.length){ +case 2: +return G__649__2.call(this,self__,coll); +case 3: +return G__649__3.call(this,self__,coll,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__649.cljs$core$IFn$_invoke$arity$2 = G__649__2; +G__649.cljs$core$IFn$_invoke$arity$3 = G__649__3; +return G__649; +})() +; + +cljs.core.Symbol.prototype.apply = (function (self__,args648){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args648))); +}); + +cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +var self__ = this; +var sym = this; +return cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,sym); +}); + +cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$2 = (function (coll,not_found){ +var self__ = this; +var sym = this; +return cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,sym,not_found); +}); + +cljs.core.Symbol.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__._meta; +}); + +cljs.core.Symbol.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (_,new_meta){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.Symbol(self__.ns,self__.name,self__.str,self__._hash,new_meta)); +}); + +cljs.core.Symbol.prototype.cljs$core$IHash$_hash$arity$1 = (function (sym){ +var self__ = this; +var sym__$1 = this; +var h__4048__auto__ = self__._hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_symbol(sym__$1); +self__._hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.Symbol.prototype.cljs$core$INamed$_name$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.name; +}); + +cljs.core.Symbol.prototype.cljs$core$INamed$_namespace$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.ns; +}); + +cljs.core.Symbol.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (o,writer,_){ +var self__ = this; +var o__$1 = this; +return cljs.core._write(writer,self__.str); +}); + +cljs.core.Symbol.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$ns,cljs.core.cst$sym$name,cljs.core.cst$sym$str,cljs.core.with_meta(cljs.core.cst$sym$_hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$_meta], null); +}); + +cljs.core.Symbol.cljs$lang$type = true; + +cljs.core.Symbol.cljs$lang$ctorStr = "cljs.core/Symbol"; + +cljs.core.Symbol.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Symbol"); +}); + +/** + * Positional factory function for cljs.core/Symbol. + */ +cljs.core.__GT_Symbol = (function cljs$core$__GT_Symbol(ns,name,str,_hash,_meta){ +return (new cljs.core.Symbol(ns,name,str,_hash,_meta)); +}); + +/** + * Returns a Symbol with the given namespace and name. + */ +cljs.core.symbol = (function cljs$core$symbol(var_args){ +var G__651 = arguments.length; +switch (G__651) { +case 1: +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.symbol.cljs$core$IFn$_invoke$arity$1 = (function (name){ +if((name instanceof cljs.core.Symbol)){ +return name; +} else { +var idx = name.indexOf("/"); +if((idx < (1))){ +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(null,name); +} else { +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(name.substring((0),idx),name.substring((idx + (1)),name.length)); +} +} +}); + +cljs.core.symbol.cljs$core$IFn$_invoke$arity$2 = (function (ns,name){ +var sym_str = ((!((ns == null)))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns),"/",cljs.core.str.cljs$core$IFn$_invoke$arity$1(name)].join(''):name); +return (new cljs.core.Symbol(ns,name,sym_str,null,null)); +}); + +cljs.core.symbol.cljs$lang$maxFixedArity = 2; + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.Fn} + * @implements {cljs.core.IDeref} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.Var = (function (val,sym,_meta){ +this.val = val; +this.sym = sym; +this._meta = _meta; +this.cljs$lang$protocol_mask$partition0$ = 6717441; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.Var.prototype.isMacro = (function (){ +var self__ = this; +var _ = this; +return (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)).cljs$lang$macro; +}); + +cljs.core.Var.prototype.toString = (function (){ +var self__ = this; +var _ = this; +return ["#'",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.sym)].join(''); +}); + +cljs.core.Var.prototype.cljs$core$IDeref$_deref$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +}); + +cljs.core.Var.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__._meta; +}); + +cljs.core.Var.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (_,new_meta){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.Var(self__.val,self__.sym,new_meta)); +}); + +cljs.core.Var.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (this$,other){ +var self__ = this; +var this$__$1 = this; +if((other instanceof cljs.core.Var)){ +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this$__$1.sym,other.sym); +} else { +return false; +} +}); + +cljs.core.Var.prototype.cljs$core$IHash$_hash$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return cljs.core.hash_symbol(self__.sym); +}); + +cljs.core.Var.prototype.cljs$core$Fn$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Var.prototype.call = (function() { +var G__696 = null; +var G__696__1 = (function (self__){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__654 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__654.cljs$core$IFn$_invoke$arity$0 ? fexpr__654.cljs$core$IFn$_invoke$arity$0() : fexpr__654.call(null)); +}); +var G__696__2 = (function (self__,a){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__655 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__655.cljs$core$IFn$_invoke$arity$1 ? fexpr__655.cljs$core$IFn$_invoke$arity$1(a) : fexpr__655.call(null,a)); +}); +var G__696__3 = (function (self__,a,b){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__656 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__656.cljs$core$IFn$_invoke$arity$2 ? fexpr__656.cljs$core$IFn$_invoke$arity$2(a,b) : fexpr__656.call(null,a,b)); +}); +var G__696__4 = (function (self__,a,b,c){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__657 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__657.cljs$core$IFn$_invoke$arity$3 ? fexpr__657.cljs$core$IFn$_invoke$arity$3(a,b,c) : fexpr__657.call(null,a,b,c)); +}); +var G__696__5 = (function (self__,a,b,c,d){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__658 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__658.cljs$core$IFn$_invoke$arity$4 ? fexpr__658.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : fexpr__658.call(null,a,b,c,d)); +}); +var G__696__6 = (function (self__,a,b,c,d,e){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__659 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__659.cljs$core$IFn$_invoke$arity$5 ? fexpr__659.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : fexpr__659.call(null,a,b,c,d,e)); +}); +var G__696__7 = (function (self__,a,b,c,d,e,f){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__660 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__660.cljs$core$IFn$_invoke$arity$6 ? fexpr__660.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : fexpr__660.call(null,a,b,c,d,e,f)); +}); +var G__696__8 = (function (self__,a,b,c,d,e,f,g){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__661 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__661.cljs$core$IFn$_invoke$arity$7 ? fexpr__661.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : fexpr__661.call(null,a,b,c,d,e,f,g)); +}); +var G__696__9 = (function (self__,a,b,c,d,e,f,g,h){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__662 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__662.cljs$core$IFn$_invoke$arity$8 ? fexpr__662.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : fexpr__662.call(null,a,b,c,d,e,f,g,h)); +}); +var G__696__10 = (function (self__,a,b,c,d,e,f,g,h,i){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__663 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__663.cljs$core$IFn$_invoke$arity$9 ? fexpr__663.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : fexpr__663.call(null,a,b,c,d,e,f,g,h,i)); +}); +var G__696__11 = (function (self__,a,b,c,d,e,f,g,h,i,j){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__664 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__664.cljs$core$IFn$_invoke$arity$10 ? fexpr__664.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : fexpr__664.call(null,a,b,c,d,e,f,g,h,i,j)); +}); +var G__696__12 = (function (self__,a,b,c,d,e,f,g,h,i,j,k){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__665 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__665.cljs$core$IFn$_invoke$arity$11 ? fexpr__665.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : fexpr__665.call(null,a,b,c,d,e,f,g,h,i,j,k)); +}); +var G__696__13 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__666 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__666.cljs$core$IFn$_invoke$arity$12 ? fexpr__666.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : fexpr__666.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +}); +var G__696__14 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__667 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__667.cljs$core$IFn$_invoke$arity$13 ? fexpr__667.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : fexpr__667.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +}); +var G__696__15 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__668 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__668.cljs$core$IFn$_invoke$arity$14 ? fexpr__668.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : fexpr__668.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +}); +var G__696__16 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__669 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__669.cljs$core$IFn$_invoke$arity$15 ? fexpr__669.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : fexpr__669.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +}); +var G__696__17 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__670 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__670.cljs$core$IFn$_invoke$arity$16 ? fexpr__670.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : fexpr__670.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +}); +var G__696__18 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__671 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__671.cljs$core$IFn$_invoke$arity$17 ? fexpr__671.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : fexpr__671.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +}); +var G__696__19 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__672 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__672.cljs$core$IFn$_invoke$arity$18 ? fexpr__672.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : fexpr__672.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +}); +var G__696__20 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__673 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__673.cljs$core$IFn$_invoke$arity$19 ? fexpr__673.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : fexpr__673.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +}); +var G__696__21 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +var fexpr__674 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__674.cljs$core$IFn$_invoke$arity$20 ? fexpr__674.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : fexpr__674.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +}); +var G__696__22 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic((self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)),a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +}); +G__696 = function(self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +switch(arguments.length){ +case 1: +return G__696__1.call(this,self__); +case 2: +return G__696__2.call(this,self__,a); +case 3: +return G__696__3.call(this,self__,a,b); +case 4: +return G__696__4.call(this,self__,a,b,c); +case 5: +return G__696__5.call(this,self__,a,b,c,d); +case 6: +return G__696__6.call(this,self__,a,b,c,d,e); +case 7: +return G__696__7.call(this,self__,a,b,c,d,e,f); +case 8: +return G__696__8.call(this,self__,a,b,c,d,e,f,g); +case 9: +return G__696__9.call(this,self__,a,b,c,d,e,f,g,h); +case 10: +return G__696__10.call(this,self__,a,b,c,d,e,f,g,h,i); +case 11: +return G__696__11.call(this,self__,a,b,c,d,e,f,g,h,i,j); +case 12: +return G__696__12.call(this,self__,a,b,c,d,e,f,g,h,i,j,k); +case 13: +return G__696__13.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l); +case 14: +return G__696__14.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m); +case 15: +return G__696__15.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n); +case 16: +return G__696__16.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o); +case 17: +return G__696__17.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); +case 18: +return G__696__18.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q); +case 19: +return G__696__19.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r); +case 20: +return G__696__20.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s); +case 21: +return G__696__21.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t); +case 22: +return G__696__22.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__696.cljs$core$IFn$_invoke$arity$1 = G__696__1; +G__696.cljs$core$IFn$_invoke$arity$2 = G__696__2; +G__696.cljs$core$IFn$_invoke$arity$3 = G__696__3; +G__696.cljs$core$IFn$_invoke$arity$4 = G__696__4; +G__696.cljs$core$IFn$_invoke$arity$5 = G__696__5; +G__696.cljs$core$IFn$_invoke$arity$6 = G__696__6; +G__696.cljs$core$IFn$_invoke$arity$7 = G__696__7; +G__696.cljs$core$IFn$_invoke$arity$8 = G__696__8; +G__696.cljs$core$IFn$_invoke$arity$9 = G__696__9; +G__696.cljs$core$IFn$_invoke$arity$10 = G__696__10; +G__696.cljs$core$IFn$_invoke$arity$11 = G__696__11; +G__696.cljs$core$IFn$_invoke$arity$12 = G__696__12; +G__696.cljs$core$IFn$_invoke$arity$13 = G__696__13; +G__696.cljs$core$IFn$_invoke$arity$14 = G__696__14; +G__696.cljs$core$IFn$_invoke$arity$15 = G__696__15; +G__696.cljs$core$IFn$_invoke$arity$16 = G__696__16; +G__696.cljs$core$IFn$_invoke$arity$17 = G__696__17; +G__696.cljs$core$IFn$_invoke$arity$18 = G__696__18; +G__696.cljs$core$IFn$_invoke$arity$19 = G__696__19; +G__696.cljs$core$IFn$_invoke$arity$20 = G__696__20; +G__696.cljs$core$IFn$_invoke$arity$21 = G__696__21; +G__696.cljs$core$IFn$_invoke$arity$22 = G__696__22; +return G__696; +})() +; + +cljs.core.Var.prototype.apply = (function (self__,args653){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args653))); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$0 = (function (){ +var self__ = this; +var _ = this; +var fexpr__675 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__675.cljs$core$IFn$_invoke$arity$0 ? fexpr__675.cljs$core$IFn$_invoke$arity$0() : fexpr__675.call(null)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$1 = (function (a){ +var self__ = this; +var _ = this; +var fexpr__676 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__676.cljs$core$IFn$_invoke$arity$1 ? fexpr__676.cljs$core$IFn$_invoke$arity$1(a) : fexpr__676.call(null,a)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$2 = (function (a,b){ +var self__ = this; +var _ = this; +var fexpr__677 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__677.cljs$core$IFn$_invoke$arity$2 ? fexpr__677.cljs$core$IFn$_invoke$arity$2(a,b) : fexpr__677.call(null,a,b)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$3 = (function (a,b,c){ +var self__ = this; +var _ = this; +var fexpr__678 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__678.cljs$core$IFn$_invoke$arity$3 ? fexpr__678.cljs$core$IFn$_invoke$arity$3(a,b,c) : fexpr__678.call(null,a,b,c)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$4 = (function (a,b,c,d){ +var self__ = this; +var _ = this; +var fexpr__679 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__679.cljs$core$IFn$_invoke$arity$4 ? fexpr__679.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : fexpr__679.call(null,a,b,c,d)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$5 = (function (a,b,c,d,e){ +var self__ = this; +var _ = this; +var fexpr__680 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__680.cljs$core$IFn$_invoke$arity$5 ? fexpr__680.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : fexpr__680.call(null,a,b,c,d,e)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$6 = (function (a,b,c,d,e,f){ +var self__ = this; +var _ = this; +var fexpr__681 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__681.cljs$core$IFn$_invoke$arity$6 ? fexpr__681.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : fexpr__681.call(null,a,b,c,d,e,f)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$7 = (function (a,b,c,d,e,f,g){ +var self__ = this; +var _ = this; +var fexpr__682 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__682.cljs$core$IFn$_invoke$arity$7 ? fexpr__682.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : fexpr__682.call(null,a,b,c,d,e,f,g)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$8 = (function (a,b,c,d,e,f,g,h){ +var self__ = this; +var _ = this; +var fexpr__683 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__683.cljs$core$IFn$_invoke$arity$8 ? fexpr__683.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : fexpr__683.call(null,a,b,c,d,e,f,g,h)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$9 = (function (a,b,c,d,e,f,g,h,i){ +var self__ = this; +var _ = this; +var fexpr__684 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__684.cljs$core$IFn$_invoke$arity$9 ? fexpr__684.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : fexpr__684.call(null,a,b,c,d,e,f,g,h,i)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$10 = (function (a,b,c,d,e,f,g,h,i,j){ +var self__ = this; +var _ = this; +var fexpr__685 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__685.cljs$core$IFn$_invoke$arity$10 ? fexpr__685.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : fexpr__685.call(null,a,b,c,d,e,f,g,h,i,j)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$11 = (function (a,b,c,d,e,f,g,h,i,j,k){ +var self__ = this; +var _ = this; +var fexpr__686 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__686.cljs$core$IFn$_invoke$arity$11 ? fexpr__686.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : fexpr__686.call(null,a,b,c,d,e,f,g,h,i,j,k)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$12 = (function (a,b,c,d,e,f,g,h,i,j,k,l){ +var self__ = this; +var _ = this; +var fexpr__687 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__687.cljs$core$IFn$_invoke$arity$12 ? fexpr__687.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : fexpr__687.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$13 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m){ +var self__ = this; +var _ = this; +var fexpr__688 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__688.cljs$core$IFn$_invoke$arity$13 ? fexpr__688.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : fexpr__688.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$14 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +var self__ = this; +var _ = this; +var fexpr__689 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__689.cljs$core$IFn$_invoke$arity$14 ? fexpr__689.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : fexpr__689.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$15 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +var self__ = this; +var _ = this; +var fexpr__690 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__690.cljs$core$IFn$_invoke$arity$15 ? fexpr__690.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : fexpr__690.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$16 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +var self__ = this; +var _ = this; +var fexpr__691 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__691.cljs$core$IFn$_invoke$arity$16 ? fexpr__691.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : fexpr__691.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$17 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +var self__ = this; +var _ = this; +var fexpr__692 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__692.cljs$core$IFn$_invoke$arity$17 ? fexpr__692.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : fexpr__692.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$18 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +var self__ = this; +var _ = this; +var fexpr__693 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__693.cljs$core$IFn$_invoke$arity$18 ? fexpr__693.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : fexpr__693.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$19 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +var self__ = this; +var _ = this; +var fexpr__694 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__694.cljs$core$IFn$_invoke$arity$19 ? fexpr__694.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : fexpr__694.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$20 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +var self__ = this; +var _ = this; +var fexpr__695 = (self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)); +return (fexpr__695.cljs$core$IFn$_invoke$arity$20 ? fexpr__695.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : fexpr__695.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +}); + +cljs.core.Var.prototype.cljs$core$IFn$_invoke$arity$21 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +var self__ = this; +var _ = this; +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic((self__.val.cljs$core$IFn$_invoke$arity$0 ? self__.val.cljs$core$IFn$_invoke$arity$0() : self__.val.call(null)),a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +}); + +cljs.core.Var.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$val,cljs.core.cst$sym$sym,cljs.core.cst$sym$_meta], null); +}); + +cljs.core.Var.cljs$lang$type = true; + +cljs.core.Var.cljs$lang$ctorStr = "cljs.core/Var"; + +cljs.core.Var.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Var"); +}); + +/** + * Positional factory function for cljs.core/Var. + */ +cljs.core.__GT_Var = (function cljs$core$__GT_Var(val,sym,_meta){ +return (new cljs.core.Var(val,sym,_meta)); +}); + +/** + * Returns true if v is of type cljs.core.Var + */ +cljs.core.var_QMARK_ = (function cljs$core$var_QMARK_(v){ +return (v instanceof cljs.core.Var); +}); + + +/** + * Return true if x implements IIterable protocol. + */ +cljs.core.iterable_QMARK_ = (function cljs$core$iterable_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition1$ & (131072))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IIterable$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition1$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IIterable,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IIterable,x); +} +}); +/** + * Clone the supplied value which must implement ICloneable. + */ +cljs.core.clone = (function cljs$core$clone(value){ +return cljs.core._clone(value); +}); +/** + * Return true if x implements ICloneable protocol. + */ +cljs.core.cloneable_QMARK_ = (function cljs$core$cloneable_QMARK_(value){ +if(!((value == null))){ +if((((value.cljs$lang$protocol_mask$partition1$ & (8192))) || ((cljs.core.PROTOCOL_SENTINEL === value.cljs$core$ICloneable$)))){ +return true; +} else { +if((!value.cljs$lang$protocol_mask$partition1$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ICloneable,value); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ICloneable,value); +} +}); +/** + * Returns a seq on the collection. If the collection is + * empty, returns nil. (seq nil) returns nil. seq also works on + * Strings. + */ +cljs.core.seq = (function cljs$core$seq(coll){ +if((coll == null)){ +return null; +} else { +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (8388608))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeqable$))))?true:false):false)){ +return coll.cljs$core$ISeqable$_seq$arity$1(null); +} else { +if(cljs.core.array_QMARK_(coll)){ +if((coll.length === (0))){ +return null; +} else { +return (new cljs.core.IndexedSeq(coll,(0),null)); +} +} else { +if(typeof coll === 'string'){ +if((coll.length === (0))){ +return null; +} else { +return (new cljs.core.IndexedSeq(coll,(0),null)); +} +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable,coll)){ +return cljs.core._seq(coll); +} else { +throw (new Error([cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll)," is not ISeqable"].join(''))); + +} +} +} +} +} +}); +/** + * Returns the first item in the collection. Calls seq on its + * argument. If coll is nil, returns nil. + */ +cljs.core.first = (function cljs$core$first(coll){ +if((coll == null)){ +return null; +} else { +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$))))?true:false):false)){ +return coll.cljs$core$ISeq$_first$arity$1(null); +} else { +var s = cljs.core.seq(coll); +if((s == null)){ +return null; +} else { +return cljs.core._first(s); +} +} +} +}); +/** + * Returns a possibly empty seq of the items after the first. Calls seq on its + * argument. + */ +cljs.core.rest = (function cljs$core$rest(coll){ +if(!((coll == null))){ +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$))))?true:false):false)){ +return coll.cljs$core$ISeq$_rest$arity$1(null); +} else { +var s = cljs.core.seq(coll); +if(s){ +return s.cljs$core$ISeq$_rest$arity$1(null); +} else { +return cljs.core.List.EMPTY; +} +} +} else { +return cljs.core.List.EMPTY; +} +}); +/** + * Returns a seq of the items after the first. Calls seq on its + * argument. If there are no more items, returns nil + */ +cljs.core.next = (function cljs$core$next(coll){ +if((coll == null)){ +return null; +} else { +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (128))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$INext$))))?true:false):false)){ +return coll.cljs$core$INext$_next$arity$1(null); +} else { +return cljs.core.seq(cljs.core.rest(coll)); +} +} +}); +/** + * Equality. Returns true if x equals y, false if not. Compares + * numbers and collections in a type-independent manner. Clojure's immutable data + * structures define -equiv (and thus =) as a value, not an identity, + * comparison. + */ +cljs.core._EQ_ = (function cljs$core$_EQ_(var_args){ +var G__707 = arguments.length; +switch (G__707) { +case 1: +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___709 = arguments.length; +var i__4519__auto___710 = (0); +while(true){ +if((i__4519__auto___710 < len__4518__auto___709)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___710])); + +var G__711 = (i__4519__auto___710 + (1)); +i__4519__auto___710 = G__711; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._EQ_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +if((x == null)){ +return (y == null); +} else { +return (((x === y)) || (cljs.core._equiv(x,y))); +} +}); + +cljs.core._EQ_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +while(true){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)){ +if(cljs.core.next(more)){ +var G__712 = y; +var G__713 = cljs.core.first(more); +var G__714 = cljs.core.next(more); +x = G__712; +y = G__713; +more = G__714; +continue; +} else { +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(y,cljs.core.first(more)); +} +} else { +return false; +} +break; +} +}); + +/** @this {Function} */ +cljs.core._EQ_.cljs$lang$applyTo = (function (seq704){ +var G__705 = cljs.core.first(seq704); +var seq704__$1 = cljs.core.next(seq704); +var G__706 = cljs.core.first(seq704__$1); +var seq704__$2 = cljs.core.next(seq704__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__705,G__706,seq704__$2); +}); + +cljs.core._EQ_.cljs$lang$maxFixedArity = (2); + + +/** +* @constructor +*/ +cljs.core.ES6Iterator = (function (s){ +this.s = s; +}); +cljs.core.ES6Iterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +if(!((self__.s == null))){ +var x = cljs.core.first(self__.s); +self__.s = cljs.core.next(self__.s); + +return ({"value": x, "done": false}); +} else { +return ({"value": null, "done": true}); +} +}); + +cljs.core.ES6Iterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$s,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ES6Iterator.cljs$lang$type = true; + +cljs.core.ES6Iterator.cljs$lang$ctorStr = "cljs.core/ES6Iterator"; + +cljs.core.ES6Iterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ES6Iterator"); +}); + +/** + * Positional factory function for cljs.core/ES6Iterator. + */ +cljs.core.__GT_ES6Iterator = (function cljs$core$__GT_ES6Iterator(s){ +return (new cljs.core.ES6Iterator(s)); +}); + +/** + * EXPERIMENTAL: Return a ES2015 compatible iterator for coll. + */ +cljs.core.es6_iterator = (function cljs$core$es6_iterator(coll){ +return (new cljs.core.ES6Iterator(cljs.core.seq(coll))); +}); + +/** +* @constructor + * @implements {cljs.core.ISeq} + * @implements {cljs.core.ISeqable} +*/ +cljs.core.ES6IteratorSeq = (function (value,iter,_rest){ +this.value = value; +this.iter = iter; +this._rest = _rest; +this.cljs$lang$protocol_mask$partition0$ = 8388672; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return this$__$1; +}); + +cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.value; +}); + +cljs.core.ES6IteratorSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +if((self__._rest == null)){ +self__._rest = cljs.core.es6_iterator_seq(self__.iter); +} else { +} + +return self__._rest; +}); + +cljs.core.ES6IteratorSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$value,cljs.core.cst$sym$iter,cljs.core.with_meta(cljs.core.cst$sym$_rest,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ES6IteratorSeq.cljs$lang$type = true; + +cljs.core.ES6IteratorSeq.cljs$lang$ctorStr = "cljs.core/ES6IteratorSeq"; + +cljs.core.ES6IteratorSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ES6IteratorSeq"); +}); + +/** + * Positional factory function for cljs.core/ES6IteratorSeq. + */ +cljs.core.__GT_ES6IteratorSeq = (function cljs$core$__GT_ES6IteratorSeq(value,iter,_rest){ +return (new cljs.core.ES6IteratorSeq(value,iter,_rest)); +}); + +/** + * EXPERIMENTAL: Given an ES2015 compatible iterator return a seq. + */ +cljs.core.es6_iterator_seq = (function cljs$core$es6_iterator_seq(iter){ +var v = iter.next(); +if(cljs.core.truth_(v.done)){ +return cljs.core.List.EMPTY; +} else { +return (new cljs.core.ES6IteratorSeq(v.value,iter,null)); +} +}); +/** + * Mix final collection hash for ordered or unordered collections. + * hash-basis is the combined collection hash, count is the number + * of elements included in the basis. Note this is the hash code + * consistent with =, different from .hashCode. + * See http://clojure.org/data_structures#hash for full algorithms. + */ +cljs.core.mix_collection_hash = (function cljs$core$mix_collection_hash(hash_basis,count){ +var h1 = cljs.core.m3_seed; +var k1 = cljs.core.m3_mix_K1(hash_basis); +var h1__$1 = cljs.core.m3_mix_H1(h1,k1); +return cljs.core.m3_fmix(h1__$1,count); +}); +/** + * Returns the hash code, consistent with =, for an external ordered + * collection implementing Iterable. + * See http://clojure.org/data_structures#hash for full algorithms. + */ +cljs.core.hash_ordered_coll = (function cljs$core$hash_ordered_coll(coll){ +var n = (0); +var hash_code = (1); +var coll__$1 = cljs.core.seq(coll); +while(true){ +if(!((coll__$1 == null))){ +var G__715 = (n + (1)); +var G__716 = ((cljs.core.imul((31),hash_code) + cljs.core.hash(cljs.core.first(coll__$1))) | (0)); +var G__717 = cljs.core.next(coll__$1); +n = G__715; +hash_code = G__716; +coll__$1 = G__717; +continue; +} else { +return cljs.core.mix_collection_hash(hash_code,n); +} +break; +} +}); +cljs.core.empty_ordered_hash = cljs.core.mix_collection_hash((1),(0)); +/** + * Returns the hash code, consistent with =, for an external unordered + * collection implementing Iterable. For maps, the iterator should + * return map entries whose hash is computed as + * (hash-ordered-coll [k v]). + * See http://clojure.org/data_structures#hash for full algorithms. + */ +cljs.core.hash_unordered_coll = (function cljs$core$hash_unordered_coll(coll){ +var n = (0); +var hash_code = (0); +var coll__$1 = cljs.core.seq(coll); +while(true){ +if(!((coll__$1 == null))){ +var G__718 = (n + (1)); +var G__719 = ((hash_code + cljs.core.hash(cljs.core.first(coll__$1))) | (0)); +var G__720 = cljs.core.next(coll__$1); +n = G__718; +hash_code = G__719; +coll__$1 = G__720; +continue; +} else { +return cljs.core.mix_collection_hash(hash_code,n); +} +break; +} +}); +cljs.core.empty_unordered_hash = cljs.core.mix_collection_hash((0),(0)); + + +goog.object.set(cljs.core.ICounted,"null",true); + +var G__721_724 = cljs.core._count; +var G__722_725 = "null"; +var G__723_726 = ((function (G__721_724,G__722_725){ +return (function (_){ +return (0); +});})(G__721_724,G__722_725)) +; +goog.object.set(G__721_724,G__722_725,G__723_726); +Date.prototype.cljs$core$IEquiv$ = cljs.core.PROTOCOL_SENTINEL; + +Date.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (o,other){ +var o__$1 = this; +return (((other instanceof Date)) && ((o__$1.valueOf() === other.valueOf()))); +}); + +Date.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +Date.prototype.cljs$core$IComparable$_compare$arity$2 = (function (this$,other){ +var this$__$1 = this; +if((other instanceof Date)){ +var G__727 = this$__$1.valueOf(); +var G__728 = other.valueOf(); +return goog.array.defaultCompare(G__727,G__728); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(this$__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(other)].join(''))); +} +}); + +/** + * @interface + */ +cljs.core.Inst = function(){}; + +cljs.core.inst_ms_STAR_ = (function cljs$core$inst_ms_STAR_(inst){ +if(((!((inst == null))) && (!((inst.cljs$core$Inst$inst_ms_STAR_$arity$1 == null))))){ +return inst.cljs$core$Inst$inst_ms_STAR_$arity$1(inst); +} else { +var x__4230__auto__ = (((inst == null))?null:inst); +var m__4231__auto__ = (cljs.core.inst_ms_STAR_[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(inst) : m__4231__auto__.call(null,inst)); +} else { +var m__4231__auto____$1 = (cljs.core.inst_ms_STAR_["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(inst) : m__4231__auto____$1.call(null,inst)); +} else { +throw cljs.core.missing_protocol("Inst.inst-ms*",inst); +} +} +} +}); + +Date.prototype.cljs$core$Inst$ = cljs.core.PROTOCOL_SENTINEL; + +Date.prototype.cljs$core$Inst$inst_ms_STAR_$arity$1 = (function (inst){ +var inst__$1 = this; +return inst__$1.getTime(); +}); +/** + * Return the number of milliseconds since January 1, 1970, 00:00:00 GMT + */ +cljs.core.inst_ms = (function cljs$core$inst_ms(inst){ +return cljs.core.inst_ms_STAR_(inst); +}); +/** + * Return true if x satisfies Inst + */ +cljs.core.inst_QMARK_ = (function cljs$core$inst_QMARK_(x){ +if(!((x == null))){ +if(((false) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$Inst$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.Inst,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.Inst,x); +} +}); +goog.object.set(cljs.core.IEquiv,"number",true); + +var G__730_733 = cljs.core._equiv; +var G__731_734 = "number"; +var G__732_735 = ((function (G__730_733,G__731_734){ +return (function (x,o){ +return (x === o); +});})(G__730_733,G__731_734)) +; +goog.object.set(G__730_733,G__731_734,G__732_735); +goog.object.set(cljs.core.Fn,"function",true); + +goog.object.set(cljs.core.IMeta,"function",true); + +var G__736_739 = cljs.core._meta; +var G__737_740 = "function"; +var G__738_741 = ((function (G__736_739,G__737_740){ +return (function (_){ +return null; +});})(G__736_739,G__737_740)) +; +goog.object.set(G__736_739,G__737_740,G__738_741); +goog.object.set(cljs.core.IHash,"_",true); + +var G__742_745 = cljs.core._hash; +var G__743_746 = "_"; +var G__744_747 = ((function (G__742_745,G__743_746){ +return (function (o){ +return goog.getUid(o); +});})(G__742_745,G__743_746)) +; +goog.object.set(G__742_745,G__743_746,G__744_747); +/** + * Returns a number one greater than num. + */ +cljs.core.inc = (function cljs$core$inc(x){ +return (x + (1)); +}); + +/** +* @constructor + * @implements {cljs.core.IDeref} +*/ +cljs.core.Reduced = (function (val){ +this.val = val; +this.cljs$lang$protocol_mask$partition0$ = 32768; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.Reduced.prototype.cljs$core$IDeref$_deref$arity$1 = (function (o){ +var self__ = this; +var o__$1 = this; +return self__.val; +}); + +cljs.core.Reduced.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$val], null); +}); + +cljs.core.Reduced.cljs$lang$type = true; + +cljs.core.Reduced.cljs$lang$ctorStr = "cljs.core/Reduced"; + +cljs.core.Reduced.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Reduced"); +}); + +/** + * Positional factory function for cljs.core/Reduced. + */ +cljs.core.__GT_Reduced = (function cljs$core$__GT_Reduced(val){ +return (new cljs.core.Reduced(val)); +}); + +/** + * Wraps x in a way such that a reduce will terminate with the value x + */ +cljs.core.reduced = (function cljs$core$reduced(x){ +return (new cljs.core.Reduced(x)); +}); +/** + * Returns true if x is the result of a call to reduced + */ +cljs.core.reduced_QMARK_ = (function cljs$core$reduced_QMARK_(r){ +return (r instanceof cljs.core.Reduced); +}); +/** + * If x is already reduced?, returns it, else returns (reduced x) + */ +cljs.core.ensure_reduced = (function cljs$core$ensure_reduced(x){ +if(cljs.core.reduced_QMARK_(x)){ +return x; +} else { +return cljs.core.reduced(x); +} +}); +/** + * If x is reduced?, returns (deref x), else returns x + */ +cljs.core.unreduced = (function cljs$core$unreduced(x){ +if(cljs.core.reduced_QMARK_(x)){ +return cljs.core.deref(x); +} else { +return x; +} +}); +/** + * Also reader macro: @var/@atom/@delay. Returns the + * most-recently-committed value of ref. When applied to a var + * or atom, returns its current state. When applied to a delay, forces + * it if not already forced. See also - realized?. + */ +cljs.core.deref = (function cljs$core$deref(o){ +return cljs.core._deref(o); +}); +/** + * Accepts any collection which satisfies the ICount and IIndexed protocols and + * reduces them without incurring seq initialization + */ +cljs.core.ci_reduce = (function cljs$core$ci_reduce(var_args){ +var G__749 = arguments.length; +switch (G__749) { +case 2: +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2 = (function (cicoll,f){ +var cnt = cljs.core._count(cicoll); +if((cnt === (0))){ +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +} else { +var val = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll,(0)); +var n = (1); +while(true){ +if((n < cnt)){ +var nval = (function (){var G__750 = val; +var G__751 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll,n); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__750,G__751) : f.call(null,G__750,G__751)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__757 = nval; +var G__758 = (n + (1)); +val = G__757; +n = G__758; +continue; +} +} else { +return val; +} +break; +} +} +}); + +cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3 = (function (cicoll,f,val){ +var cnt = cljs.core._count(cicoll); +var val__$1 = val; +var n = (0); +while(true){ +if((n < cnt)){ +var nval = (function (){var G__752 = val__$1; +var G__753 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll,n); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__752,G__753) : f.call(null,G__752,G__753)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__759 = nval; +var G__760 = (n + (1)); +val__$1 = G__759; +n = G__760; +continue; +} +} else { +return val__$1; +} +break; +} +}); + +cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$4 = (function (cicoll,f,val,idx){ +var cnt = cljs.core._count(cicoll); +var val__$1 = val; +var n = idx; +while(true){ +if((n < cnt)){ +var nval = (function (){var G__754 = val__$1; +var G__755 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(cicoll,n); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__754,G__755) : f.call(null,G__754,G__755)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__761 = nval; +var G__762 = (n + (1)); +val__$1 = G__761; +n = G__762; +continue; +} +} else { +return val__$1; +} +break; +} +}); + +cljs.core.ci_reduce.cljs$lang$maxFixedArity = 4; + +cljs.core.array_reduce = (function cljs$core$array_reduce(var_args){ +var G__764 = arguments.length; +switch (G__764) { +case 2: +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2 = (function (arr,f){ +var cnt = arr.length; +if((arr.length === (0))){ +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +} else { +var val = (arr[(0)]); +var n = (1); +while(true){ +if((n < cnt)){ +var nval = (function (){var G__765 = val; +var G__766 = (arr[n]); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__765,G__766) : f.call(null,G__765,G__766)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__772 = nval; +var G__773 = (n + (1)); +val = G__772; +n = G__773; +continue; +} +} else { +return val; +} +break; +} +} +}); + +cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3 = (function (arr,f,val){ +var cnt = arr.length; +var val__$1 = val; +var n = (0); +while(true){ +if((n < cnt)){ +var nval = (function (){var G__767 = val__$1; +var G__768 = (arr[n]); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__767,G__768) : f.call(null,G__767,G__768)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__774 = nval; +var G__775 = (n + (1)); +val__$1 = G__774; +n = G__775; +continue; +} +} else { +return val__$1; +} +break; +} +}); + +cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4 = (function (arr,f,val,idx){ +var cnt = arr.length; +var val__$1 = val; +var n = idx; +while(true){ +if((n < cnt)){ +var nval = (function (){var G__769 = val__$1; +var G__770 = (arr[n]); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__769,G__770) : f.call(null,G__769,G__770)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__776 = nval; +var G__777 = (n + (1)); +val__$1 = G__776; +n = G__777; +continue; +} +} else { +return val__$1; +} +break; +} +}); + +cljs.core.array_reduce.cljs$lang$maxFixedArity = 4; + + + + + + + +/** + * Returns true if coll implements count in constant time + */ +cljs.core.counted_QMARK_ = (function cljs$core$counted_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (2))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ICounted$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ICounted,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ICounted,x); +} +}); +/** + * Returns true if coll implements nth in constant time + */ +cljs.core.indexed_QMARK_ = (function cljs$core$indexed_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (16))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IIndexed$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,x); +} +}); +cljs.core._indexOf = (function cljs$core$_indexOf(var_args){ +var G__781 = arguments.length; +switch (G__781) { +case 2: +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._indexOf.cljs$core$IFn$_invoke$arity$2 = (function (coll,x){ +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); + +cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3 = (function (coll,x,start){ +var len = cljs.core.count(coll); +if((start >= len)){ +return (-1); +} else { +var idx = (((start > (0)))?start:(((start < (0)))?(function (){var x__4024__auto__ = (0); +var y__4025__auto__ = (start + len); +return ((x__4024__auto__ > y__4025__auto__) ? x__4024__auto__ : y__4025__auto__); +})():start +)); +while(true){ +if((idx < len)){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(coll,idx),x)){ +return idx; +} else { +var G__783 = (idx + (1)); +idx = G__783; +continue; +} +} else { +return (-1); +} +break; +} +} +}); + +cljs.core._indexOf.cljs$lang$maxFixedArity = 3; + +cljs.core._lastIndexOf = (function cljs$core$_lastIndexOf(var_args){ +var G__785 = arguments.length; +switch (G__785) { +case 2: +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$2 = (function (coll,x){ +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); + +cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3 = (function (coll,x,start){ +var len = cljs.core.count(coll); +if((len === (0))){ +return (-1); +} else { +var idx = (((start > (0)))?(function (){var x__4027__auto__ = (len - (1)); +var y__4028__auto__ = start; +return ((x__4027__auto__ < y__4028__auto__) ? x__4027__auto__ : y__4028__auto__); +})():(((start < (0)))?(len + start):start +)); +while(true){ +if((idx >= (0))){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(coll,idx),x)){ +return idx; +} else { +var G__787 = (idx - (1)); +idx = G__787; +continue; +} +} else { +return (-1); +} +break; +} +} +}); + +cljs.core._lastIndexOf.cljs$lang$maxFixedArity = 3; + + +/** +* @constructor +*/ +cljs.core.IndexedSeqIterator = (function (arr,i){ +this.arr = arr; +this.i = i; +}); +cljs.core.IndexedSeqIterator.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return (self__.i < self__.arr.length); +}); + +cljs.core.IndexedSeqIterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +var ret = (self__.arr[self__.i]); +self__.i = (self__.i + (1)); + +return ret; +}); + +cljs.core.IndexedSeqIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.IndexedSeqIterator.cljs$lang$type = true; + +cljs.core.IndexedSeqIterator.cljs$lang$ctorStr = "cljs.core/IndexedSeqIterator"; + +cljs.core.IndexedSeqIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/IndexedSeqIterator"); +}); + +/** + * Positional factory function for cljs.core/IndexedSeqIterator. + */ +cljs.core.__GT_IndexedSeqIterator = (function cljs$core$__GT_IndexedSeqIterator(arr,i){ +return (new cljs.core.IndexedSeqIterator(arr,i)); +}); + + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ASeq} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.IndexedSeq = (function (arr,i,meta){ +this.arr = arr; +this.i = i; +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 166592766; +this.cljs$lang$protocol_mask$partition1$ = 139264; +}); +cljs.core.IndexedSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.IndexedSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.IndexedSeq.prototype.indexOf = (function() { +var G__788 = null; +var G__788__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__788__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__788 = function(x,start){ +switch(arguments.length){ +case 1: +return G__788__1.call(this,x); +case 2: +return G__788__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__788.cljs$core$IFn$_invoke$arity$1 = G__788__1; +G__788.cljs$core$IFn$_invoke$arity$2 = G__788__2; +return G__788; +})() +; + +cljs.core.IndexedSeq.prototype.lastIndexOf = (function() { +var G__789 = null; +var G__789__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__789__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__789 = function(x,start){ +switch(arguments.length){ +case 1: +return G__789__1.call(this,x); +case 2: +return G__789__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__789.cljs$core$IFn$_invoke$arity$1 = G__789__1; +G__789.cljs$core$IFn$_invoke$arity$2 = G__789__2; +return G__789; +})() +; + +cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (coll,n){ +var self__ = this; +var coll__$1 = this; +var i__$1 = (n + self__.i); +if(((((0) <= i__$1)) && ((i__$1 < self__.arr.length)))){ +return (self__.arr[i__$1]); +} else { +throw (new Error("Index out of bounds")); +} +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (coll,n,not_found){ +var self__ = this; +var coll__$1 = this; +var i__$1 = (n + self__.i); +if(((((0) <= i__$1)) && ((i__$1 < self__.arr.length)))){ +return (self__.arr[i__$1]); +} else { +return not_found; +} +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.IndexedSeqIterator(self__.arr,self__.i)); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.IndexedSeq.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.IndexedSeq(self__.arr,self__.i,self__.meta)); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$INext$_next$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +if(((self__.i + (1)) < self__.arr.length)){ +return (new cljs.core.IndexedSeq(self__.arr,(self__.i + (1)),null)); +} else { +return null; +} +}); + +cljs.core.IndexedSeq.prototype.cljs$core$ICounted$_count$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +var x__4024__auto__ = (0); +var y__4025__auto__ = (self__.arr.length - self__.i); +return ((x__4024__auto__ > y__4025__auto__) ? x__4024__auto__ : y__4025__auto__); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var c = coll__$1.cljs$core$ICounted$_count$arity$1(null); +if((c > (0))){ +return (new cljs.core.RSeq(coll__$1,(c - (1)),null)); +} else { +return null; +} +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.hash_ordered_coll(coll__$1); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.List.EMPTY; +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,(self__.arr[self__.i]),(self__.i + (1))); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,start,self__.i); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (self__.arr[self__.i]); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +if(((self__.i + (1)) < self__.arr.length)){ +return (new cljs.core.IndexedSeq(self__.arr,(self__.i + (1)),null)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.IndexedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +if((self__.i < self__.arr.length)){ +return this$__$1; +} else { +return null; +} +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,new_meta){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.IndexedSeq(self__.arr,self__.i,new_meta)); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.IndexedSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.cst$sym$i,cljs.core.cst$sym$meta], null); +}); + +cljs.core.IndexedSeq.cljs$lang$type = true; + +cljs.core.IndexedSeq.cljs$lang$ctorStr = "cljs.core/IndexedSeq"; + +cljs.core.IndexedSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/IndexedSeq"); +}); + +/** + * Positional factory function for cljs.core/IndexedSeq. + */ +cljs.core.__GT_IndexedSeq = (function cljs$core$__GT_IndexedSeq(arr,i,meta){ +return (new cljs.core.IndexedSeq(arr,i,meta)); +}); + +var G__790_793 = cljs.core.IndexedSeq.prototype; +var G__791_794 = cljs.core.ITER_SYMBOL; +var G__792_795 = ((function (G__790_793,G__791_794){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__790_793,G__791_794)) +; +goog.object.set(G__790_793,G__791_794,G__792_795); +/** + * Create seq from a primitive JavaScript Array-like. + */ +cljs.core.prim_seq = (function cljs$core$prim_seq(var_args){ +var G__797 = arguments.length; +switch (G__797) { +case 1: +return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$1 = (function (prim){ +return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(prim,(0)); +}); + +cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2 = (function (prim,i){ +if((i < prim.length)){ +return (new cljs.core.IndexedSeq(prim,i,null)); +} else { +return null; +} +}); + +cljs.core.prim_seq.cljs$lang$maxFixedArity = 2; + +/** + * Create a seq from a JavaScript array. + */ +cljs.core.array_seq = (function cljs$core$array_seq(var_args){ +var G__800 = arguments.length; +switch (G__800) { +case 1: +return cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.array_seq.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.array_seq.cljs$core$IFn$_invoke$arity$1 = (function (array){ +return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(array,(0)); +}); + +cljs.core.array_seq.cljs$core$IFn$_invoke$arity$2 = (function (array,i){ +return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(array,i); +}); + +cljs.core.array_seq.cljs$lang$maxFixedArity = 2; + + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.RSeq = (function (ci,i,meta){ +this.ci = ci; +this.i = i; +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 32374990; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}); +cljs.core.RSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.RSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.RSeq.prototype.indexOf = (function() { +var G__802 = null; +var G__802__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__802__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__802 = function(x,start){ +switch(arguments.length){ +case 1: +return G__802__1.call(this,x); +case 2: +return G__802__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__802.cljs$core$IFn$_invoke$arity$1 = G__802__1; +G__802.cljs$core$IFn$_invoke$arity$2 = G__802__2; +return G__802; +})() +; + +cljs.core.RSeq.prototype.lastIndexOf = (function() { +var G__803 = null; +var G__803__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__803__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__803 = function(x,start){ +switch(arguments.length){ +case 1: +return G__803__1.call(this,x); +case 2: +return G__803__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__803.cljs$core$IFn$_invoke$arity$1 = G__803__1; +G__803.cljs$core$IFn$_invoke$arity$2 = G__803__2; +return G__803; +})() +; + +cljs.core.RSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.RSeq.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.RSeq(self__.ci,self__.i,self__.meta)); +}); + +cljs.core.RSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.i > (0))){ +return (new cljs.core.RSeq(self__.ci,(self__.i - (1)),null)); +} else { +return null; +} +}); + +cljs.core.RSeq.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (self__.i + (1)); +}); + +cljs.core.RSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.hash_ordered_coll(coll__$1); +}); + +cljs.core.RSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.RSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (col,f){ +var self__ = this; +var col__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,col__$1); +}); + +cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (col,f,start){ +var self__ = this; +var col__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,col__$1); +}); + +cljs.core.RSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.ci,self__.i); +}); + +cljs.core.RSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.i > (0))){ +return (new cljs.core.RSeq(self__.ci,(self__.i - (1)),null)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.RSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.RSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,new_meta){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.RSeq(self__.ci,self__.i,new_meta)); +}); + +cljs.core.RSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.RSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$ci,cljs.core.cst$sym$i,cljs.core.cst$sym$meta], null); +}); + +cljs.core.RSeq.cljs$lang$type = true; + +cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq"; + +cljs.core.RSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/RSeq"); +}); + +/** + * Positional factory function for cljs.core/RSeq. + */ +cljs.core.__GT_RSeq = (function cljs$core$__GT_RSeq(ci,i,meta){ +return (new cljs.core.RSeq(ci,i,meta)); +}); + +var G__804_807 = cljs.core.RSeq.prototype; +var G__805_808 = cljs.core.ITER_SYMBOL; +var G__806_809 = ((function (G__804_807,G__805_808){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__804_807,G__805_808)) +; +goog.object.set(G__804_807,G__805_808,G__806_809); +/** + * Same as (first (next x)) + */ +cljs.core.second = (function cljs$core$second(coll){ +return cljs.core.first(cljs.core.next(coll)); +}); +/** + * Same as (first (first x)) + */ +cljs.core.ffirst = (function cljs$core$ffirst(coll){ +return cljs.core.first(cljs.core.first(coll)); +}); +/** + * Same as (next (first x)) + */ +cljs.core.nfirst = (function cljs$core$nfirst(coll){ +return cljs.core.next(cljs.core.first(coll)); +}); +/** + * Same as (first (next x)) + */ +cljs.core.fnext = (function cljs$core$fnext(coll){ +return cljs.core.first(cljs.core.next(coll)); +}); +/** + * Same as (next (next x)) + */ +cljs.core.nnext = (function cljs$core$nnext(coll){ +return cljs.core.next(cljs.core.next(coll)); +}); +/** + * Return the last item in coll, in linear time + */ +cljs.core.last = (function cljs$core$last(s){ +while(true){ +var sn = cljs.core.next(s); +if(!((sn == null))){ +var G__810 = sn; +s = G__810; +continue; +} else { +return cljs.core.first(s); +} +break; +} +}); +goog.object.set(cljs.core.IEquiv,"_",true); + +var G__811_814 = cljs.core._equiv; +var G__812_815 = "_"; +var G__813_816 = ((function (G__811_814,G__812_815){ +return (function (x,o){ +return (x === o); +});})(G__811_814,G__812_815)) +; +goog.object.set(G__811_814,G__812_815,G__813_816); +/** + * conj[oin]. Returns a new collection with the xs + * 'added'. (conj nil item) returns (item). The 'addition' may + * happen at different 'places' depending on the concrete type. + */ +cljs.core.conj = (function cljs$core$conj(var_args){ +var G__821 = arguments.length; +switch (G__821) { +case 0: +return cljs.core.conj.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.conj.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___823 = arguments.length; +var i__4519__auto___824 = (0); +while(true){ +if((i__4519__auto___824 < len__4518__auto___823)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___824])); + +var G__825 = (i__4519__auto___824 + (1)); +i__4519__auto___824 = G__825; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.conj.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.PersistentVector.EMPTY; +}); + +cljs.core.conj.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +return coll; +}); + +cljs.core.conj.cljs$core$IFn$_invoke$arity$2 = (function (coll,x){ +if(!((coll == null))){ +return cljs.core._conj(coll,x); +} else { +return (new cljs.core.List(null,x,null,(1),null)); +} +}); + +cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic = (function (coll,x,xs){ +while(true){ +if(cljs.core.truth_(xs)){ +var G__826 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(coll,x); +var G__827 = cljs.core.first(xs); +var G__828 = cljs.core.next(xs); +coll = G__826; +x = G__827; +xs = G__828; +continue; +} else { +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(coll,x); +} +break; +} +}); + +/** @this {Function} */ +cljs.core.conj.cljs$lang$applyTo = (function (seq818){ +var G__819 = cljs.core.first(seq818); +var seq818__$1 = cljs.core.next(seq818); +var G__820 = cljs.core.first(seq818__$1); +var seq818__$2 = cljs.core.next(seq818__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__819,G__820,seq818__$2); +}); + +cljs.core.conj.cljs$lang$maxFixedArity = (2); + +/** + * Returns an empty collection of the same category as coll, or nil + */ +cljs.core.empty = (function cljs$core$empty(coll){ +if((coll == null)){ +return null; +} else { +return cljs.core._empty(coll); +} +}); +cljs.core.accumulating_seq_count = (function cljs$core$accumulating_seq_count(coll){ +var s = cljs.core.seq(coll); +var acc = (0); +while(true){ +if(cljs.core.counted_QMARK_(s)){ +return (acc + cljs.core._count(s)); +} else { +var G__829 = cljs.core.next(s); +var G__830 = (acc + (1)); +s = G__829; +acc = G__830; +continue; +} +break; +} +}); +/** + * Returns the number of items in the collection. (count nil) returns + * 0. Also works on strings, arrays, and Maps + */ +cljs.core.count = (function cljs$core$count(coll){ +if(!((coll == null))){ +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (2))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ICounted$))))?true:false):false)){ +return coll.cljs$core$ICounted$_count$arity$1(null); +} else { +if(cljs.core.array_QMARK_(coll)){ +return coll.length; +} else { +if(typeof coll === 'string'){ +return coll.length; +} else { +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (8388608))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeqable$))))?true:false):false)){ +return cljs.core.accumulating_seq_count(coll); +} else { +return cljs.core._count(coll); + +} +} +} +} +} else { +return (0); +} +}); +cljs.core.linear_traversal_nth = (function cljs$core$linear_traversal_nth(var_args){ +var G__834 = arguments.length; +switch (G__834) { +case 2: +return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2 = (function (coll,n){ +while(true){ +if((coll == null)){ +throw (new Error("Index out of bounds")); +} else { +if((n === (0))){ +if(cljs.core.seq(coll)){ +return cljs.core.first(coll); +} else { +throw (new Error("Index out of bounds")); +} +} else { +if(cljs.core.indexed_QMARK_(coll)){ +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(coll,n); +} else { +if(cljs.core.seq(coll)){ +var G__836 = cljs.core.next(coll); +var G__837 = (n - (1)); +coll = G__836; +n = G__837; +continue; +} else { +throw (new Error("Index out of bounds")); + +} +} +} +} +break; +} +}); + +cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3 = (function (coll,n,not_found){ +while(true){ +if((coll == null)){ +return not_found; +} else { +if((n === (0))){ +if(cljs.core.seq(coll)){ +return cljs.core.first(coll); +} else { +return not_found; +} +} else { +if(cljs.core.indexed_QMARK_(coll)){ +return cljs.core._nth.cljs$core$IFn$_invoke$arity$3(coll,n,not_found); +} else { +if(cljs.core.seq(coll)){ +var G__838 = cljs.core.next(coll); +var G__839 = (n - (1)); +var G__840 = not_found; +coll = G__838; +n = G__839; +not_found = G__840; +continue; +} else { +return not_found; + +} +} +} +} +break; +} +}); + +cljs.core.linear_traversal_nth.cljs$lang$maxFixedArity = 3; + +/** + * Returns the value at the index. get returns nil if index out of + * bounds, nth throws an exception unless not-found is supplied. nth + * also works for strings, arrays, regex Matchers and Lists, and, + * in O(n) time, for sequences. + */ +cljs.core.nth = (function cljs$core$nth(var_args){ +var G__842 = arguments.length; +switch (G__842) { +case 2: +return cljs.core.nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.nth.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.nth.cljs$core$IFn$_invoke$arity$2 = (function (coll,n){ +if(!(typeof n === 'number')){ +throw (new Error("Index argument to nth must be a number")); +} else { +if((coll == null)){ +return coll; +} else { +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (16))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IIndexed$))))?true:false):false)){ +return coll.cljs$core$IIndexed$_nth$arity$2(null,n); +} else { +if(cljs.core.array_QMARK_(coll)){ +if((((n >= (0))) && ((n < coll.length)))){ +return (coll[n]); +} else { +throw (new Error("Index out of bounds")); +} +} else { +if(typeof coll === 'string'){ +if((((n >= (0))) && ((n < coll.length)))){ +return coll.charAt(n); +} else { +throw (new Error("Index out of bounds")); +} +} else { +if((function (){var or__3936__auto__ = ((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$))))?true:false):false); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +if(!((coll == null))){ +if((((coll.cljs$lang$protocol_mask$partition0$ & (16777216))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISequential$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +} +})()){ +return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$2(coll,n); +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,coll)){ +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(coll,n); +} else { +throw (new Error(["nth not supported on this type ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.type__GT_str(cljs.core.type(coll)))].join(''))); + +} +} +} +} +} +} +} +}); + +cljs.core.nth.cljs$core$IFn$_invoke$arity$3 = (function (coll,n,not_found){ +if(!(typeof n === 'number')){ +throw (new Error("Index argument to nth must be a number.")); +} else { +if((coll == null)){ +return not_found; +} else { +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (16))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IIndexed$))))?true:false):false)){ +return coll.cljs$core$IIndexed$_nth$arity$3(null,n,not_found); +} else { +if(cljs.core.array_QMARK_(coll)){ +if((((n >= (0))) && ((n < coll.length)))){ +return (coll[n]); +} else { +return not_found; +} +} else { +if(typeof coll === 'string'){ +if((((n >= (0))) && ((n < coll.length)))){ +return coll.charAt(n); +} else { +return not_found; +} +} else { +if((function (){var or__3936__auto__ = ((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$))))?true:false):false); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +if(!((coll == null))){ +if((((coll.cljs$lang$protocol_mask$partition0$ & (16777216))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISequential$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +} +})()){ +return cljs.core.linear_traversal_nth.cljs$core$IFn$_invoke$arity$3(coll,n,not_found); +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.IIndexed,coll)){ +return cljs.core._nth.cljs$core$IFn$_invoke$arity$3(coll,n,not_found); +} else { +throw (new Error(["nth not supported on this type ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.type__GT_str(cljs.core.type(coll)))].join(''))); + +} +} +} +} +} +} +} +}); + +cljs.core.nth.cljs$lang$maxFixedArity = 3; + +/** + * Returns the nth rest of coll, coll when n is 0. + */ +cljs.core.nthrest = (function cljs$core$nthrest(coll,n){ +var n__$1 = n; +var xs = coll; +while(true){ +var temp__5455__auto__ = (((n__$1 > (0))) && (cljs.core.seq(xs))); +if(temp__5455__auto__){ +var xs__$1 = temp__5455__auto__; +var G__852 = (n__$1 - (1)); +var G__853 = cljs.core.rest(xs__$1); +n__$1 = G__852; +xs = G__853; +continue; +} else { +return xs; +} +break; +} +}); +/** + * Returns the value mapped to key, not-found or nil if key not present. + */ +cljs.core.get = (function cljs$core$get(var_args){ +var G__855 = arguments.length; +switch (G__855) { +case 2: +return cljs.core.get.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.get.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.get.cljs$core$IFn$_invoke$arity$2 = (function (o,k){ +if((o == null)){ +return null; +} else { +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (256))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$ILookup$))))?true:false):false)){ +return o.cljs$core$ILookup$_lookup$arity$2(null,k); +} else { +if(cljs.core.array_QMARK_(o)){ +if(((!((k == null))) && ((k < o.length)))){ +return (o[(k | (0))]); +} else { +return null; +} +} else { +if(typeof o === 'string'){ +if(((!((k == null))) && ((k < o.length)))){ +return o.charAt((k | (0))); +} else { +return null; +} +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.ILookup,o)){ +return cljs.core._lookup.cljs$core$IFn$_invoke$arity$2(o,k); +} else { +return null; + +} +} +} +} +} +}); + +cljs.core.get.cljs$core$IFn$_invoke$arity$3 = (function (o,k,not_found){ +if(!((o == null))){ +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (256))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$ILookup$))))?true:false):false)){ +return o.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +} else { +if(cljs.core.array_QMARK_(o)){ +if(((!((k == null))) && ((k >= (0))) && ((k < o.length)))){ +return (o[(k | (0))]); +} else { +return not_found; +} +} else { +if(typeof o === 'string'){ +if(((!((k == null))) && ((k >= (0))) && ((k < o.length)))){ +return o.charAt((k | (0))); +} else { +return not_found; +} +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.ILookup,o)){ +return cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(o,k,not_found); +} else { +return not_found; + +} +} +} +} +} else { +return not_found; +} +}); + +cljs.core.get.cljs$lang$maxFixedArity = 3; + + + +/** + * assoc[iate]. When applied to a map, returns a new map of the + * same (hashed/sorted) type, that contains the mapping of key(s) to + * val(s). When applied to a vector, returns a new vector that + * contains val at index. + */ +cljs.core.assoc = (function cljs$core$assoc(var_args){ +var G__864 = arguments.length; +switch (G__864) { +case 3: +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___866 = arguments.length; +var i__4519__auto___867 = (0); +while(true){ +if((i__4519__auto___867 < len__4518__auto___866)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___867])); + +var G__868 = (i__4519__auto___867 + (1)); +i__4519__auto___867 = G__868; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.assoc.cljs$core$IFn$_invoke$arity$3 = (function (coll,k,v){ +if(!((coll == null))){ +return cljs.core._assoc(coll,k,v); +} else { +return cljs.core.PersistentArrayMap.createAsIfByAssoc([k,v]); +} +}); + +cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic = (function (coll,k,v,kvs){ +while(true){ +var ret = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(coll,k,v); +if(cljs.core.truth_(kvs)){ +var G__869 = ret; +var G__870 = cljs.core.first(kvs); +var G__871 = cljs.core.second(kvs); +var G__872 = cljs.core.nnext(kvs); +coll = G__869; +k = G__870; +v = G__871; +kvs = G__872; +continue; +} else { +return ret; +} +break; +} +}); + +/** @this {Function} */ +cljs.core.assoc.cljs$lang$applyTo = (function (seq860){ +var G__861 = cljs.core.first(seq860); +var seq860__$1 = cljs.core.next(seq860); +var G__862 = cljs.core.first(seq860__$1); +var seq860__$2 = cljs.core.next(seq860__$1); +var G__863 = cljs.core.first(seq860__$2); +var seq860__$3 = cljs.core.next(seq860__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__861,G__862,G__863,seq860__$3); +}); + +cljs.core.assoc.cljs$lang$maxFixedArity = (3); + +/** + * dissoc[iate]. Returns a new map of the same (hashed/sorted) type, + * that does not contain a mapping for key(s). + */ +cljs.core.dissoc = (function cljs$core$dissoc(var_args){ +var G__877 = arguments.length; +switch (G__877) { +case 1: +return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___879 = arguments.length; +var i__4519__auto___880 = (0); +while(true){ +if((i__4519__auto___880 < len__4518__auto___879)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___880])); + +var G__881 = (i__4519__auto___880 + (1)); +i__4519__auto___880 = G__881; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.dissoc.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +return coll; +}); + +cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2 = (function (coll,k){ +if((coll == null)){ +return null; +} else { +return cljs.core._dissoc(coll,k); +} +}); + +cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic = (function (coll,k,ks){ +while(true){ +if((coll == null)){ +return null; +} else { +var ret = cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(coll,k); +if(cljs.core.truth_(ks)){ +var G__882 = ret; +var G__883 = cljs.core.first(ks); +var G__884 = cljs.core.next(ks); +coll = G__882; +k = G__883; +ks = G__884; +continue; +} else { +return ret; +} +} +break; +} +}); + +/** @this {Function} */ +cljs.core.dissoc.cljs$lang$applyTo = (function (seq874){ +var G__875 = cljs.core.first(seq874); +var seq874__$1 = cljs.core.next(seq874); +var G__876 = cljs.core.first(seq874__$1); +var seq874__$2 = cljs.core.next(seq874__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__875,G__876,seq874__$2); +}); + +cljs.core.dissoc.cljs$lang$maxFixedArity = (2); + +/** + * Return true if f is a JavaScript function or satisfies the Fn protocol. + */ +cljs.core.fn_QMARK_ = (function cljs$core$fn_QMARK_(f){ +var or__3936__auto__ = goog.isFunction(f); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +if(!((f == null))){ +if(((false) || ((cljs.core.PROTOCOL_SENTINEL === f.cljs$core$Fn$)))){ +return true; +} else { +if((!f.cljs$lang$protocol_mask$partition$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.Fn,f); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.Fn,f); +} +} +}); + +/** +* @constructor + * @implements {cljs.core.IFn} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.Fn} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.MetaFn = (function (afn,meta){ +this.afn = afn; +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 393217; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.MetaFn.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.meta; +}); + +cljs.core.MetaFn.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (_,new_meta){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.MetaFn(self__.afn,new_meta)); +}); + +cljs.core.MetaFn.prototype.cljs$core$Fn$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.MetaFn.prototype.call = (function() { +var G__888 = null; +var G__888__1 = (function (self__){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$0 ? self__.afn.cljs$core$IFn$_invoke$arity$0() : self__.afn.call(null)); +}); +var G__888__2 = (function (self__,a){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$1 ? self__.afn.cljs$core$IFn$_invoke$arity$1(a) : self__.afn.call(null,a)); +}); +var G__888__3 = (function (self__,a,b){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$2 ? self__.afn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.afn.call(null,a,b)); +}); +var G__888__4 = (function (self__,a,b,c){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$3 ? self__.afn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.afn.call(null,a,b,c)); +}); +var G__888__5 = (function (self__,a,b,c,d){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$4 ? self__.afn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.afn.call(null,a,b,c,d)); +}); +var G__888__6 = (function (self__,a,b,c,d,e){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$5 ? self__.afn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.afn.call(null,a,b,c,d,e)); +}); +var G__888__7 = (function (self__,a,b,c,d,e,f){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$6 ? self__.afn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : self__.afn.call(null,a,b,c,d,e,f)); +}); +var G__888__8 = (function (self__,a,b,c,d,e,f,g){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$7 ? self__.afn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : self__.afn.call(null,a,b,c,d,e,f,g)); +}); +var G__888__9 = (function (self__,a,b,c,d,e,f,g,h){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$8 ? self__.afn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : self__.afn.call(null,a,b,c,d,e,f,g,h)); +}); +var G__888__10 = (function (self__,a,b,c,d,e,f,g,h,i){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$9 ? self__.afn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : self__.afn.call(null,a,b,c,d,e,f,g,h,i)); +}); +var G__888__11 = (function (self__,a,b,c,d,e,f,g,h,i,j){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$10 ? self__.afn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j)); +}); +var G__888__12 = (function (self__,a,b,c,d,e,f,g,h,i,j,k){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$11 ? self__.afn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k)); +}); +var G__888__13 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$12 ? self__.afn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +}); +var G__888__14 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$13 ? self__.afn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +}); +var G__888__15 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$14 ? self__.afn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +}); +var G__888__16 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$15 ? self__.afn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +}); +var G__888__17 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$16 ? self__.afn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +}); +var G__888__18 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$17 ? self__.afn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +}); +var G__888__19 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$18 ? self__.afn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +}); +var G__888__20 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$19 ? self__.afn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +}); +var G__888__21 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return (self__.afn.cljs$core$IFn$_invoke$arity$20 ? self__.afn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +}); +var G__888__22 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +var self__ = this; +var self____$1 = this; +var _ = self____$1; +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.afn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +}); +G__888 = function(self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +switch(arguments.length){ +case 1: +return G__888__1.call(this,self__); +case 2: +return G__888__2.call(this,self__,a); +case 3: +return G__888__3.call(this,self__,a,b); +case 4: +return G__888__4.call(this,self__,a,b,c); +case 5: +return G__888__5.call(this,self__,a,b,c,d); +case 6: +return G__888__6.call(this,self__,a,b,c,d,e); +case 7: +return G__888__7.call(this,self__,a,b,c,d,e,f); +case 8: +return G__888__8.call(this,self__,a,b,c,d,e,f,g); +case 9: +return G__888__9.call(this,self__,a,b,c,d,e,f,g,h); +case 10: +return G__888__10.call(this,self__,a,b,c,d,e,f,g,h,i); +case 11: +return G__888__11.call(this,self__,a,b,c,d,e,f,g,h,i,j); +case 12: +return G__888__12.call(this,self__,a,b,c,d,e,f,g,h,i,j,k); +case 13: +return G__888__13.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l); +case 14: +return G__888__14.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m); +case 15: +return G__888__15.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n); +case 16: +return G__888__16.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o); +case 17: +return G__888__17.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); +case 18: +return G__888__18.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q); +case 19: +return G__888__19.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r); +case 20: +return G__888__20.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s); +case 21: +return G__888__21.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t); +case 22: +return G__888__22.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__888.cljs$core$IFn$_invoke$arity$1 = G__888__1; +G__888.cljs$core$IFn$_invoke$arity$2 = G__888__2; +G__888.cljs$core$IFn$_invoke$arity$3 = G__888__3; +G__888.cljs$core$IFn$_invoke$arity$4 = G__888__4; +G__888.cljs$core$IFn$_invoke$arity$5 = G__888__5; +G__888.cljs$core$IFn$_invoke$arity$6 = G__888__6; +G__888.cljs$core$IFn$_invoke$arity$7 = G__888__7; +G__888.cljs$core$IFn$_invoke$arity$8 = G__888__8; +G__888.cljs$core$IFn$_invoke$arity$9 = G__888__9; +G__888.cljs$core$IFn$_invoke$arity$10 = G__888__10; +G__888.cljs$core$IFn$_invoke$arity$11 = G__888__11; +G__888.cljs$core$IFn$_invoke$arity$12 = G__888__12; +G__888.cljs$core$IFn$_invoke$arity$13 = G__888__13; +G__888.cljs$core$IFn$_invoke$arity$14 = G__888__14; +G__888.cljs$core$IFn$_invoke$arity$15 = G__888__15; +G__888.cljs$core$IFn$_invoke$arity$16 = G__888__16; +G__888.cljs$core$IFn$_invoke$arity$17 = G__888__17; +G__888.cljs$core$IFn$_invoke$arity$18 = G__888__18; +G__888.cljs$core$IFn$_invoke$arity$19 = G__888__19; +G__888.cljs$core$IFn$_invoke$arity$20 = G__888__20; +G__888.cljs$core$IFn$_invoke$arity$21 = G__888__21; +G__888.cljs$core$IFn$_invoke$arity$22 = G__888__22; +return G__888; +})() +; + +cljs.core.MetaFn.prototype.apply = (function (self__,args887){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args887))); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$0 = (function (){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$0 ? self__.afn.cljs$core$IFn$_invoke$arity$0() : self__.afn.call(null)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$1 = (function (a){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$1 ? self__.afn.cljs$core$IFn$_invoke$arity$1(a) : self__.afn.call(null,a)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$2 = (function (a,b){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$2 ? self__.afn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.afn.call(null,a,b)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$3 = (function (a,b,c){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$3 ? self__.afn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.afn.call(null,a,b,c)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$4 = (function (a,b,c,d){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$4 ? self__.afn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.afn.call(null,a,b,c,d)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$5 = (function (a,b,c,d,e){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$5 ? self__.afn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.afn.call(null,a,b,c,d,e)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$6 = (function (a,b,c,d,e,f){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$6 ? self__.afn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : self__.afn.call(null,a,b,c,d,e,f)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$7 = (function (a,b,c,d,e,f,g){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$7 ? self__.afn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : self__.afn.call(null,a,b,c,d,e,f,g)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$8 = (function (a,b,c,d,e,f,g,h){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$8 ? self__.afn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : self__.afn.call(null,a,b,c,d,e,f,g,h)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$9 = (function (a,b,c,d,e,f,g,h,i){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$9 ? self__.afn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : self__.afn.call(null,a,b,c,d,e,f,g,h,i)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$10 = (function (a,b,c,d,e,f,g,h,i,j){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$10 ? self__.afn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$11 = (function (a,b,c,d,e,f,g,h,i,j,k){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$11 ? self__.afn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$12 = (function (a,b,c,d,e,f,g,h,i,j,k,l){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$12 ? self__.afn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$13 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$13 ? self__.afn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$14 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$14 ? self__.afn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$15 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$15 ? self__.afn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$16 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$16 ? self__.afn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$17 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$17 ? self__.afn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$18 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$18 ? self__.afn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$19 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$19 ? self__.afn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$20 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +var self__ = this; +var _ = this; +return (self__.afn.cljs$core$IFn$_invoke$arity$20 ? self__.afn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : self__.afn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +}); + +cljs.core.MetaFn.prototype.cljs$core$IFn$_invoke$arity$21 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +var self__ = this; +var _ = this; +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.afn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +}); + +cljs.core.MetaFn.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$afn,cljs.core.cst$sym$meta], null); +}); + +cljs.core.MetaFn.cljs$lang$type = true; + +cljs.core.MetaFn.cljs$lang$ctorStr = "cljs.core/MetaFn"; + +cljs.core.MetaFn.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/MetaFn"); +}); + +/** + * Positional factory function for cljs.core/MetaFn. + */ +cljs.core.__GT_MetaFn = (function cljs$core$__GT_MetaFn(afn,meta){ +return (new cljs.core.MetaFn(afn,meta)); +}); + +/** + * Returns an object of the same type and value as obj, with + * map m as its metadata. + */ +cljs.core.with_meta = (function cljs$core$with_meta(o,meta){ +if(goog.isFunction(o)){ +return (new cljs.core.MetaFn(o,meta)); +} else { +if((o == null)){ +return null; +} else { +return cljs.core._with_meta(o,meta); +} +} +}); +/** + * Returns the metadata of obj, returns nil if there is no metadata. + */ +cljs.core.meta = (function cljs$core$meta(o){ +if((function (){var and__3925__auto__ = !((o == null)); +if(and__3925__auto__){ +if(!((o == null))){ +if((((o.cljs$lang$protocol_mask$partition0$ & (131072))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IMeta$)))){ +return true; +} else { +if((!o.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IMeta,o); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IMeta,o); +} +} else { +return and__3925__auto__; +} +})()){ +return cljs.core._meta(o); +} else { +return null; +} +}); +/** + * For a list or queue, same as first, for a vector, same as, but much + * more efficient than, last. If the collection is empty, returns nil. + */ +cljs.core.peek = (function cljs$core$peek(coll){ +if((coll == null)){ +return null; +} else { +return cljs.core._peek(coll); +} +}); +/** + * For a list or queue, returns a new list/queue without the first + * item, for a vector, returns a new vector without the last item. + * Note - not the same as next/butlast. + */ +cljs.core.pop = (function cljs$core$pop(coll){ +if((coll == null)){ +return null; +} else { +return cljs.core._pop(coll); +} +}); +/** + * disj[oin]. Returns a new set of the same (hashed/sorted) type, that + * does not contain key(s). + */ +cljs.core.disj = (function cljs$core$disj(var_args){ +var G__895 = arguments.length; +switch (G__895) { +case 1: +return cljs.core.disj.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.disj.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___897 = arguments.length; +var i__4519__auto___898 = (0); +while(true){ +if((i__4519__auto___898 < len__4518__auto___897)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___898])); + +var G__899 = (i__4519__auto___898 + (1)); +i__4519__auto___898 = G__899; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.disj.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +return coll; +}); + +cljs.core.disj.cljs$core$IFn$_invoke$arity$2 = (function (coll,k){ +if((coll == null)){ +return null; +} else { +return cljs.core._disjoin(coll,k); +} +}); + +cljs.core.disj.cljs$core$IFn$_invoke$arity$variadic = (function (coll,k,ks){ +while(true){ +if((coll == null)){ +return null; +} else { +var ret = cljs.core.disj.cljs$core$IFn$_invoke$arity$2(coll,k); +if(cljs.core.truth_(ks)){ +var G__900 = ret; +var G__901 = cljs.core.first(ks); +var G__902 = cljs.core.next(ks); +coll = G__900; +k = G__901; +ks = G__902; +continue; +} else { +return ret; +} +} +break; +} +}); + +/** @this {Function} */ +cljs.core.disj.cljs$lang$applyTo = (function (seq892){ +var G__893 = cljs.core.first(seq892); +var seq892__$1 = cljs.core.next(seq892); +var G__894 = cljs.core.first(seq892__$1); +var seq892__$2 = cljs.core.next(seq892__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__893,G__894,seq892__$2); +}); + +cljs.core.disj.cljs$lang$maxFixedArity = (2); + +/** + * Returns true if coll has no items - same as (not (seq coll)). + * Please use the idiom (seq x) rather than (not (empty? x)) + */ +cljs.core.empty_QMARK_ = (function cljs$core$empty_QMARK_(coll){ +return (((coll == null)) || (cljs.core.not(cljs.core.seq(coll)))); +}); +/** + * Returns true if x satisfies ICollection + */ +cljs.core.coll_QMARK_ = (function cljs$core$coll_QMARK_(x){ +if((x == null)){ +return false; +} else { +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (8))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ICollection$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ICollection,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ICollection,x); +} +} +}); +/** + * Returns true if x satisfies ISet + */ +cljs.core.set_QMARK_ = (function cljs$core$set_QMARK_(x){ +if((x == null)){ +return false; +} else { +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (4096))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISet$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x); +} +} +}); +/** + * Returns true if coll implements IAssociative + */ +cljs.core.associative_QMARK_ = (function cljs$core$associative_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (512))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IAssociative$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IAssociative,x); +} +}); +/** + * Returns true if coll implements IFind + */ +cljs.core.ifind_QMARK_ = (function cljs$core$ifind_QMARK_(x){ +if(!((x == null))){ +if(((false) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IFind$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IFind,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IFind,x); +} +}); +/** + * Returns true if coll satisfies ISequential + */ +cljs.core.sequential_QMARK_ = (function cljs$core$sequential_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (16777216))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISequential$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x); +} +}); +/** + * Returns true if coll satisfies ISorted + */ +cljs.core.sorted_QMARK_ = (function cljs$core$sorted_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (268435456))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISorted$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ISorted,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ISorted,x); +} +}); +/** + * Returns true if coll satisfies IReduce + */ +cljs.core.reduceable_QMARK_ = (function cljs$core$reduceable_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (524288))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IReduce$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,x); +} +}); +/** + * Return true if x satisfies IMap + */ +cljs.core.map_QMARK_ = (function cljs$core$map_QMARK_(x){ +if((x == null)){ +return false; +} else { +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (1024))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IMap$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x); +} +} +}); +/** + * Return true if x satisfies IRecord + */ +cljs.core.record_QMARK_ = (function cljs$core$record_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (67108864))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IRecord$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IRecord,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IRecord,x); +} +}); +/** + * Return true if x satisfies IVector + */ +cljs.core.vector_QMARK_ = (function cljs$core$vector_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (16384))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IVector$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IVector,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IVector,x); +} +}); + +/** + * Return true if x is satisfies IChunkedSeq. + */ +cljs.core.chunked_seq_QMARK_ = (function cljs$core$chunked_seq_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition1$ & (512))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IChunkedSeq$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +}); +/** + * Create JavaSript object from an even number arguments representing + * interleaved keys and values. + */ +cljs.core.js_obj = (function cljs$core$js_obj(var_args){ +var G__916 = arguments.length; +switch (G__916) { +case 0: +return cljs.core.js_obj.cljs$core$IFn$_invoke$arity$0(); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___920 = arguments.length; +var i__4519__auto___921 = (0); +while(true){ +if((i__4519__auto___921 < len__4518__auto___920)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___921])); + +var G__922 = (i__4519__auto___921 + (1)); +i__4519__auto___921 = G__922; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((0)),(0),null)); +return cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic(argseq__4534__auto__); + +} +}); + +cljs.core.js_obj.cljs$core$IFn$_invoke$arity$0 = (function (){ +return {}; +}); + +cljs.core.js_obj.cljs$core$IFn$_invoke$arity$variadic = (function (keyvals){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(goog.object.create,keyvals); +}); + +/** @this {Function} */ +cljs.core.js_obj.cljs$lang$applyTo = (function (seq915){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq915)); +}); + +cljs.core.js_obj.cljs$lang$maxFixedArity = (0); + +/** + * Return the JavaScript keys for an object. + */ +cljs.core.js_keys = (function cljs$core$js_keys(obj){ +return goog.object.getKeys(obj); +}); +/** + * Delete a property from a JavaScript object. + * Returns true upon success, false otherwise. + */ +cljs.core.js_delete = (function cljs$core$js_delete(obj,key){ +return delete obj[key]; +}); +cljs.core.array_copy = (function cljs$core$array_copy(from,i,to,j,len){ +var i__$1 = i; +var j__$1 = j; +var len__$1 = len; +while(true){ +if((len__$1 === (0))){ +return to; +} else { +(to[j__$1] = (from[i__$1])); + +var G__923 = (i__$1 + (1)); +var G__924 = (j__$1 + (1)); +var G__925 = (len__$1 - (1)); +i__$1 = G__923; +j__$1 = G__924; +len__$1 = G__925; +continue; +} +break; +} +}); +cljs.core.array_copy_downward = (function cljs$core$array_copy_downward(from,i,to,j,len){ +var i__$1 = (i + (len - (1))); +var j__$1 = (j + (len - (1))); +var len__$1 = len; +while(true){ +if((len__$1 === (0))){ +return to; +} else { +(to[j__$1] = (from[i__$1])); + +var G__926 = (i__$1 - (1)); +var G__927 = (j__$1 - (1)); +var G__928 = (len__$1 - (1)); +i__$1 = G__926; +j__$1 = G__927; +len__$1 = G__928; +continue; +} +break; +} +}); +cljs.core.lookup_sentinel = {}; +/** + * Returns true if x is the value false, false otherwise. + */ +cljs.core.false_QMARK_ = (function cljs$core$false_QMARK_(x){ +return x === false; +}); +/** + * Returns true if x is the value true, false otherwise. + */ +cljs.core.true_QMARK_ = (function cljs$core$true_QMARK_(x){ +return x === true; +}); +/** + * Return true if x is a Boolean + */ +cljs.core.boolean_QMARK_ = (function cljs$core$boolean_QMARK_(x){ +return ((x === true) || (x === false)); +}); +/** + * Returns true if x identical to the JavaScript undefined value. + */ +cljs.core.undefined_QMARK_ = (function cljs$core$undefined_QMARK_(x){ +return (void 0 === x); +}); +/** + * Return true if s satisfies ISeq + */ +cljs.core.seq_QMARK_ = (function cljs$core$seq_QMARK_(s){ +if((s == null)){ +return false; +} else { +if(!((s == null))){ +if((((s.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === s.cljs$core$ISeq$)))){ +return true; +} else { +if((!s.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.ISeq,s); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.ISeq,s); +} +} +}); +/** + * Return true if the seq function is supported for s + */ +cljs.core.seqable_QMARK_ = (function cljs$core$seqable_QMARK_(s){ +var or__3936__auto__ = ((!((s == null)))?(((((s.cljs$lang$protocol_mask$partition0$ & (8388608))) || ((cljs.core.PROTOCOL_SENTINEL === s.cljs$core$ISeqable$))))?true:(((!s.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable,s):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISeqable,s)); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return ((cljs.core.array_QMARK_(s)) || (typeof s === 'string')); +} +}); +/** + * Coerce to boolean + */ +cljs.core.boolean$ = (function cljs$core$boolean(x){ +if((x == null)){ +return false; +} else { +if(x === false){ +return false; +} else { +return true; + +} +} +}); +/** + * Returns true if f returns true for fn? or satisfies IFn. + */ +cljs.core.ifn_QMARK_ = (function cljs$core$ifn_QMARK_(f){ +var or__3936__auto__ = cljs.core.fn_QMARK_(f); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +if(!((f == null))){ +if((((f.cljs$lang$protocol_mask$partition0$ & (1))) || ((cljs.core.PROTOCOL_SENTINEL === f.cljs$core$IFn$)))){ +return true; +} else { +if((!f.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IFn,f); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IFn,f); +} +} +}); +/** + * Returns true if n is a JavaScript number with no decimal part. + */ +cljs.core.integer_QMARK_ = (function cljs$core$integer_QMARK_(n){ +return ((typeof n === 'number') && (!(isNaN(n))) && (!((n === Infinity))) && ((parseFloat(n) === parseInt(n,(10))))); +}); +/** + * Return true if x satisfies integer? or is an instance of goog.math.Integer + * or goog.math.Long. + */ +cljs.core.int_QMARK_ = (function cljs$core$int_QMARK_(x){ +return ((cljs.core.integer_QMARK_(x)) || ((x instanceof goog.math.Integer)) || ((x instanceof goog.math.Long))); +}); +/** + * Return true if x satisfies int? and is positive. + */ +cljs.core.pos_int_QMARK_ = (function cljs$core$pos_int_QMARK_(x){ +if(cljs.core.integer_QMARK_(x)){ +return (x > (0)); +} else { +if((x instanceof goog.math.Integer)){ +return ((cljs.core.not(x.isNegative())) && (cljs.core.not(x.isZero()))); +} else { +if((x instanceof goog.math.Long)){ +return ((cljs.core.not(x.isNegative())) && (cljs.core.not(x.isZero()))); +} else { +return false; + +} +} +} +}); +/** + * Return true if x satisfies int? and is negative. + */ +cljs.core.neg_int_QMARK_ = (function cljs$core$neg_int_QMARK_(x){ +if(cljs.core.integer_QMARK_(x)){ +return (x < (0)); +} else { +if((x instanceof goog.math.Integer)){ +return x.isNegative(); +} else { +if((x instanceof goog.math.Long)){ +return x.isNegative(); +} else { +return false; + +} +} +} +}); +/** + * Return true if x satisfies int? and is a natural integer value. + */ +cljs.core.nat_int_QMARK_ = (function cljs$core$nat_int_QMARK_(x){ +if(cljs.core.integer_QMARK_(x)){ +return !((x < (0))); +} else { +if((x instanceof goog.math.Integer)){ +return cljs.core.not(x.isNegative()); +} else { +if((x instanceof goog.math.Long)){ +return cljs.core.not(x.isNegative()); +} else { +return false; + +} +} +} +}); +/** + * Returns true for JavaScript numbers, false otherwise. + */ +cljs.core.float_QMARK_ = (function cljs$core$float_QMARK_(x){ +return typeof x === 'number'; +}); +/** + * Returns true for JavaScript numbers, false otherwise. + */ +cljs.core.double_QMARK_ = (function cljs$core$double_QMARK_(x){ +return typeof x === 'number'; +}); +/** + * Returns true for Infinity and -Infinity values. + */ +cljs.core.infinite_QMARK_ = (function cljs$core$infinite_QMARK_(x){ +return (((x === Number.POSITIVE_INFINITY)) || ((x === Number.NEGATIVE_INFINITY))); +}); +/** + * Returns true if key is present in the given collection, otherwise + * returns false. Note that for numerically indexed collections like + * vectors and arrays, this tests if the numeric key is within the + * range of indexes. 'contains?' operates constant or logarithmic time; + * it will not perform a linear search for a value. See also 'some'. + */ +cljs.core.contains_QMARK_ = (function cljs$core$contains_QMARK_(coll,v){ +if((cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,v,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)){ +return false; +} else { +return true; +} +}); +/** + * Returns the map entry for key, or nil if key not present. + */ +cljs.core.find = (function cljs$core$find(coll,k){ +if(cljs.core.ifind_QMARK_(coll)){ +return cljs.core._find(coll,k); +} else { +if(((!((coll == null))) && (cljs.core.associative_QMARK_(coll)) && (cljs.core.contains_QMARK_(coll,k)))){ +return (new cljs.core.MapEntry(k,cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,k),null)); +} else { +return null; +} +} +}); +/** + * Returns true if no two of the arguments are = + */ +cljs.core.distinct_QMARK_ = (function cljs$core$distinct_QMARK_(var_args){ +var G__940 = arguments.length; +switch (G__940) { +case 1: +return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___942 = arguments.length; +var i__4519__auto___943 = (0); +while(true){ +if((i__4519__auto___943 < len__4518__auto___942)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___943])); + +var G__944 = (i__4519__auto___943 + (1)); +i__4519__auto___943 = G__944; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return !(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)); +}); + +cljs.core.distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +if(!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y))){ +var s = cljs.core.PersistentHashSet.createAsIfByAssoc([x,y]); +var xs = more; +while(true){ +var x__$1 = cljs.core.first(xs); +var etc = cljs.core.next(xs); +if(cljs.core.truth_(xs)){ +if(cljs.core.contains_QMARK_(s,x__$1)){ +return false; +} else { +var G__945 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(s,x__$1); +var G__946 = etc; +s = G__945; +xs = G__946; +continue; +} +} else { +return true; +} +break; +} +} else { +return false; +} +}); + +/** @this {Function} */ +cljs.core.distinct_QMARK_.cljs$lang$applyTo = (function (seq937){ +var G__938 = cljs.core.first(seq937); +var seq937__$1 = cljs.core.next(seq937); +var G__939 = cljs.core.first(seq937__$1); +var seq937__$2 = cljs.core.next(seq937__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__938,G__939,seq937__$2); +}); + +cljs.core.distinct_QMARK_.cljs$lang$maxFixedArity = (2); + +/** + * Comparator. Returns a negative number, zero, or a positive number + * when x is logically 'less than', 'equal to', or 'greater than' + * y. Uses IComparable if available and google.array.defaultCompare for objects + * of the same type and special-cases nil to be less than any other object. + */ +cljs.core.compare = (function cljs$core$compare(x,y){ +if((x === y)){ +return (0); +} else { +if((x == null)){ +return (-1); +} else { +if((y == null)){ +return (1); +} else { +if(typeof x === 'number'){ +if(typeof y === 'number'){ +return goog.array.defaultCompare(x,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +} else { +if(((!((x == null)))?(((((x.cljs$lang$protocol_mask$partition1$ & (2048))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IComparable$))))?true:(((!x.cljs$lang$protocol_mask$partition1$))?cljs.core.native_satisfies_QMARK_(cljs.core.IComparable,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IComparable,x))){ +return cljs.core._compare(x,y); +} else { +if(((((typeof x === 'string') || (cljs.core.array_QMARK_(x)) || (x === true) || (x === false))) && ((cljs.core.type(x) === cljs.core.type(y))))){ +return goog.array.defaultCompare(x,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} + +} +} +} +} +} +}); +/** + * Compare indexed collection. + */ +cljs.core.compare_indexed = (function cljs$core$compare_indexed(var_args){ +var G__949 = arguments.length; +switch (G__949) { +case 2: +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 4: +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2 = (function (xs,ys){ +var xl = cljs.core.count(xs); +var yl = cljs.core.count(ys); +if((xl < yl)){ +return (-1); +} else { +if((xl > yl)){ +return (1); +} else { +if((xl === (0))){ +return (0); +} else { +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4(xs,ys,xl,(0)); + +} +} +} +}); + +cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$4 = (function (xs,ys,len,n){ +while(true){ +var d = cljs.core.compare(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(xs,n),cljs.core.nth.cljs$core$IFn$_invoke$arity$2(ys,n)); +if((((d === (0))) && (((n + (1)) < len)))){ +var G__951 = xs; +var G__952 = ys; +var G__953 = len; +var G__954 = (n + (1)); +xs = G__951; +ys = G__952; +len = G__953; +n = G__954; +continue; +} else { +return d; +} +break; +} +}); + +cljs.core.compare_indexed.cljs$lang$maxFixedArity = 4; + +/** + * Given a fn that might be boolean valued or a comparator, + * return a fn that is a comparator. + */ +cljs.core.fn__GT_comparator = (function cljs$core$fn__GT_comparator(f){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(f,cljs.core.compare)){ +return cljs.core.compare; +} else { +return (function (x,y){ +var r = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null,x,y)); +if(typeof r === 'number'){ +return r; +} else { +if(cljs.core.truth_(r)){ +return (-1); +} else { +if(cljs.core.truth_((f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(y,x) : f.call(null,y,x)))){ +return (1); +} else { +return (0); +} +} +} +}); +} +}); +/** + * Returns a sorted sequence of the items in coll. Comp can be + * boolean-valued comparison function, or a -/0/+ valued comparator. + * Comp defaults to compare. + */ +cljs.core.sort = (function cljs$core$sort(var_args){ +var G__956 = arguments.length; +switch (G__956) { +case 1: +return cljs.core.sort.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.sort.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.sort.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +return cljs.core.sort.cljs$core$IFn$_invoke$arity$2(cljs.core.compare,coll); +}); + +cljs.core.sort.cljs$core$IFn$_invoke$arity$2 = (function (comp,coll){ +if(cljs.core.seq(coll)){ +var a = cljs.core.to_array(coll); +var G__957_960 = a; +var G__958_961 = cljs.core.fn__GT_comparator(comp); +goog.array.stableSort(G__957_960,G__958_961); + +return cljs.core.seq(a); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.sort.cljs$lang$maxFixedArity = 2; + +/** + * Returns a sorted sequence of the items in coll, where the sort + * order is determined by comparing (keyfn item). Comp can be + * boolean-valued comparison function, or a -/0/+ valued comparator. + * Comp defaults to compare. + */ +cljs.core.sort_by = (function cljs$core$sort_by(var_args){ +var G__963 = arguments.length; +switch (G__963) { +case 2: +return cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.sort_by.cljs$core$IFn$_invoke$arity$2 = (function (keyfn,coll){ +return cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3(keyfn,cljs.core.compare,coll); +}); + +cljs.core.sort_by.cljs$core$IFn$_invoke$arity$3 = (function (keyfn,comp,coll){ +return cljs.core.sort.cljs$core$IFn$_invoke$arity$2((function (x,y){ +var G__965 = (keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(x) : keyfn.call(null,x)); +var G__966 = (keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(y) : keyfn.call(null,y)); +var fexpr__964 = cljs.core.fn__GT_comparator(comp); +return (fexpr__964.cljs$core$IFn$_invoke$arity$2 ? fexpr__964.cljs$core$IFn$_invoke$arity$2(G__965,G__966) : fexpr__964.call(null,G__965,G__966)); +}),coll); +}); + +cljs.core.sort_by.cljs$lang$maxFixedArity = 3; + +cljs.core.seq_reduce = (function cljs$core$seq_reduce(var_args){ +var G__969 = arguments.length; +switch (G__969) { +case 2: +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +var temp__5455__auto__ = cljs.core.seq(coll); +if(temp__5455__auto__){ +var s = temp__5455__auto__; +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(f,cljs.core.first(s),cljs.core.next(s)); +} else { +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +} +}); + +cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3 = (function (f,val,coll){ +var val__$1 = val; +var coll__$1 = cljs.core.seq(coll); +while(true){ +if(coll__$1){ +var nval = (function (){var G__970 = val__$1; +var G__971 = cljs.core.first(coll__$1); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__970,G__971) : f.call(null,G__970,G__971)); +})(); +if(cljs.core.reduced_QMARK_(nval)){ +return cljs.core.deref(nval); +} else { +var G__973 = nval; +var G__974 = cljs.core.next(coll__$1); +val__$1 = G__973; +coll__$1 = G__974; +continue; +} +} else { +return val__$1; +} +break; +} +}); + +cljs.core.seq_reduce.cljs$lang$maxFixedArity = 3; + +/** + * Return a random permutation of coll + */ +cljs.core.shuffle = (function cljs$core$shuffle(coll){ +var a = cljs.core.to_array(coll); +goog.array.shuffle(a); + +return cljs.core.vec(a); +}); +cljs.core.iter_reduce = (function cljs$core$iter_reduce(var_args){ +var G__976 = arguments.length; +switch (G__976) { +case 2: +return cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2 = (function (coll,f){ +var iter = cljs.core._iterator(coll); +if(cljs.core.truth_(iter.hasNext())){ +var init = iter.next(); +var acc = init; +while(true){ +if(iter.hasNext()){ +var nacc = (function (){var G__977 = acc; +var G__978 = iter.next(); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__977,G__978) : f.call(null,G__977,G__978)); +})(); +if(cljs.core.reduced_QMARK_(nacc)){ +return cljs.core.deref(nacc); +} else { +var G__982 = nacc; +acc = G__982; +continue; +} +} else { +return acc; +} +break; +} +} else { +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +} +}); + +cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3 = (function (coll,f,init){ +var iter = cljs.core._iterator(coll); +var acc = init; +while(true){ +if(iter.hasNext()){ +var nacc = (function (){var G__979 = acc; +var G__980 = iter.next(); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__979,G__980) : f.call(null,G__979,G__980)); +})(); +if(cljs.core.reduced_QMARK_(nacc)){ +return cljs.core.deref(nacc); +} else { +var G__983 = nacc; +acc = G__983; +continue; +} +} else { +return acc; +} +break; +} +}); + +cljs.core.iter_reduce.cljs$lang$maxFixedArity = 3; + +/** + * f should be a function of 2 arguments. If val is not supplied, + * returns the result of applying f to the first 2 items in coll, then + * applying f to that result and the 3rd item, etc. If coll contains no + * items, f must accept no arguments as well, and reduce returns the + * result of calling f with no arguments. If coll has only 1 item, it + * is returned and f is not called. If val is supplied, returns the + * result of applying f to val and the first item in coll, then + * applying f to that result and the 2nd item, etc. If coll contains no + * items, returns val and f is not called. + */ +cljs.core.reduce = (function cljs$core$reduce(var_args){ +var G__985 = arguments.length; +switch (G__985) { +case 2: +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.reduce.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (524288))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IReduce$))))?true:false):false)){ +return coll.cljs$core$IReduce$_reduce$arity$2(null,f); +} else { +if(cljs.core.array_QMARK_(coll)){ +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(coll,f); +} else { +if(typeof coll === 'string'){ +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$2(coll,f); +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,coll)){ +return cljs.core._reduce.cljs$core$IFn$_invoke$arity$2(coll,f); +} else { +if(cljs.core.iterable_QMARK_(coll)){ +return cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2(coll,f); +} else { +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll); + +} +} +} +} +} +}); + +cljs.core.reduce.cljs$core$IFn$_invoke$arity$3 = (function (f,val,coll){ +if(((!((coll == null)))?(((((coll.cljs$lang$protocol_mask$partition0$ & (524288))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IReduce$))))?true:false):false)){ +return coll.cljs$core$IReduce$_reduce$arity$3(null,f,val); +} else { +if(cljs.core.array_QMARK_(coll)){ +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val); +} else { +if(typeof coll === 'string'){ +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val); +} else { +if(cljs.core.native_satisfies_QMARK_(cljs.core.IReduce,coll)){ +return cljs.core._reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val); +} else { +if(cljs.core.iterable_QMARK_(coll)){ +return cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3(coll,f,val); +} else { +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,val,coll); + +} +} +} +} +} +}); + +cljs.core.reduce.cljs$lang$maxFixedArity = 3; + +/** + * Reduces an associative collection. f should be a function of 3 + * arguments. Returns the result of applying f to init, the first key + * and the first value in coll, then applying f to that result and the + * 2nd key and value, etc. If coll contains no entries, returns init + * and f is not called. Note that reduce-kv is supported on vectors, + * where the keys will be the ordinals. + */ +cljs.core.reduce_kv = (function cljs$core$reduce_kv(f,init,coll){ +if(!((coll == null))){ +return cljs.core._kv_reduce(coll,f,init); +} else { +return init; +} +}); +/** + * Returns its argument. + */ +cljs.core.identity = (function cljs$core$identity(x){ +return x; +}); +/** + * Takes a reducing function f of 2 args and returns a fn suitable for + * transduce by adding an arity-1 signature that calls cf (default - + * identity) on the result argument. + */ +cljs.core.completing = (function cljs$core$completing(var_args){ +var G__990 = arguments.length; +switch (G__990) { +case 1: +return cljs.core.completing.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.completing.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.completing.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return cljs.core.completing.cljs$core$IFn$_invoke$arity$2(f,cljs.core.identity); +}); + +cljs.core.completing.cljs$core$IFn$_invoke$arity$2 = (function (f,cf){ +return (function() { +var G__992 = null; +var G__992__0 = (function (){ +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +}); +var G__992__1 = (function (x){ +return (cf.cljs$core$IFn$_invoke$arity$1 ? cf.cljs$core$IFn$_invoke$arity$1(x) : cf.call(null,x)); +}); +var G__992__2 = (function (x,y){ +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null,x,y)); +}); +G__992 = function(x,y){ +switch(arguments.length){ +case 0: +return G__992__0.call(this); +case 1: +return G__992__1.call(this,x); +case 2: +return G__992__2.call(this,x,y); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__992.cljs$core$IFn$_invoke$arity$0 = G__992__0; +G__992.cljs$core$IFn$_invoke$arity$1 = G__992__1; +G__992.cljs$core$IFn$_invoke$arity$2 = G__992__2; +return G__992; +})() +}); + +cljs.core.completing.cljs$lang$maxFixedArity = 2; + +/** + * reduce with a transformation of f (xf). If init is not + * supplied, (f) will be called to produce it. f should be a reducing + * step function that accepts both 1 and 2 arguments, if it accepts + * only 2 you can add the arity-1 with 'completing'. Returns the result + * of applying (the transformed) xf to init and the first item in coll, + * then applying xf to that result and the 2nd item, etc. If coll + * contains no items, returns init and f is not called. Note that + * certain transforms may inject or skip items. + */ +cljs.core.transduce = (function cljs$core$transduce(var_args){ +var G__994 = arguments.length; +switch (G__994) { +case 3: +return cljs.core.transduce.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.transduce.cljs$core$IFn$_invoke$arity$3 = (function (xform,f,coll){ +return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(xform,f,(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)),coll); +}); + +cljs.core.transduce.cljs$core$IFn$_invoke$arity$4 = (function (xform,f,init,coll){ +var f__$1 = (xform.cljs$core$IFn$_invoke$arity$1 ? xform.cljs$core$IFn$_invoke$arity$1(f) : xform.call(null,f)); +var ret = cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(f__$1,init,coll); +return (f__$1.cljs$core$IFn$_invoke$arity$1 ? f__$1.cljs$core$IFn$_invoke$arity$1(ret) : f__$1.call(null,ret)); +}); + +cljs.core.transduce.cljs$lang$maxFixedArity = 4; + +/** + * Returns the sum of nums. (+) returns 0. + */ +cljs.core._PLUS_ = (function cljs$core$_PLUS_(var_args){ +var G__1000 = arguments.length; +switch (G__1000) { +case 0: +return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1002 = arguments.length; +var i__4519__auto___1003 = (0); +while(true){ +if((i__4519__auto___1003 < len__4518__auto___1002)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1003])); + +var G__1004 = (i__4519__auto___1003 + (1)); +i__4519__auto___1003 = G__1004; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (0); +}); + +cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x + y); +}); + +cljs.core._PLUS_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._PLUS_,(x + y),more); +}); + +/** @this {Function} */ +cljs.core._PLUS_.cljs$lang$applyTo = (function (seq997){ +var G__998 = cljs.core.first(seq997); +var seq997__$1 = cljs.core.next(seq997); +var G__999 = cljs.core.first(seq997__$1); +var seq997__$2 = cljs.core.next(seq997__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__998,G__999,seq997__$2); +}); + +cljs.core._PLUS_.cljs$lang$maxFixedArity = (2); + +/** + * If no ys are supplied, returns the negation of x, else subtracts + * the ys from x and returns the result. + */ +cljs.core._ = (function cljs$core$_(var_args){ +var G__1009 = arguments.length; +switch (G__1009) { +case 1: +return cljs.core._.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1011 = arguments.length; +var i__4519__auto___1012 = (0); +while(true){ +if((i__4519__auto___1012 < len__4518__auto___1011)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1012])); + +var G__1013 = (i__4519__auto___1012 + (1)); +i__4519__auto___1012 = G__1013; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (- x); +}); + +cljs.core._.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x - y); +}); + +cljs.core._.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._,(x - y),more); +}); + +/** @this {Function} */ +cljs.core._.cljs$lang$applyTo = (function (seq1006){ +var G__1007 = cljs.core.first(seq1006); +var seq1006__$1 = cljs.core.next(seq1006); +var G__1008 = cljs.core.first(seq1006__$1); +var seq1006__$2 = cljs.core.next(seq1006__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1007,G__1008,seq1006__$2); +}); + +cljs.core._.cljs$lang$maxFixedArity = (2); + +/** + * Returns the product of nums. (*) returns 1. + */ +cljs.core._STAR_ = (function cljs$core$_STAR_(var_args){ +var G__1018 = arguments.length; +switch (G__1018) { +case 0: +return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1020 = arguments.length; +var i__4519__auto___1021 = (0); +while(true){ +if((i__4519__auto___1021 < len__4518__auto___1020)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1021])); + +var G__1022 = (i__4519__auto___1021 + (1)); +i__4519__auto___1021 = G__1022; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._STAR_.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (1); +}); + +cljs.core._STAR_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core._STAR_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x * y); +}); + +cljs.core._STAR_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._STAR_,(x * y),more); +}); + +/** @this {Function} */ +cljs.core._STAR_.cljs$lang$applyTo = (function (seq1015){ +var G__1016 = cljs.core.first(seq1015); +var seq1015__$1 = cljs.core.next(seq1015); +var G__1017 = cljs.core.first(seq1015__$1); +var seq1015__$2 = cljs.core.next(seq1015__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1016,G__1017,seq1015__$2); +}); + +cljs.core._STAR_.cljs$lang$maxFixedArity = (2); + +/** + * If no denominators are supplied, returns 1/numerator, + * else returns numerator divided by all of the denominators. + */ +cljs.core._SLASH_ = (function cljs$core$_SLASH_(var_args){ +var G__1027 = arguments.length; +switch (G__1027) { +case 1: +return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1029 = arguments.length; +var i__4519__auto___1030 = (0); +while(true){ +if((i__4519__auto___1030 < len__4518__auto___1029)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1030])); + +var G__1031 = (i__4519__auto___1030 + (1)); +i__4519__auto___1030 = G__1031; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return ((1) / x); +}); + +cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x / y); +}); + +cljs.core._SLASH_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._SLASH_,(x / y),more); +}); + +/** @this {Function} */ +cljs.core._SLASH_.cljs$lang$applyTo = (function (seq1024){ +var G__1025 = cljs.core.first(seq1024); +var seq1024__$1 = cljs.core.next(seq1024); +var G__1026 = cljs.core.first(seq1024__$1); +var seq1024__$2 = cljs.core.next(seq1024__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1025,G__1026,seq1024__$2); +}); + +cljs.core._SLASH_.cljs$lang$maxFixedArity = (2); + +/** + * Returns non-nil if nums are in monotonically increasing order, + * otherwise false. + */ +cljs.core._LT_ = (function cljs$core$_LT_(var_args){ +var G__1036 = arguments.length; +switch (G__1036) { +case 1: +return cljs.core._LT_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._LT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1038 = arguments.length; +var i__4519__auto___1039 = (0); +while(true){ +if((i__4519__auto___1039 < len__4518__auto___1038)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1039])); + +var G__1040 = (i__4519__auto___1039 + (1)); +i__4519__auto___1039 = G__1040; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._LT_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core._LT_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x < y); +}); + +cljs.core._LT_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +while(true){ +if((x < y)){ +if(cljs.core.next(more)){ +var G__1041 = y; +var G__1042 = cljs.core.first(more); +var G__1043 = cljs.core.next(more); +x = G__1041; +y = G__1042; +more = G__1043; +continue; +} else { +return (y < cljs.core.first(more)); +} +} else { +return false; +} +break; +} +}); + +/** @this {Function} */ +cljs.core._LT_.cljs$lang$applyTo = (function (seq1033){ +var G__1034 = cljs.core.first(seq1033); +var seq1033__$1 = cljs.core.next(seq1033); +var G__1035 = cljs.core.first(seq1033__$1); +var seq1033__$2 = cljs.core.next(seq1033__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1034,G__1035,seq1033__$2); +}); + +cljs.core._LT_.cljs$lang$maxFixedArity = (2); + +/** + * Returns non-nil if nums are in monotonically non-decreasing order, + * otherwise false. + */ +cljs.core._LT__EQ_ = (function cljs$core$_LT__EQ_(var_args){ +var G__1048 = arguments.length; +switch (G__1048) { +case 1: +return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1050 = arguments.length; +var i__4519__auto___1051 = (0); +while(true){ +if((i__4519__auto___1051 < len__4518__auto___1050)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1051])); + +var G__1052 = (i__4519__auto___1051 + (1)); +i__4519__auto___1051 = G__1052; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x <= y); +}); + +cljs.core._LT__EQ_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +while(true){ +if((x <= y)){ +if(cljs.core.next(more)){ +var G__1053 = y; +var G__1054 = cljs.core.first(more); +var G__1055 = cljs.core.next(more); +x = G__1053; +y = G__1054; +more = G__1055; +continue; +} else { +return (y <= cljs.core.first(more)); +} +} else { +return false; +} +break; +} +}); + +/** @this {Function} */ +cljs.core._LT__EQ_.cljs$lang$applyTo = (function (seq1045){ +var G__1046 = cljs.core.first(seq1045); +var seq1045__$1 = cljs.core.next(seq1045); +var G__1047 = cljs.core.first(seq1045__$1); +var seq1045__$2 = cljs.core.next(seq1045__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1046,G__1047,seq1045__$2); +}); + +cljs.core._LT__EQ_.cljs$lang$maxFixedArity = (2); + +/** + * Returns non-nil if nums are in monotonically decreasing order, + * otherwise false. + */ +cljs.core._GT_ = (function cljs$core$_GT_(var_args){ +var G__1060 = arguments.length; +switch (G__1060) { +case 1: +return cljs.core._GT_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._GT_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1062 = arguments.length; +var i__4519__auto___1063 = (0); +while(true){ +if((i__4519__auto___1063 < len__4518__auto___1062)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1063])); + +var G__1064 = (i__4519__auto___1063 + (1)); +i__4519__auto___1063 = G__1064; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._GT_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core._GT_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x > y); +}); + +cljs.core._GT_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +while(true){ +if((x > y)){ +if(cljs.core.next(more)){ +var G__1065 = y; +var G__1066 = cljs.core.first(more); +var G__1067 = cljs.core.next(more); +x = G__1065; +y = G__1066; +more = G__1067; +continue; +} else { +return (y > cljs.core.first(more)); +} +} else { +return false; +} +break; +} +}); + +/** @this {Function} */ +cljs.core._GT_.cljs$lang$applyTo = (function (seq1057){ +var G__1058 = cljs.core.first(seq1057); +var seq1057__$1 = cljs.core.next(seq1057); +var G__1059 = cljs.core.first(seq1057__$1); +var seq1057__$2 = cljs.core.next(seq1057__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1058,G__1059,seq1057__$2); +}); + +cljs.core._GT_.cljs$lang$maxFixedArity = (2); + +/** + * Returns non-nil if nums are in monotonically non-increasing order, + * otherwise false. + */ +cljs.core._GT__EQ_ = (function cljs$core$_GT__EQ_(var_args){ +var G__1072 = arguments.length; +switch (G__1072) { +case 1: +return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1074 = arguments.length; +var i__4519__auto___1075 = (0); +while(true){ +if((i__4519__auto___1075 < len__4518__auto___1074)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1075])); + +var G__1076 = (i__4519__auto___1075 + (1)); +i__4519__auto___1075 = G__1076; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x >= y); +}); + +cljs.core._GT__EQ_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +while(true){ +if((x >= y)){ +if(cljs.core.next(more)){ +var G__1077 = y; +var G__1078 = cljs.core.first(more); +var G__1079 = cljs.core.next(more); +x = G__1077; +y = G__1078; +more = G__1079; +continue; +} else { +return (y >= cljs.core.first(more)); +} +} else { +return false; +} +break; +} +}); + +/** @this {Function} */ +cljs.core._GT__EQ_.cljs$lang$applyTo = (function (seq1069){ +var G__1070 = cljs.core.first(seq1069); +var seq1069__$1 = cljs.core.next(seq1069); +var G__1071 = cljs.core.first(seq1069__$1); +var seq1069__$2 = cljs.core.next(seq1069__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1070,G__1071,seq1069__$2); +}); + +cljs.core._GT__EQ_.cljs$lang$maxFixedArity = (2); + +/** + * Returns a number one less than num. + */ +cljs.core.dec = (function cljs$core$dec(x){ +return (x - (1)); +}); +/** + * Returns the greatest of the nums. + */ +cljs.core.max = (function cljs$core$max(var_args){ +var G__1084 = arguments.length; +switch (G__1084) { +case 1: +return cljs.core.max.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.max.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1086 = arguments.length; +var i__4519__auto___1087 = (0); +while(true){ +if((i__4519__auto___1087 < len__4518__auto___1086)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1087])); + +var G__1088 = (i__4519__auto___1087 + (1)); +i__4519__auto___1087 = G__1088; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.max.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.max.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core.max.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +var x__4024__auto__ = x; +var y__4025__auto__ = y; +return ((x__4024__auto__ > y__4025__auto__) ? x__4024__auto__ : y__4025__auto__); +}); + +cljs.core.max.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.max,(function (){var x__4024__auto__ = x; +var y__4025__auto__ = y; +return ((x__4024__auto__ > y__4025__auto__) ? x__4024__auto__ : y__4025__auto__); +})(),more); +}); + +/** @this {Function} */ +cljs.core.max.cljs$lang$applyTo = (function (seq1081){ +var G__1082 = cljs.core.first(seq1081); +var seq1081__$1 = cljs.core.next(seq1081); +var G__1083 = cljs.core.first(seq1081__$1); +var seq1081__$2 = cljs.core.next(seq1081__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1082,G__1083,seq1081__$2); +}); + +cljs.core.max.cljs$lang$maxFixedArity = (2); + +/** + * Returns the least of the nums. + */ +cljs.core.min = (function cljs$core$min(var_args){ +var G__1093 = arguments.length; +switch (G__1093) { +case 1: +return cljs.core.min.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.min.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1095 = arguments.length; +var i__4519__auto___1096 = (0); +while(true){ +if((i__4519__auto___1096 < len__4518__auto___1095)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1096])); + +var G__1097 = (i__4519__auto___1096 + (1)); +i__4519__auto___1096 = G__1097; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.min.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.min.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core.min.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +var x__4027__auto__ = x; +var y__4028__auto__ = y; +return ((x__4027__auto__ < y__4028__auto__) ? x__4027__auto__ : y__4028__auto__); +}); + +cljs.core.min.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.min,(function (){var x__4027__auto__ = x; +var y__4028__auto__ = y; +return ((x__4027__auto__ < y__4028__auto__) ? x__4027__auto__ : y__4028__auto__); +})(),more); +}); + +/** @this {Function} */ +cljs.core.min.cljs$lang$applyTo = (function (seq1090){ +var G__1091 = cljs.core.first(seq1090); +var seq1090__$1 = cljs.core.next(seq1090); +var G__1092 = cljs.core.first(seq1090__$1); +var seq1090__$2 = cljs.core.next(seq1090__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1091,G__1092,seq1090__$2); +}); + +cljs.core.min.cljs$lang$maxFixedArity = (2); + +cljs.core.byte$ = (function cljs$core$byte(x){ +return x; +}); +/** + * Coerce to char + */ +cljs.core.char$ = (function cljs$core$char(x){ +if(typeof x === 'number'){ +return String.fromCharCode(x); +} else { +if(((typeof x === 'string') && ((x.length === (1))))){ +return x; +} else { +throw (new Error("Argument to char must be a character or number")); + +} +} +}); +cljs.core.short$ = (function cljs$core$short(x){ +return x; +}); +cljs.core.float$ = (function cljs$core$float(x){ +return x; +}); +cljs.core.double$ = (function cljs$core$double(x){ +return x; +}); +cljs.core.unchecked_byte = (function cljs$core$unchecked_byte(x){ +return x; +}); +cljs.core.unchecked_char = (function cljs$core$unchecked_char(x){ +return x; +}); +cljs.core.unchecked_short = (function cljs$core$unchecked_short(x){ +return x; +}); +cljs.core.unchecked_float = (function cljs$core$unchecked_float(x){ +return x; +}); +cljs.core.unchecked_double = (function cljs$core$unchecked_double(x){ +return x; +}); +/** + * Returns the sum of nums. (+) returns 0. + */ +cljs.core.unchecked_add = (function cljs$core$unchecked_add(var_args){ +var G__1102 = arguments.length; +switch (G__1102) { +case 0: +return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1104 = arguments.length; +var i__4519__auto___1105 = (0); +while(true){ +if((i__4519__auto___1105 < len__4518__auto___1104)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1105])); + +var G__1106 = (i__4519__auto___1105 + (1)); +i__4519__auto___1105 = G__1106; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (0); +}); + +cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x + y); +}); + +cljs.core.unchecked_add.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_add,(x + y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_add.cljs$lang$applyTo = (function (seq1099){ +var G__1100 = cljs.core.first(seq1099); +var seq1099__$1 = cljs.core.next(seq1099); +var G__1101 = cljs.core.first(seq1099__$1); +var seq1099__$2 = cljs.core.next(seq1099__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1100,G__1101,seq1099__$2); +}); + +cljs.core.unchecked_add.cljs$lang$maxFixedArity = (2); + +/** + * Returns the sum of nums. (+) returns 0. + */ +cljs.core.unchecked_add_int = (function cljs$core$unchecked_add_int(var_args){ +var G__1111 = arguments.length; +switch (G__1111) { +case 0: +return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1113 = arguments.length; +var i__4519__auto___1114 = (0); +while(true){ +if((i__4519__auto___1114 < len__4518__auto___1113)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1114])); + +var G__1115 = (i__4519__auto___1114 + (1)); +i__4519__auto___1114 = G__1115; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (0); +}); + +cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x + y); +}); + +cljs.core.unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_add_int,(x + y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_add_int.cljs$lang$applyTo = (function (seq1108){ +var G__1109 = cljs.core.first(seq1108); +var seq1108__$1 = cljs.core.next(seq1108); +var G__1110 = cljs.core.first(seq1108__$1); +var seq1108__$2 = cljs.core.next(seq1108__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1109,G__1110,seq1108__$2); +}); + +cljs.core.unchecked_add_int.cljs$lang$maxFixedArity = (2); + +/** + * Returns a number one less than x, an int. + */ +cljs.core.unchecked_dec = (function cljs$core$unchecked_dec(x){ +return (x - (1)); +}); +/** + * Returns a number one less than x, an int. + */ +cljs.core.unchecked_dec_int = (function cljs$core$unchecked_dec_int(x){ +return (x - (1)); +}); +/** + * If no denominators are supplied, returns 1/numerator, + * else returns numerator divided by all of the denominators. + */ +cljs.core.unchecked_divide_int = (function cljs$core$unchecked_divide_int(var_args){ +var G__1120 = arguments.length; +switch (G__1120) { +case 1: +return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1122 = arguments.length; +var i__4519__auto___1123 = (0); +while(true){ +if((i__4519__auto___1123 < len__4518__auto___1122)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1123])); + +var G__1124 = (i__4519__auto___1123 + (1)); +i__4519__auto___1123 = G__1124; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return ((1) / x); +}); + +cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x / y); +}); + +cljs.core.unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_divide_int,(x / y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_divide_int.cljs$lang$applyTo = (function (seq1117){ +var G__1118 = cljs.core.first(seq1117); +var seq1117__$1 = cljs.core.next(seq1117); +var G__1119 = cljs.core.first(seq1117__$1); +var seq1117__$2 = cljs.core.next(seq1117__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1118,G__1119,seq1117__$2); +}); + +cljs.core.unchecked_divide_int.cljs$lang$maxFixedArity = (2); + +cljs.core.unchecked_inc = (function cljs$core$unchecked_inc(x){ +return (x + (1)); +}); +cljs.core.unchecked_inc_int = (function cljs$core$unchecked_inc_int(x){ +return (x + (1)); +}); +/** + * Returns the product of nums. (*) returns 1. + */ +cljs.core.unchecked_multiply = (function cljs$core$unchecked_multiply(var_args){ +var G__1129 = arguments.length; +switch (G__1129) { +case 0: +return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1131 = arguments.length; +var i__4519__auto___1132 = (0); +while(true){ +if((i__4519__auto___1132 < len__4518__auto___1131)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1132])); + +var G__1133 = (i__4519__auto___1132 + (1)); +i__4519__auto___1132 = G__1133; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (1); +}); + +cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x * y); +}); + +cljs.core.unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_multiply,(x * y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_multiply.cljs$lang$applyTo = (function (seq1126){ +var G__1127 = cljs.core.first(seq1126); +var seq1126__$1 = cljs.core.next(seq1126); +var G__1128 = cljs.core.first(seq1126__$1); +var seq1126__$2 = cljs.core.next(seq1126__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1127,G__1128,seq1126__$2); +}); + +cljs.core.unchecked_multiply.cljs$lang$maxFixedArity = (2); + +/** + * Returns the product of nums. (*) returns 1. + */ +cljs.core.unchecked_multiply_int = (function cljs$core$unchecked_multiply_int(var_args){ +var G__1138 = arguments.length; +switch (G__1138) { +case 0: +return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1140 = arguments.length; +var i__4519__auto___1141 = (0); +while(true){ +if((i__4519__auto___1141 < len__4518__auto___1140)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1141])); + +var G__1142 = (i__4519__auto___1141 + (1)); +i__4519__auto___1141 = G__1142; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (1); +}); + +cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return x; +}); + +cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x * y); +}); + +cljs.core.unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_multiply_int,(x * y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_multiply_int.cljs$lang$applyTo = (function (seq1135){ +var G__1136 = cljs.core.first(seq1135); +var seq1135__$1 = cljs.core.next(seq1135); +var G__1137 = cljs.core.first(seq1135__$1); +var seq1135__$2 = cljs.core.next(seq1135__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1136,G__1137,seq1135__$2); +}); + +cljs.core.unchecked_multiply_int.cljs$lang$maxFixedArity = (2); + +cljs.core.unchecked_negate = (function cljs$core$unchecked_negate(x){ +return (- x); +}); +cljs.core.unchecked_negate_int = (function cljs$core$unchecked_negate_int(x){ +return (- x); +}); +cljs.core.unchecked_remainder_int = (function cljs$core$unchecked_remainder_int(x,n){ +return cljs.core.mod(x,n); +}); +/** + * If no ys are supplied, returns the negation of x, else subtracts + * the ys from x and returns the result. + */ +cljs.core.unchecked_subtract = (function cljs$core$unchecked_subtract(var_args){ +var G__1147 = arguments.length; +switch (G__1147) { +case 1: +return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1149 = arguments.length; +var i__4519__auto___1150 = (0); +while(true){ +if((i__4519__auto___1150 < len__4518__auto___1149)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1150])); + +var G__1151 = (i__4519__auto___1150 + (1)); +i__4519__auto___1150 = G__1151; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (- x); +}); + +cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x - y); +}); + +cljs.core.unchecked_subtract.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_subtract,(x - y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_subtract.cljs$lang$applyTo = (function (seq1144){ +var G__1145 = cljs.core.first(seq1144); +var seq1144__$1 = cljs.core.next(seq1144); +var G__1146 = cljs.core.first(seq1144__$1); +var seq1144__$2 = cljs.core.next(seq1144__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1145,G__1146,seq1144__$2); +}); + +cljs.core.unchecked_subtract.cljs$lang$maxFixedArity = (2); + +/** + * If no ys are supplied, returns the negation of x, else subtracts + * the ys from x and returns the result. + */ +cljs.core.unchecked_subtract_int = (function cljs$core$unchecked_subtract_int(var_args){ +var G__1156 = arguments.length; +switch (G__1156) { +case 1: +return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1158 = arguments.length; +var i__4519__auto___1159 = (0); +while(true){ +if((i__4519__auto___1159 < len__4518__auto___1158)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1159])); + +var G__1160 = (i__4519__auto___1159 + (1)); +i__4519__auto___1159 = G__1160; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (- x); +}); + +cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x - y); +}); + +cljs.core.unchecked_subtract_int.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.unchecked_subtract_int,(x - y),more); +}); + +/** @this {Function} */ +cljs.core.unchecked_subtract_int.cljs$lang$applyTo = (function (seq1153){ +var G__1154 = cljs.core.first(seq1153); +var seq1153__$1 = cljs.core.next(seq1153); +var G__1155 = cljs.core.first(seq1153__$1); +var seq1153__$2 = cljs.core.next(seq1153__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1154,G__1155,seq1153__$2); +}); + +cljs.core.unchecked_subtract_int.cljs$lang$maxFixedArity = (2); + +cljs.core.fix = (function cljs$core$fix(q){ +if((q >= (0))){ +return Math.floor(q); +} else { +return Math.ceil(q); +} +}); +/** + * Coerce to int by stripping decimal places. + */ +cljs.core.int$ = (function cljs$core$int(x){ +return (x | (0)); +}); +/** + * Coerce to int by stripping decimal places. + */ +cljs.core.unchecked_int = (function cljs$core$unchecked_int(x){ +return cljs.core.fix(x); +}); +/** + * Coerce to long by stripping decimal places. Identical to `int'. + */ +cljs.core.long$ = (function cljs$core$long(x){ +return cljs.core.fix(x); +}); +/** + * Coerce to long by stripping decimal places. Identical to `int'. + */ +cljs.core.unchecked_long = (function cljs$core$unchecked_long(x){ +return cljs.core.fix(x); +}); +cljs.core.booleans = (function cljs$core$booleans(x){ +return x; +}); +cljs.core.bytes = (function cljs$core$bytes(x){ +return x; +}); +cljs.core.chars = (function cljs$core$chars(x){ +return x; +}); +cljs.core.shorts = (function cljs$core$shorts(x){ +return x; +}); +cljs.core.ints = (function cljs$core$ints(x){ +return x; +}); +cljs.core.floats = (function cljs$core$floats(x){ +return x; +}); +cljs.core.doubles = (function cljs$core$doubles(x){ +return x; +}); +cljs.core.longs = (function cljs$core$longs(x){ +return x; +}); +/** + * Modulus of num and div with original javascript behavior. i.e. bug for negative numbers + */ +cljs.core.js_mod = (function cljs$core$js_mod(n,d){ +return (n % d); +}); +/** + * Modulus of num and div. Truncates toward negative infinity. + */ +cljs.core.mod = (function cljs$core$mod(n,d){ +return (((n % d) + d) % d); +}); +/** + * quot[ient] of dividing numerator by denominator. + */ +cljs.core.quot = (function cljs$core$quot(n,d){ +var rem = (n % d); +return cljs.core.fix(((n - rem) / d)); +}); +/** + * remainder of dividing numerator by denominator. + */ +cljs.core.rem = (function cljs$core$rem(n,d){ +var q = cljs.core.quot(n,d); +return (n - (d * q)); +}); +/** + * Bitwise exclusive or + */ +cljs.core.bit_xor = (function cljs$core$bit_xor(var_args){ +var G__1165 = arguments.length; +switch (G__1165) { +case 2: +return cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1167 = arguments.length; +var i__4519__auto___1168 = (0); +while(true){ +if((i__4519__auto___1168 < len__4518__auto___1167)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1168])); + +var G__1169 = (i__4519__auto___1168 + (1)); +i__4519__auto___1168 = G__1169; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x ^ y); +}); + +cljs.core.bit_xor.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_xor,(x ^ y),more); +}); + +/** @this {Function} */ +cljs.core.bit_xor.cljs$lang$applyTo = (function (seq1162){ +var G__1163 = cljs.core.first(seq1162); +var seq1162__$1 = cljs.core.next(seq1162); +var G__1164 = cljs.core.first(seq1162__$1); +var seq1162__$2 = cljs.core.next(seq1162__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1163,G__1164,seq1162__$2); +}); + +cljs.core.bit_xor.cljs$lang$maxFixedArity = (2); + +/** + * Bitwise and + */ +cljs.core.bit_and = (function cljs$core$bit_and(var_args){ +var G__1174 = arguments.length; +switch (G__1174) { +case 2: +return cljs.core.bit_and.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1176 = arguments.length; +var i__4519__auto___1177 = (0); +while(true){ +if((i__4519__auto___1177 < len__4518__auto___1176)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1177])); + +var G__1178 = (i__4519__auto___1177 + (1)); +i__4519__auto___1177 = G__1178; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.bit_and.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x & y); +}); + +cljs.core.bit_and.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_and,(x & y),more); +}); + +/** @this {Function} */ +cljs.core.bit_and.cljs$lang$applyTo = (function (seq1171){ +var G__1172 = cljs.core.first(seq1171); +var seq1171__$1 = cljs.core.next(seq1171); +var G__1173 = cljs.core.first(seq1171__$1); +var seq1171__$2 = cljs.core.next(seq1171__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1172,G__1173,seq1171__$2); +}); + +cljs.core.bit_and.cljs$lang$maxFixedArity = (2); + +/** + * Bitwise or + */ +cljs.core.bit_or = (function cljs$core$bit_or(var_args){ +var G__1183 = arguments.length; +switch (G__1183) { +case 2: +return cljs.core.bit_or.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1185 = arguments.length; +var i__4519__auto___1186 = (0); +while(true){ +if((i__4519__auto___1186 < len__4518__auto___1185)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1186])); + +var G__1187 = (i__4519__auto___1186 + (1)); +i__4519__auto___1186 = G__1187; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.bit_or.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x | y); +}); + +cljs.core.bit_or.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_or,(x | y),more); +}); + +/** @this {Function} */ +cljs.core.bit_or.cljs$lang$applyTo = (function (seq1180){ +var G__1181 = cljs.core.first(seq1180); +var seq1180__$1 = cljs.core.next(seq1180); +var G__1182 = cljs.core.first(seq1180__$1); +var seq1180__$2 = cljs.core.next(seq1180__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1181,G__1182,seq1180__$2); +}); + +cljs.core.bit_or.cljs$lang$maxFixedArity = (2); + +/** + * Bitwise and with complement + */ +cljs.core.bit_and_not = (function cljs$core$bit_and_not(var_args){ +var G__1192 = arguments.length; +switch (G__1192) { +case 2: +return cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1194 = arguments.length; +var i__4519__auto___1195 = (0); +while(true){ +if((i__4519__auto___1195 < len__4518__auto___1194)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1195])); + +var G__1196 = (i__4519__auto___1195 + (1)); +i__4519__auto___1195 = G__1196; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (x & ~y); +}); + +cljs.core.bit_and_not.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.bit_and_not,(x & ~y),more); +}); + +/** @this {Function} */ +cljs.core.bit_and_not.cljs$lang$applyTo = (function (seq1189){ +var G__1190 = cljs.core.first(seq1189); +var seq1189__$1 = cljs.core.next(seq1189); +var G__1191 = cljs.core.first(seq1189__$1); +var seq1189__$2 = cljs.core.next(seq1189__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1190,G__1191,seq1189__$2); +}); + +cljs.core.bit_and_not.cljs$lang$maxFixedArity = (2); + +/** + * Clear bit at index n + */ +cljs.core.bit_clear = (function cljs$core$bit_clear(x,n){ +return (x & ~(1 << n)); +}); +/** + * Flip bit at index n + */ +cljs.core.bit_flip = (function cljs$core$bit_flip(x,n){ +return (x ^ (1 << n)); +}); +/** + * Bitwise complement + */ +cljs.core.bit_not = (function cljs$core$bit_not(x){ +return (~ x); +}); +/** + * Set bit at index n + */ +cljs.core.bit_set = (function cljs$core$bit_set(x,n){ +return (x | (1 << n)); +}); +/** + * Test bit at index n + */ +cljs.core.bit_test = (function cljs$core$bit_test(x,n){ +return ((x & (1 << n)) != 0); +}); +/** + * Bitwise shift left + */ +cljs.core.bit_shift_left = (function cljs$core$bit_shift_left(x,n){ +return (x << n); +}); +/** + * Bitwise shift right + */ +cljs.core.bit_shift_right = (function cljs$core$bit_shift_right(x,n){ +return (x >> n); +}); +/** + * DEPRECATED: Bitwise shift right with zero fill + */ +cljs.core.bit_shift_right_zero_fill = (function cljs$core$bit_shift_right_zero_fill(x,n){ +return (x >>> n); +}); +/** + * Bitwise shift right with zero fill + */ +cljs.core.unsigned_bit_shift_right = (function cljs$core$unsigned_bit_shift_right(x,n){ +return (x >>> n); +}); +/** + * Counts the number of bits set in n + */ +cljs.core.bit_count = (function cljs$core$bit_count(v){ +var v__$1 = (v - ((v >> (1)) & (1431655765))); +var v__$2 = ((v__$1 & (858993459)) + ((v__$1 >> (2)) & (858993459))); +return ((((v__$2 + (v__$2 >> (4))) & (252645135)) * (16843009)) >> (24)); +}); +/** + * Returns non-nil if nums all have the equivalent + * value, otherwise false. Behavior on non nums is + * undefined. + */ +cljs.core._EQ__EQ_ = (function cljs$core$_EQ__EQ_(var_args){ +var G__1201 = arguments.length; +switch (G__1201) { +case 1: +return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1203 = arguments.length; +var i__4519__auto___1204 = (0); +while(true){ +if((i__4519__auto___1204 < len__4518__auto___1203)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1204])); + +var G__1205 = (i__4519__auto___1204 + (1)); +i__4519__auto___1204 = G__1205; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return true; +}); + +cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return cljs.core._equiv(x,y); +}); + +cljs.core._EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +while(true){ +if((x === y)){ +if(cljs.core.next(more)){ +var G__1206 = y; +var G__1207 = cljs.core.first(more); +var G__1208 = cljs.core.next(more); +x = G__1206; +y = G__1207; +more = G__1208; +continue; +} else { +return (y === cljs.core.first(more)); +} +} else { +return false; +} +break; +} +}); + +/** @this {Function} */ +cljs.core._EQ__EQ_.cljs$lang$applyTo = (function (seq1198){ +var G__1199 = cljs.core.first(seq1198); +var seq1198__$1 = cljs.core.next(seq1198); +var G__1200 = cljs.core.first(seq1198__$1); +var seq1198__$2 = cljs.core.next(seq1198__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1199,G__1200,seq1198__$2); +}); + +cljs.core._EQ__EQ_.cljs$lang$maxFixedArity = (2); + +/** + * Returns true if num is greater than zero, else false + */ +cljs.core.pos_QMARK_ = (function cljs$core$pos_QMARK_(x){ +return (x > (0)); +}); +/** + * Returns true if num is zero, else false + */ +cljs.core.zero_QMARK_ = (function cljs$core$zero_QMARK_(x){ +return (x === (0)); +}); +/** + * Returns true if num is less than zero, else false + */ +cljs.core.neg_QMARK_ = (function cljs$core$neg_QMARK_(x){ +return (x < (0)); +}); +/** + * Returns the nth next of coll, (seq coll) when n is 0. + */ +cljs.core.nthnext = (function cljs$core$nthnext(coll,n){ +var n__$1 = n; +var xs = cljs.core.seq(coll); +while(true){ +if(((xs) && ((n__$1 > (0))))){ +var G__1209 = (n__$1 - (1)); +var G__1210 = cljs.core.next(xs); +n__$1 = G__1209; +xs = G__1210; +continue; +} else { +return xs; +} +break; +} +}); +/** + * With no args, returns the empty string. With one arg x, returns + * x.toString(). (str nil) returns the empty string. With more than + * one arg, returns the concatenation of the str values of the args. + */ +cljs.core.str = (function cljs$core$str(var_args){ +var G__1214 = arguments.length; +switch (G__1214) { +case 0: +return cljs.core.str.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.str.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1216 = arguments.length; +var i__4519__auto___1217 = (0); +while(true){ +if((i__4519__auto___1217 < len__4518__auto___1216)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1217])); + +var G__1218 = (i__4519__auto___1217 + (1)); +i__4519__auto___1217 = G__1218; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((1)),(0),null)); +return cljs.core.str.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4534__auto__); + +} +}); + +cljs.core.str.cljs$core$IFn$_invoke$arity$0 = (function (){ +return ""; +}); + +cljs.core.str.cljs$core$IFn$_invoke$arity$1 = (function (x){ +if((x == null)){ +return ""; +} else { +return [x].join(""); +} +}); + +cljs.core.str.cljs$core$IFn$_invoke$arity$variadic = (function (x,ys){ +var sb = (new goog.string.StringBuffer([cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join(''))); +var more = ys; +while(true){ +if(cljs.core.truth_(more)){ +var G__1219 = sb.append([cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(more))].join('')); +var G__1220 = cljs.core.next(more); +sb = G__1219; +more = G__1220; +continue; +} else { +return sb.toString(); +} +break; +} +}); + +/** @this {Function} */ +cljs.core.str.cljs$lang$applyTo = (function (seq1212){ +var G__1213 = cljs.core.first(seq1212); +var seq1212__$1 = cljs.core.next(seq1212); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1213,seq1212__$1); +}); + +cljs.core.str.cljs$lang$maxFixedArity = (1); + +/** + * Returns the substring of s beginning at start inclusive, and ending + * at end (defaults to length of string), exclusive. + */ +cljs.core.subs = (function cljs$core$subs(var_args){ +var G__1222 = arguments.length; +switch (G__1222) { +case 2: +return cljs.core.subs.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.subs.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.subs.cljs$core$IFn$_invoke$arity$2 = (function (s,start){ +return s.substring(start); +}); + +cljs.core.subs.cljs$core$IFn$_invoke$arity$3 = (function (s,start,end){ +return s.substring(start,end); +}); + +cljs.core.subs.cljs$lang$maxFixedArity = 3; + + +/** + * Assumes x is sequential. Returns true if x equals y, otherwise + * returns false. + */ +cljs.core.equiv_sequential = (function cljs$core$equiv_sequential(x,y){ +return cljs.core.boolean$(((cljs.core.sequential_QMARK_(y))?((((cljs.core.counted_QMARK_(x)) && (cljs.core.counted_QMARK_(y)) && (!((cljs.core.count(x) === cljs.core.count(y))))))?false:(function (){var xs = cljs.core.seq(x); +var ys = cljs.core.seq(y); +while(true){ +if((xs == null)){ +return (ys == null); +} else { +if((ys == null)){ +return false; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.first(xs),cljs.core.first(ys))){ +var G__1224 = cljs.core.next(xs); +var G__1225 = cljs.core.next(ys); +xs = G__1224; +ys = G__1225; +continue; +} else { +return false; + +} +} +} +break; +} +})()):null)); +}); +cljs.core.hash_coll = (function cljs$core$hash_coll(coll){ +if(cljs.core.seq(coll)){ +var res = cljs.core.hash(cljs.core.first(coll)); +var s = cljs.core.next(coll); +while(true){ +if((s == null)){ +return res; +} else { +var G__1226 = cljs.core.hash_combine(res,cljs.core.hash(cljs.core.first(s))); +var G__1227 = cljs.core.next(s); +res = G__1226; +s = G__1227; +continue; +} +break; +} +} else { +return (0); +} +}); + +cljs.core.hash_imap = (function cljs$core$hash_imap(m){ +var h = (0); +var s = cljs.core.seq(m); +while(true){ +if(s){ +var e = cljs.core.first(s); +var G__1228 = ((h + (cljs.core.hash(cljs.core.key(e)) ^ cljs.core.hash(cljs.core.val(e)))) % (4503599627370496)); +var G__1229 = cljs.core.next(s); +h = G__1228; +s = G__1229; +continue; +} else { +return h; +} +break; +} +}); +cljs.core.hash_iset = (function cljs$core$hash_iset(s){ +var h = (0); +var s__$1 = cljs.core.seq(s); +while(true){ +if(s__$1){ +var e = cljs.core.first(s__$1); +var G__1230 = ((h + cljs.core.hash(e)) % (4503599627370496)); +var G__1231 = cljs.core.next(s__$1); +h = G__1230; +s__$1 = G__1231; +continue; +} else { +return h; +} +break; +} +}); + + +/** + * Takes a JavaScript object and a map of names to functions and + * attaches said functions as methods on the object. Any references to + * JavaScript's implicit this (via the this-as macro) will resolve to the + * object that the function is attached. + */ +cljs.core.extend_object_BANG_ = (function cljs$core$extend_object_BANG_(obj,fn_map){ +var seq__1232_1242 = cljs.core.seq(fn_map); +var chunk__1233_1243 = null; +var count__1234_1244 = (0); +var i__1235_1245 = (0); +while(true){ +if((i__1235_1245 < count__1234_1244)){ +var vec__1236_1246 = chunk__1233_1243.cljs$core$IIndexed$_nth$arity$2(null,i__1235_1245); +var key_name_1247 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1236_1246,(0),null); +var f_1248 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1236_1246,(1),null); +var str_name_1249 = cljs.core.name(key_name_1247); +goog.object.set(obj,str_name_1249,f_1248); + + +var G__1250 = seq__1232_1242; +var G__1251 = chunk__1233_1243; +var G__1252 = count__1234_1244; +var G__1253 = (i__1235_1245 + (1)); +seq__1232_1242 = G__1250; +chunk__1233_1243 = G__1251; +count__1234_1244 = G__1252; +i__1235_1245 = G__1253; +continue; +} else { +var temp__5457__auto___1254 = cljs.core.seq(seq__1232_1242); +if(temp__5457__auto___1254){ +var seq__1232_1255__$1 = temp__5457__auto___1254; +if(cljs.core.chunked_seq_QMARK_(seq__1232_1255__$1)){ +var c__4338__auto___1256 = cljs.core.chunk_first(seq__1232_1255__$1); +var G__1257 = cljs.core.chunk_rest(seq__1232_1255__$1); +var G__1258 = c__4338__auto___1256; +var G__1259 = cljs.core.count(c__4338__auto___1256); +var G__1260 = (0); +seq__1232_1242 = G__1257; +chunk__1233_1243 = G__1258; +count__1234_1244 = G__1259; +i__1235_1245 = G__1260; +continue; +} else { +var vec__1239_1261 = cljs.core.first(seq__1232_1255__$1); +var key_name_1262 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1239_1261,(0),null); +var f_1263 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1239_1261,(1),null); +var str_name_1264 = cljs.core.name(key_name_1262); +goog.object.set(obj,str_name_1264,f_1263); + + +var G__1265 = cljs.core.next(seq__1232_1255__$1); +var G__1266 = null; +var G__1267 = (0); +var G__1268 = (0); +seq__1232_1242 = G__1265; +chunk__1233_1243 = G__1266; +count__1234_1244 = G__1267; +i__1235_1245 = G__1268; +continue; +} +} else { +} +} +break; +} + +return obj; +}); + +/** +* @constructor + * @implements {cljs.core.IList} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ASeq} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IStack} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.List = (function (meta,first,rest,count,__hash){ +this.meta = meta; +this.first = first; +this.rest = rest; +this.count = count; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 65937646; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}); +cljs.core.List.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.List.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.List.prototype.indexOf = (function() { +var G__1269 = null; +var G__1269__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__1269__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1269 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1269__1.call(this,x); +case 2: +return G__1269__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1269.cljs$core$IFn$_invoke$arity$1 = G__1269__1; +G__1269.cljs$core$IFn$_invoke$arity$2 = G__1269__2; +return G__1269; +})() +; + +cljs.core.List.prototype.lastIndexOf = (function() { +var G__1270 = null; +var G__1270__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,self__.count); +}); +var G__1270__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1270 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1270__1.call(this,x); +case 2: +return G__1270__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1270.cljs$core$IFn$_invoke$arity$1 = G__1270__1; +G__1270.cljs$core$IFn$_invoke$arity$2 = G__1270__2; +return G__1270; +})() +; + +cljs.core.List.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.List.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.List(self__.meta,self__.first,self__.rest,self__.count,self__.__hash)); +}); + +cljs.core.List.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.count === (1))){ +return null; +} else { +return self__.rest; +} +}); + +cljs.core.List.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.count; +}); + +cljs.core.List.prototype.cljs$core$IStack$_peek$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.first; +}); + +cljs.core.List.prototype.cljs$core$IStack$_pop$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ISeq$_rest$arity$1(null); +}); + +cljs.core.List.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.List.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.List.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.List.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.first; +}); + +cljs.core.List.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.count === (1))){ +return cljs.core.List.EMPTY; +} else { +return self__.rest; +} +}); + +cljs.core.List.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.List.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.List(meta__$1,self__.first,self__.rest,self__.count,self__.__hash)); +}); + +cljs.core.List.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.List(self__.meta,o,coll__$1,(self__.count + (1)),null)); +}); + +cljs.core.List.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$first,cljs.core.cst$sym$rest,cljs.core.cst$sym$count,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.List.cljs$lang$type = true; + +cljs.core.List.cljs$lang$ctorStr = "cljs.core/List"; + +cljs.core.List.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/List"); +}); + +/** + * Positional factory function for cljs.core/List. + */ +cljs.core.__GT_List = (function cljs$core$__GT_List(meta,first,rest,count,__hash){ +return (new cljs.core.List(meta,first,rest,count,__hash)); +}); + +/** + * Returns true if x implements IList + */ +cljs.core.list_QMARK_ = (function cljs$core$list_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (33554432))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IList$)))){ +return true; +} else { +if((!x.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IList,x); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IList,x); +} +}); +var G__1272_1275 = cljs.core.List.prototype; +var G__1273_1276 = cljs.core.ITER_SYMBOL; +var G__1274_1277 = ((function (G__1272_1275,G__1273_1276){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__1272_1275,G__1273_1276)) +; +goog.object.set(G__1272_1275,G__1273_1276,G__1274_1277); + +/** +* @constructor + * @implements {cljs.core.IList} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IStack} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.EmptyList = (function (meta){ +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 65937614; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}); +cljs.core.EmptyList.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.EmptyList.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.EmptyList.prototype.indexOf = (function() { +var G__1278 = null; +var G__1278__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__1278__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1278 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1278__1.call(this,x); +case 2: +return G__1278__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1278.cljs$core$IFn$_invoke$arity$1 = G__1278__1; +G__1278.cljs$core$IFn$_invoke$arity$2 = G__1278__2; +return G__1278; +})() +; + +cljs.core.EmptyList.prototype.lastIndexOf = (function() { +var G__1279 = null; +var G__1279__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__1279__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1279 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1279__1.call(this,x); +case 2: +return G__1279__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1279.cljs$core$IFn$_invoke$arity$1 = G__1279__1; +G__1279.cljs$core$IFn$_invoke$arity$2 = G__1279__2; +return G__1279; +})() +; + +cljs.core.EmptyList.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.EmptyList.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.EmptyList(self__.meta)); +}); + +cljs.core.EmptyList.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return null; +}); + +cljs.core.EmptyList.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (0); +}); + +cljs.core.EmptyList.prototype.cljs$core$IStack$_peek$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return null; +}); + +cljs.core.EmptyList.prototype.cljs$core$IStack$_pop$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +throw (new Error("Can't pop empty list")); +}); + +cljs.core.EmptyList.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.empty_ordered_hash; +}); + +cljs.core.EmptyList.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +if(((cljs.core.list_QMARK_(other)) || (cljs.core.sequential_QMARK_(other)))){ +return (cljs.core.seq(other) == null); +} else { +return false; +} +}); + +cljs.core.EmptyList.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.EmptyList.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return null; +}); + +cljs.core.EmptyList.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.List.EMPTY; +}); + +cljs.core.EmptyList.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return null; +}); + +cljs.core.EmptyList.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.EmptyList(meta__$1)); +}); + +cljs.core.EmptyList.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.List(self__.meta,o,null,(1),null)); +}); + +cljs.core.EmptyList.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta], null); +}); + +cljs.core.EmptyList.cljs$lang$type = true; + +cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList"; + +cljs.core.EmptyList.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/EmptyList"); +}); + +/** + * Positional factory function for cljs.core/EmptyList. + */ +cljs.core.__GT_EmptyList = (function cljs$core$__GT_EmptyList(meta){ +return (new cljs.core.EmptyList(meta)); +}); + +cljs.core.List.EMPTY = (new cljs.core.EmptyList(null)); +var G__1280_1283 = cljs.core.EmptyList.prototype; +var G__1281_1284 = cljs.core.ITER_SYMBOL; +var G__1282_1285 = ((function (G__1280_1283,G__1281_1284){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__1280_1283,G__1281_1284)) +; +goog.object.set(G__1280_1283,G__1281_1284,G__1282_1285); +/** + * Returns true if coll satisfies? IReversible. + */ +cljs.core.reversible_QMARK_ = (function cljs$core$reversible_QMARK_(coll){ +if(!((coll == null))){ +if((((coll.cljs$lang$protocol_mask$partition0$ & (134217728))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IReversible$)))){ +return true; +} else { +if((!coll.cljs$lang$protocol_mask$partition0$)){ +return cljs.core.native_satisfies_QMARK_(cljs.core.IReversible,coll); +} else { +return false; +} +} +} else { +return cljs.core.native_satisfies_QMARK_(cljs.core.IReversible,coll); +} +}); +/** + * Returns, in constant time, a seq of the items in rev (which + * can be a vector or sorted-map), in reverse order. If rev is empty returns nil + */ +cljs.core.rseq = (function cljs$core$rseq(rev){ +return cljs.core._rseq(rev); +}); +/** + * Returns a seq of the items in coll in reverse order. Not lazy. + */ +cljs.core.reverse = (function cljs$core$reverse(coll){ +if(cljs.core.reversible_QMARK_(coll)){ +var or__3936__auto__ = cljs.core.rseq(coll); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return cljs.core.List.EMPTY; +} +} else { +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,cljs.core.List.EMPTY,coll); +} +}); +/** + * Creates a new list containing the items. + */ +cljs.core.list = (function cljs$core$list(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1288 = arguments.length; +var i__4519__auto___1289 = (0); +while(true){ +if((i__4519__auto___1289 < len__4518__auto___1288)){ +args__4521__auto__.push((arguments[i__4519__auto___1289])); + +var G__1290 = (i__4519__auto___1289 + (1)); +i__4519__auto___1289 = G__1290; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.list.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.list.cljs$core$IFn$_invoke$arity$variadic = (function (xs){ +var arr = (((((xs instanceof cljs.core.IndexedSeq)) && ((xs.i === (0)))))?xs.arr:(function (){var arr = []; +var xs__$1 = xs; +while(true){ +if(!((xs__$1 == null))){ +arr.push(xs__$1.cljs$core$ISeq$_first$arity$1(null)); + +var G__1291 = xs__$1.cljs$core$INext$_next$arity$1(null); +xs__$1 = G__1291; +continue; +} else { +return arr; +} +break; +} +})()); +var i = arr.length; +var r = cljs.core.List.EMPTY; +while(true){ +if((i > (0))){ +var G__1292 = (i - (1)); +var G__1293 = r.cljs$core$ICollection$_conj$arity$2(null,(arr[(i - (1))])); +i = G__1292; +r = G__1293; +continue; +} else { +return r; +} +break; +} +}); + +cljs.core.list.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.list.cljs$lang$applyTo = (function (seq1287){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq1287)); +}); + + +/** +* @constructor + * @implements {cljs.core.IList} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ASeq} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Cons = (function (meta,first,rest,__hash){ +this.meta = meta; +this.first = first; +this.rest = rest; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 65929452; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}); +cljs.core.Cons.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.Cons.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Cons.prototype.indexOf = (function() { +var G__1294 = null; +var G__1294__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__1294__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1294 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1294__1.call(this,x); +case 2: +return G__1294__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1294.cljs$core$IFn$_invoke$arity$1 = G__1294__1; +G__1294.cljs$core$IFn$_invoke$arity$2 = G__1294__2; +return G__1294; +})() +; + +cljs.core.Cons.prototype.lastIndexOf = (function() { +var G__1295 = null; +var G__1295__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__1295__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1295 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1295__1.call(this,x); +case 2: +return G__1295__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1295.cljs$core$IFn$_invoke$arity$1 = G__1295__1; +G__1295.cljs$core$IFn$_invoke$arity$2 = G__1295__2; +return G__1295; +})() +; + +cljs.core.Cons.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.Cons.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.Cons(self__.meta,self__.first,self__.rest,self__.__hash)); +}); + +cljs.core.Cons.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.rest == null)){ +return null; +} else { +return cljs.core.seq(self__.rest); +} +}); + +cljs.core.Cons.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.Cons.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.Cons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.Cons.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.first; +}); + +cljs.core.Cons.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.rest == null)){ +return cljs.core.List.EMPTY; +} else { +return self__.rest; +} +}); + +cljs.core.Cons.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.Cons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.Cons(meta__$1,self__.first,self__.rest,self__.__hash)); +}); + +cljs.core.Cons.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.Cons(null,o,coll__$1,null)); +}); + +cljs.core.Cons.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$first,cljs.core.cst$sym$rest,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Cons.cljs$lang$type = true; + +cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons"; + +cljs.core.Cons.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Cons"); +}); + +/** + * Positional factory function for cljs.core/Cons. + */ +cljs.core.__GT_Cons = (function cljs$core$__GT_Cons(meta,first,rest,__hash){ +return (new cljs.core.Cons(meta,first,rest,__hash)); +}); + +var G__1296_1299 = cljs.core.Cons.prototype; +var G__1297_1300 = cljs.core.ITER_SYMBOL; +var G__1298_1301 = ((function (G__1296_1299,G__1297_1300){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__1296_1299,G__1297_1300)) +; +goog.object.set(G__1296_1299,G__1297_1300,G__1298_1301); +/** + * Returns a new seq where x is the first element and coll is the rest. + */ +cljs.core.cons = (function cljs$core$cons(x,coll){ +if((function (){var or__3936__auto__ = (coll == null); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +if(!((coll == null))){ +if((((coll.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$ISeq$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +} +})()){ +return (new cljs.core.Cons(null,x,coll,null)); +} else { +return (new cljs.core.Cons(null,x,cljs.core.seq(coll),null)); +} +}); +cljs.core.hash_keyword = (function cljs$core$hash_keyword(k){ +return ((cljs.core.hash_symbol(k) + (2654435769)) | (0)); +}); +cljs.core.compare_keywords = (function cljs$core$compare_keywords(a,b){ +if((a.fqn === b.fqn)){ +return (0); +} else { +if(cljs.core.truth_((function (){var and__3925__auto__ = cljs.core.not(a.ns); +if(and__3925__auto__){ +return b.ns; +} else { +return and__3925__auto__; +} +})())){ +return (-1); +} else { +if(cljs.core.truth_(a.ns)){ +if(cljs.core.not(b.ns)){ +return (1); +} else { +var nsc = (function (){var G__1304 = a.ns; +var G__1305 = b.ns; +return goog.array.defaultCompare(G__1304,G__1305); +})(); +if(((0) === nsc)){ +var G__1306 = a.name; +var G__1307 = b.name; +return goog.array.defaultCompare(G__1306,G__1307); +} else { +return nsc; +} +} +} else { +var G__1308 = a.name; +var G__1309 = b.name; +return goog.array.defaultCompare(G__1308,G__1309); + +} +} +} +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.INamed} + * @implements {cljs.core.IPrintWithWriter} +*/ +cljs.core.Keyword = (function (ns,name,fqn,_hash){ +this.ns = ns; +this.name = name; +this.fqn = fqn; +this._hash = _hash; +this.cljs$lang$protocol_mask$partition0$ = 2153775105; +this.cljs$lang$protocol_mask$partition1$ = 4096; +}); +cljs.core.Keyword.prototype.toString = (function (){ +var self__ = this; +var _ = this; +return [":",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.fqn)].join(''); +}); + +cljs.core.Keyword.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Keyword.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (_,other){ +var self__ = this; +var ___$1 = this; +if((other instanceof cljs.core.Keyword)){ +return (self__.fqn === other.fqn); +} else { +return false; +} +}); + +cljs.core.Keyword.prototype.call = (function() { +var G__1311 = null; +var G__1311__2 = (function (self__,coll){ +var self__ = this; +var self____$1 = this; +var kw = self____$1; +return cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,kw); +}); +var G__1311__3 = (function (self__,coll,not_found){ +var self__ = this; +var self____$1 = this; +var kw = self____$1; +return cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,kw,not_found); +}); +G__1311 = function(self__,coll,not_found){ +switch(arguments.length){ +case 2: +return G__1311__2.call(this,self__,coll); +case 3: +return G__1311__3.call(this,self__,coll,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__1311.cljs$core$IFn$_invoke$arity$2 = G__1311__2; +G__1311.cljs$core$IFn$_invoke$arity$3 = G__1311__3; +return G__1311; +})() +; + +cljs.core.Keyword.prototype.apply = (function (self__,args1310){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args1310))); +}); + +cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +var self__ = this; +var kw = this; +return cljs.core.get.cljs$core$IFn$_invoke$arity$2(coll,kw); +}); + +cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$2 = (function (coll,not_found){ +var self__ = this; +var kw = this; +return cljs.core.get.cljs$core$IFn$_invoke$arity$3(coll,kw,not_found); +}); + +cljs.core.Keyword.prototype.cljs$core$IHash$_hash$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +var h__4048__auto__ = self__._hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_keyword(this$__$1); +self__._hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.Keyword.prototype.cljs$core$INamed$_name$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.name; +}); + +cljs.core.Keyword.prototype.cljs$core$INamed$_namespace$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.ns; +}); + +cljs.core.Keyword.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (o,writer,_){ +var self__ = this; +var o__$1 = this; +return cljs.core._write(writer,[":",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.fqn)].join('')); +}); + +cljs.core.Keyword.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$ns,cljs.core.cst$sym$name,cljs.core.cst$sym$fqn,cljs.core.with_meta(cljs.core.cst$sym$_hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Keyword.cljs$lang$type = true; + +cljs.core.Keyword.cljs$lang$ctorStr = "cljs.core/Keyword"; + +cljs.core.Keyword.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Keyword"); +}); + +/** + * Positional factory function for cljs.core/Keyword. + */ +cljs.core.__GT_Keyword = (function cljs$core$__GT_Keyword(ns,name,fqn,_hash){ +return (new cljs.core.Keyword(ns,name,fqn,_hash)); +}); + +/** + * Return true if x is a Keyword + */ +cljs.core.keyword_QMARK_ = (function cljs$core$keyword_QMARK_(x){ +return (x instanceof cljs.core.Keyword); +}); +/** + * Efficient test to determine that two keywords are identical. + */ +cljs.core.keyword_identical_QMARK_ = (function cljs$core$keyword_identical_QMARK_(x,y){ +if((x === y)){ +return true; +} else { +if((((x instanceof cljs.core.Keyword)) && ((y instanceof cljs.core.Keyword)))){ +return (x.fqn === y.fqn); +} else { +return false; +} +} +}); +/** + * Efficient test to determine that two symbols are identical. + */ +cljs.core.symbol_identical_QMARK_ = (function cljs$core$symbol_identical_QMARK_(x,y){ +if((x === y)){ +return true; +} else { +if((((x instanceof cljs.core.Symbol)) && ((y instanceof cljs.core.Symbol)))){ +return (x.str === y.str); +} else { +return false; +} +} +}); +/** + * Returns the namespace String of a symbol or keyword, or nil if not present. + */ +cljs.core.namespace = (function cljs$core$namespace(x){ +if(((!((x == null)))?(((((x.cljs$lang$protocol_mask$partition1$ & (4096))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$INamed$))))?true:false):false)){ +return x.cljs$core$INamed$_namespace$arity$1(null); +} else { +throw (new Error(["Doesn't support namespace: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join(''))); +} +}); +/** + * Return true if x is a symbol or keyword + */ +cljs.core.ident_QMARK_ = (function cljs$core$ident_QMARK_(x){ +return (((x instanceof cljs.core.Keyword)) || ((x instanceof cljs.core.Symbol))); +}); +/** + * Return true if x is a symbol or keyword without a namespace + */ +cljs.core.simple_ident_QMARK_ = (function cljs$core$simple_ident_QMARK_(x){ +return ((cljs.core.ident_QMARK_(x)) && ((cljs.core.namespace(x) == null))); +}); +/** + * Return true if x is a symbol or keyword with a namespace + */ +cljs.core.qualified_ident_QMARK_ = (function cljs$core$qualified_ident_QMARK_(x){ +return cljs.core.boolean$((function (){var and__3925__auto__ = cljs.core.ident_QMARK_(x); +if(and__3925__auto__){ +var and__3925__auto____$1 = cljs.core.namespace(x); +if(cljs.core.truth_(and__3925__auto____$1)){ +return true; +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +/** + * Return true if x is a symbol without a namespace + */ +cljs.core.simple_symbol_QMARK_ = (function cljs$core$simple_symbol_QMARK_(x){ +return (((x instanceof cljs.core.Symbol)) && ((cljs.core.namespace(x) == null))); +}); +/** + * Return true if x is a symbol with a namespace + */ +cljs.core.qualified_symbol_QMARK_ = (function cljs$core$qualified_symbol_QMARK_(x){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (x instanceof cljs.core.Symbol); +if(and__3925__auto__){ +var and__3925__auto____$1 = cljs.core.namespace(x); +if(cljs.core.truth_(and__3925__auto____$1)){ +return true; +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +/** + * Return true if x is a keyword without a namespace + */ +cljs.core.simple_keyword_QMARK_ = (function cljs$core$simple_keyword_QMARK_(x){ +return (((x instanceof cljs.core.Keyword)) && ((cljs.core.namespace(x) == null))); +}); +/** + * Return true if x is a keyword with a namespace + */ +cljs.core.qualified_keyword_QMARK_ = (function cljs$core$qualified_keyword_QMARK_(x){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (x instanceof cljs.core.Keyword); +if(and__3925__auto__){ +var and__3925__auto____$1 = cljs.core.namespace(x); +if(cljs.core.truth_(and__3925__auto____$1)){ +return true; +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +/** + * Returns a Keyword with the given namespace and name. Do not use : + * in the keyword strings, it will be added automatically. + */ +cljs.core.keyword = (function cljs$core$keyword(var_args){ +var G__1314 = arguments.length; +switch (G__1314) { +case 1: +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.keyword.cljs$core$IFn$_invoke$arity$1 = (function (name){ +if((name instanceof cljs.core.Keyword)){ +return name; +} else { +if((name instanceof cljs.core.Symbol)){ +return (new cljs.core.Keyword(cljs.core.namespace(name),cljs.core.name(name),name.str,null)); +} else { +if(typeof name === 'string'){ +var parts = name.split("/"); +if((parts.length === (2))){ +return (new cljs.core.Keyword((parts[(0)]),(parts[(1)]),name,null)); +} else { +return (new cljs.core.Keyword(null,(parts[(0)]),name,null)); +} +} else { +return null; +} +} +} +}); + +cljs.core.keyword.cljs$core$IFn$_invoke$arity$2 = (function (ns,name){ +var ns__$1 = (((ns instanceof cljs.core.Keyword))?cljs.core.name(ns):(((ns instanceof cljs.core.Symbol))?cljs.core.name(ns):ns +)); +var name__$1 = (((name instanceof cljs.core.Keyword))?cljs.core.name(name):(((name instanceof cljs.core.Symbol))?cljs.core.name(name):name +)); +return (new cljs.core.Keyword(ns__$1,name__$1,[cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(ns__$1)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns__$1),"/"].join(''):null)),cljs.core.str.cljs$core$IFn$_invoke$arity$1(name__$1)].join(''),null)); +}); + +cljs.core.keyword.cljs$lang$maxFixedArity = 2; + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IPending} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.LazySeq = (function (meta,fn,s,__hash){ +this.meta = meta; +this.fn = fn; +this.s = s; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32374988; +this.cljs$lang$protocol_mask$partition1$ = 1; +}); +cljs.core.LazySeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.LazySeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.LazySeq.prototype.sval = (function (){ +var self__ = this; +var coll = this; +if((self__.fn == null)){ +return self__.s; +} else { +self__.s = (self__.fn.cljs$core$IFn$_invoke$arity$0 ? self__.fn.cljs$core$IFn$_invoke$arity$0() : self__.fn.call(null)); + +self__.fn = null; + +return self__.s; +} +}); + +cljs.core.LazySeq.prototype.indexOf = (function() { +var G__1316 = null; +var G__1316__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__1316__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1316 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1316__1.call(this,x); +case 2: +return G__1316__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1316.cljs$core$IFn$_invoke$arity$1 = G__1316__1; +G__1316.cljs$core$IFn$_invoke$arity$2 = G__1316__2; +return G__1316; +})() +; + +cljs.core.LazySeq.prototype.lastIndexOf = (function() { +var G__1317 = null; +var G__1317__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__1317__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1317 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1317__1.call(this,x); +case 2: +return G__1317__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1317.cljs$core$IFn$_invoke$arity$1 = G__1317__1; +G__1317.cljs$core$IFn$_invoke$arity$2 = G__1317__2; +return G__1317; +})() +; + +cljs.core.LazySeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.LazySeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +coll__$1.cljs$core$ISeqable$_seq$arity$1(null); + +if((self__.s == null)){ +return null; +} else { +return cljs.core.next(self__.s); +} +}); + +cljs.core.LazySeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.LazySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.LazySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.LazySeq.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.not(self__.fn); +}); + +cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.LazySeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +coll__$1.cljs$core$ISeqable$_seq$arity$1(null); + +if((self__.s == null)){ +return null; +} else { +return cljs.core.first(self__.s); +} +}); + +cljs.core.LazySeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +coll__$1.cljs$core$ISeqable$_seq$arity$1(null); + +if(!((self__.s == null))){ +return cljs.core.rest(self__.s); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.LazySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +coll__$1.sval(); + +if((self__.s == null)){ +return null; +} else { +var ls = self__.s; +while(true){ +if((ls instanceof cljs.core.LazySeq)){ +var G__1318 = ls.sval(); +ls = G__1318; +continue; +} else { +self__.s = ls; + +return cljs.core.seq(self__.s); +} +break; +} +} +}); + +cljs.core.LazySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.LazySeq(meta__$1,((function (coll__$1){ +return (function (){ +return coll__$1.cljs$core$ISeqable$_seq$arity$1(null); +});})(coll__$1)) +,null,self__.__hash)); +}); + +cljs.core.LazySeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.LazySeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.with_meta(cljs.core.cst$sym$fn,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$s,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.LazySeq.cljs$lang$type = true; + +cljs.core.LazySeq.cljs$lang$ctorStr = "cljs.core/LazySeq"; + +cljs.core.LazySeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/LazySeq"); +}); + +/** + * Positional factory function for cljs.core/LazySeq. + */ +cljs.core.__GT_LazySeq = (function cljs$core$__GT_LazySeq(meta,fn,s,__hash){ +return (new cljs.core.LazySeq(meta,fn,s,__hash)); +}); + +var G__1319_1322 = cljs.core.LazySeq.prototype; +var G__1320_1323 = cljs.core.ITER_SYMBOL; +var G__1321_1324 = ((function (G__1319_1322,G__1320_1323){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__1319_1322,G__1320_1323)) +; +goog.object.set(G__1319_1322,G__1320_1323,G__1321_1324); + +/** +* @constructor + * @implements {cljs.core.ICounted} +*/ +cljs.core.ChunkBuffer = (function (buf,end){ +this.buf = buf; +this.end = end; +this.cljs$lang$protocol_mask$partition0$ = 2; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.ChunkBuffer.prototype.add = (function (o){ +var self__ = this; +var _ = this; +(self__.buf[self__.end] = o); + +return self__.end = (self__.end + (1)); +}); + +cljs.core.ChunkBuffer.prototype.chunk = (function (){ +var self__ = this; +var _ = this; +var ret = (new cljs.core.ArrayChunk(self__.buf,(0),self__.end)); +self__.buf = null; + +return ret; +}); + +cljs.core.ChunkBuffer.prototype.cljs$core$ICounted$_count$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.end; +}); + +cljs.core.ChunkBuffer.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$buf,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$end,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ChunkBuffer.cljs$lang$type = true; + +cljs.core.ChunkBuffer.cljs$lang$ctorStr = "cljs.core/ChunkBuffer"; + +cljs.core.ChunkBuffer.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ChunkBuffer"); +}); + +/** + * Positional factory function for cljs.core/ChunkBuffer. + */ +cljs.core.__GT_ChunkBuffer = (function cljs$core$__GT_ChunkBuffer(buf,end){ +return (new cljs.core.ChunkBuffer(buf,end)); +}); + +cljs.core.chunk_buffer = (function cljs$core$chunk_buffer(capacity){ +return (new cljs.core.ChunkBuffer((new Array(capacity)),(0))); +}); + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.IChunk} + * @implements {cljs.core.IReduce} +*/ +cljs.core.ArrayChunk = (function (arr,off,end){ +this.arr = arr; +this.off = off; +this.end = end; +this.cljs$lang$protocol_mask$partition0$ = 524306; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.ArrayChunk.prototype.cljs$core$ICounted$_count$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (self__.end - self__.off); +}); + +cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (coll,i){ +var self__ = this; +var coll__$1 = this; +return (self__.arr[(self__.off + i)]); +}); + +cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (coll,i,not_found){ +var self__ = this; +var coll__$1 = this; +if((((i >= (0))) && ((i < (self__.end - self__.off))))){ +return (self__.arr[(self__.off + i)]); +} else { +return not_found; +} +}); + +cljs.core.ArrayChunk.prototype.cljs$core$IChunk$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ArrayChunk.prototype.cljs$core$IChunk$_drop_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.off === self__.end)){ +throw (new Error("-drop-first of empty chunk")); +} else { +return (new cljs.core.ArrayChunk(self__.arr,(self__.off + (1)),self__.end)); +} +}); + +cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,(self__.arr[self__.off]),(self__.off + (1))); +}); + +cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.array_reduce.cljs$core$IFn$_invoke$arity$4(self__.arr,f,start,self__.off); +}); + +cljs.core.ArrayChunk.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.cst$sym$off,cljs.core.cst$sym$end], null); +}); + +cljs.core.ArrayChunk.cljs$lang$type = true; + +cljs.core.ArrayChunk.cljs$lang$ctorStr = "cljs.core/ArrayChunk"; + +cljs.core.ArrayChunk.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ArrayChunk"); +}); + +/** + * Positional factory function for cljs.core/ArrayChunk. + */ +cljs.core.__GT_ArrayChunk = (function cljs$core$__GT_ArrayChunk(arr,off,end){ +return (new cljs.core.ArrayChunk(arr,off,end)); +}); + +cljs.core.array_chunk = (function cljs$core$array_chunk(var_args){ +var G__1326 = arguments.length; +switch (G__1326) { +case 1: +return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$1 = (function (arr){ +return (new cljs.core.ArrayChunk(arr,(0),arr.length)); +}); + +cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2 = (function (arr,off){ +return (new cljs.core.ArrayChunk(arr,off,arr.length)); +}); + +cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3 = (function (arr,off,end){ +return (new cljs.core.ArrayChunk(arr,off,end)); +}); + +cljs.core.array_chunk.cljs$lang$maxFixedArity = 3; + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ASeq} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IChunkedNext} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IChunkedSeq} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.ChunkedCons = (function (chunk,more,meta,__hash){ +this.chunk = chunk; +this.more = more; +this.meta = meta; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 31850732; +this.cljs$lang$protocol_mask$partition1$ = 1536; +}); +cljs.core.ChunkedCons.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.ChunkedCons.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.ChunkedCons.prototype.indexOf = (function() { +var G__1328 = null; +var G__1328__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__1328__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1328 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1328__1.call(this,x); +case 2: +return G__1328__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1328.cljs$core$IFn$_invoke$arity$1 = G__1328__1; +G__1328.cljs$core$IFn$_invoke$arity$2 = G__1328__2; +return G__1328; +})() +; + +cljs.core.ChunkedCons.prototype.lastIndexOf = (function() { +var G__1329 = null; +var G__1329__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__1329__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1329 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1329__1.call(this,x); +case 2: +return G__1329__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1329.cljs$core$IFn$_invoke$arity$1 = G__1329__1; +G__1329.cljs$core$IFn$_invoke$arity$2 = G__1329__2; +return G__1329; +})() +; + +cljs.core.ChunkedCons.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.ChunkedCons.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((cljs.core._count(self__.chunk) > (1))){ +return (new cljs.core.ChunkedCons(cljs.core._drop_first(self__.chunk),self__.more,self__.meta,null)); +} else { +var more__$1 = cljs.core._seq(self__.more); +if((more__$1 == null)){ +return null; +} else { +return more__$1; +} +} +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.chunk,(0)); +}); + +cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((cljs.core._count(self__.chunk) > (1))){ +return (new cljs.core.ChunkedCons(cljs.core._drop_first(self__.chunk),self__.more,self__.meta,null)); +} else { +if((self__.more == null)){ +return cljs.core.List.EMPTY; +} else { +return self__.more; +} +} +}); + +cljs.core.ChunkedCons.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.chunk; +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.more == null)){ +return cljs.core.List.EMPTY; +} else { +return self__.more; +} +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,m){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.ChunkedCons(self__.chunk,self__.more,m,self__.__hash)); +}); + +cljs.core.ChunkedCons.prototype.cljs$core$ICollection$_conj$arity$2 = (function (this$,o){ +var self__ = this; +var this$__$1 = this; +return cljs.core.cons(o,this$__$1); +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.more == null)){ +return null; +} else { +return self__.more; +} +}); + +cljs.core.ChunkedCons.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$chunk,cljs.core.cst$sym$more,cljs.core.cst$sym$meta,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ChunkedCons.cljs$lang$type = true; + +cljs.core.ChunkedCons.cljs$lang$ctorStr = "cljs.core/ChunkedCons"; + +cljs.core.ChunkedCons.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ChunkedCons"); +}); + +/** + * Positional factory function for cljs.core/ChunkedCons. + */ +cljs.core.__GT_ChunkedCons = (function cljs$core$__GT_ChunkedCons(chunk,more,meta,__hash){ +return (new cljs.core.ChunkedCons(chunk,more,meta,__hash)); +}); + +var G__1330_1333 = cljs.core.ChunkedCons.prototype; +var G__1331_1334 = cljs.core.ITER_SYMBOL; +var G__1332_1335 = ((function (G__1330_1333,G__1331_1334){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__1330_1333,G__1331_1334)) +; +goog.object.set(G__1330_1333,G__1331_1334,G__1332_1335); +cljs.core.chunk_cons = (function cljs$core$chunk_cons(chunk,rest){ +if((cljs.core._count(chunk) === (0))){ +return rest; +} else { +return (new cljs.core.ChunkedCons(chunk,rest,null,null)); +} +}); +cljs.core.chunk_append = (function cljs$core$chunk_append(b,x){ +return b.add(x); +}); +cljs.core.chunk = (function cljs$core$chunk(b){ +return b.chunk(); +}); +cljs.core.chunk_first = (function cljs$core$chunk_first(s){ +return cljs.core._chunked_first(s); +}); +cljs.core.chunk_rest = (function cljs$core$chunk_rest(s){ +return cljs.core._chunked_rest(s); +}); +cljs.core.chunk_next = (function cljs$core$chunk_next(s){ +if(((!((s == null)))?(((((s.cljs$lang$protocol_mask$partition1$ & (1024))) || ((cljs.core.PROTOCOL_SENTINEL === s.cljs$core$IChunkedNext$))))?true:false):false)){ +return cljs.core._chunked_next(s); +} else { +return cljs.core.seq(cljs.core._chunked_rest(s)); +} +}); +/** + * Naive impl of to-array as a start. + */ +cljs.core.to_array = (function cljs$core$to_array(s){ +var ary = []; +var s__$1 = cljs.core.seq(s); +while(true){ +if(!((s__$1 == null))){ +ary.push(cljs.core.first(s__$1)); + +var G__1337 = cljs.core.next(s__$1); +s__$1 = G__1337; +continue; +} else { +return ary; +} +break; +} +}); +/** + * Returns a (potentially-ragged) 2-dimensional array + * containing the contents of coll. + */ +cljs.core.to_array_2d = (function cljs$core$to_array_2d(coll){ +var ret = (new Array(cljs.core.count(coll))); +var i_1338 = (0); +var xs_1339 = cljs.core.seq(coll); +while(true){ +if((xs_1339 == null)){ +} else { +(ret[i_1338] = cljs.core.to_array(cljs.core.first(xs_1339))); + +var G__1340 = (i_1338 + (1)); +var G__1341 = cljs.core.next(xs_1339); +i_1338 = G__1340; +xs_1339 = G__1341; +continue; +} +break; +} + +return ret; +}); +/** + * Creates an array of ints. Does not coerce array, provided for compatibility + * with Clojure. + */ +cljs.core.int_array = (function cljs$core$int_array(var_args){ +var G__1343 = arguments.length; +switch (G__1343) { +case 1: +return cljs.core.int_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.int_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.int_array.cljs$core$IFn$_invoke$arity$1 = (function (size_or_seq){ +if(typeof size_or_seq === 'number'){ +return cljs.core.int_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null); +} else { +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq); +} +}); + +cljs.core.int_array.cljs$core$IFn$_invoke$arity$2 = (function (size,init_val_or_seq){ +var a = (new Array(size)); +if(cljs.core.seq_QMARK_(init_val_or_seq)){ +var s = cljs.core.seq(init_val_or_seq); +var i = (0); +var s__$1 = s; +while(true){ +if(((s__$1) && ((i < size)))){ +(a[i] = cljs.core.first(s__$1)); + +var G__1345 = (i + (1)); +var G__1346 = cljs.core.next(s__$1); +i = G__1345; +s__$1 = G__1346; +continue; +} else { +return a; +} +break; +} +} else { +var n__4395__auto___1347 = size; +var i_1348 = (0); +while(true){ +if((i_1348 < n__4395__auto___1347)){ +(a[i_1348] = init_val_or_seq); + +var G__1349 = (i_1348 + (1)); +i_1348 = G__1349; +continue; +} else { +} +break; +} + +return a; +} +}); + +cljs.core.int_array.cljs$lang$maxFixedArity = 2; + +/** + * Creates an array of longs. Does not coerce array, provided for compatibility + * with Clojure. + */ +cljs.core.long_array = (function cljs$core$long_array(var_args){ +var G__1351 = arguments.length; +switch (G__1351) { +case 1: +return cljs.core.long_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.long_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.long_array.cljs$core$IFn$_invoke$arity$1 = (function (size_or_seq){ +if(typeof size_or_seq === 'number'){ +return cljs.core.long_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null); +} else { +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq); +} +}); + +cljs.core.long_array.cljs$core$IFn$_invoke$arity$2 = (function (size,init_val_or_seq){ +var a = (new Array(size)); +if(cljs.core.seq_QMARK_(init_val_or_seq)){ +var s = cljs.core.seq(init_val_or_seq); +var i = (0); +var s__$1 = s; +while(true){ +if(((s__$1) && ((i < size)))){ +(a[i] = cljs.core.first(s__$1)); + +var G__1353 = (i + (1)); +var G__1354 = cljs.core.next(s__$1); +i = G__1353; +s__$1 = G__1354; +continue; +} else { +return a; +} +break; +} +} else { +var n__4395__auto___1355 = size; +var i_1356 = (0); +while(true){ +if((i_1356 < n__4395__auto___1355)){ +(a[i_1356] = init_val_or_seq); + +var G__1357 = (i_1356 + (1)); +i_1356 = G__1357; +continue; +} else { +} +break; +} + +return a; +} +}); + +cljs.core.long_array.cljs$lang$maxFixedArity = 2; + +/** + * Creates an array of doubles. Does not coerce array, provided for compatibility + * with Clojure. + */ +cljs.core.double_array = (function cljs$core$double_array(var_args){ +var G__1359 = arguments.length; +switch (G__1359) { +case 1: +return cljs.core.double_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.double_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.double_array.cljs$core$IFn$_invoke$arity$1 = (function (size_or_seq){ +if(typeof size_or_seq === 'number'){ +return cljs.core.double_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null); +} else { +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq); +} +}); + +cljs.core.double_array.cljs$core$IFn$_invoke$arity$2 = (function (size,init_val_or_seq){ +var a = (new Array(size)); +if(cljs.core.seq_QMARK_(init_val_or_seq)){ +var s = cljs.core.seq(init_val_or_seq); +var i = (0); +var s__$1 = s; +while(true){ +if(((s__$1) && ((i < size)))){ +(a[i] = cljs.core.first(s__$1)); + +var G__1361 = (i + (1)); +var G__1362 = cljs.core.next(s__$1); +i = G__1361; +s__$1 = G__1362; +continue; +} else { +return a; +} +break; +} +} else { +var n__4395__auto___1363 = size; +var i_1364 = (0); +while(true){ +if((i_1364 < n__4395__auto___1363)){ +(a[i_1364] = init_val_or_seq); + +var G__1365 = (i_1364 + (1)); +i_1364 = G__1365; +continue; +} else { +} +break; +} + +return a; +} +}); + +cljs.core.double_array.cljs$lang$maxFixedArity = 2; + +/** + * Creates an array of objects. Does not coerce array, provided for compatibility + * with Clojure. + */ +cljs.core.object_array = (function cljs$core$object_array(var_args){ +var G__1367 = arguments.length; +switch (G__1367) { +case 1: +return cljs.core.object_array.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.object_array.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.object_array.cljs$core$IFn$_invoke$arity$1 = (function (size_or_seq){ +if(typeof size_or_seq === 'number'){ +return cljs.core.object_array.cljs$core$IFn$_invoke$arity$2(size_or_seq,null); +} else { +return cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(size_or_seq); +} +}); + +cljs.core.object_array.cljs$core$IFn$_invoke$arity$2 = (function (size,init_val_or_seq){ +var a = (new Array(size)); +if(cljs.core.seq_QMARK_(init_val_or_seq)){ +var s = cljs.core.seq(init_val_or_seq); +var i = (0); +var s__$1 = s; +while(true){ +if(((s__$1) && ((i < size)))){ +(a[i] = cljs.core.first(s__$1)); + +var G__1369 = (i + (1)); +var G__1370 = cljs.core.next(s__$1); +i = G__1369; +s__$1 = G__1370; +continue; +} else { +return a; +} +break; +} +} else { +var n__4395__auto___1371 = size; +var i_1372 = (0); +while(true){ +if((i_1372 < n__4395__auto___1371)){ +(a[i_1372] = init_val_or_seq); + +var G__1373 = (i_1372 + (1)); +i_1372 = G__1373; +continue; +} else { +} +break; +} + +return a; +} +}); + +cljs.core.object_array.cljs$lang$maxFixedArity = 2; + +/** + * If coll is counted? returns its count, else will count at most the first n + * elements of coll using its seq + */ +cljs.core.bounded_count = (function cljs$core$bounded_count(n,coll){ +if(cljs.core.counted_QMARK_(coll)){ +return cljs.core.count(coll); +} else { +var i = (0); +var s = cljs.core.seq(coll); +while(true){ +if(((!((s == null))) && ((i < n)))){ +var G__1374 = (i + (1)); +var G__1375 = cljs.core.next(s); +i = G__1374; +s = G__1375; +continue; +} else { +return i; +} +break; +} +} +}); +cljs.core.spread = (function cljs$core$spread(arglist){ +if((arglist == null)){ +return null; +} else { +var n = cljs.core.next(arglist); +if((n == null)){ +return cljs.core.seq(cljs.core.first(arglist)); +} else { +return cljs.core.cons(cljs.core.first(arglist),(cljs.core.spread.cljs$core$IFn$_invoke$arity$1 ? cljs.core.spread.cljs$core$IFn$_invoke$arity$1(n) : cljs.core.spread.call(null,n))); +} +} +}); +/** + * Returns a lazy seq representing the concatenation of the elements in the supplied colls. + */ +cljs.core.concat = (function cljs$core$concat(var_args){ +var G__1380 = arguments.length; +switch (G__1380) { +case 0: +return cljs.core.concat.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.concat.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.concat.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1382 = arguments.length; +var i__4519__auto___1383 = (0); +while(true){ +if((i__4519__auto___1383 < len__4518__auto___1382)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1383])); + +var G__1384 = (i__4519__auto___1383 + (1)); +i__4519__auto___1383 = G__1384; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.concat.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (new cljs.core.LazySeq(null,(function (){ +return null; +}),null,null)); +}); + +cljs.core.concat.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (new cljs.core.LazySeq(null,(function (){ +return x; +}),null,null)); +}); + +cljs.core.concat.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return (new cljs.core.LazySeq(null,(function (){ +var s = cljs.core.seq(x); +if(s){ +if(cljs.core.chunked_seq_QMARK_(s)){ +return cljs.core.chunk_cons(cljs.core.chunk_first(s),cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.chunk_rest(s),y)); +} else { +return cljs.core.cons(cljs.core.first(s),cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.rest(s),y)); +} +} else { +return y; +} +}),null,null)); +}); + +cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,zs){ +var cat = (function cljs$core$cat(xys,zs__$1){ +return (new cljs.core.LazySeq(null,(function (){ +var xys__$1 = cljs.core.seq(xys); +if(xys__$1){ +if(cljs.core.chunked_seq_QMARK_(xys__$1)){ +return cljs.core.chunk_cons(cljs.core.chunk_first(xys__$1),cljs$core$cat(cljs.core.chunk_rest(xys__$1),zs__$1)); +} else { +return cljs.core.cons(cljs.core.first(xys__$1),cljs$core$cat(cljs.core.rest(xys__$1),zs__$1)); +} +} else { +if(cljs.core.truth_(zs__$1)){ +return cljs$core$cat(cljs.core.first(zs__$1),cljs.core.next(zs__$1)); +} else { +return null; +} +} +}),null,null)); +}); +return cat(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(x,y),zs); +}); + +/** @this {Function} */ +cljs.core.concat.cljs$lang$applyTo = (function (seq1377){ +var G__1378 = cljs.core.first(seq1377); +var seq1377__$1 = cljs.core.next(seq1377); +var G__1379 = cljs.core.first(seq1377__$1); +var seq1377__$2 = cljs.core.next(seq1377__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1378,G__1379,seq1377__$2); +}); + +cljs.core.concat.cljs$lang$maxFixedArity = (2); + +/** + * Creates a new list containing the items prepended to the rest, the + * last of which will be treated as a sequence. + */ +cljs.core.list_STAR_ = (function cljs$core$list_STAR_(var_args){ +var G__1391 = arguments.length; +switch (G__1391) { +case 1: +return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1393 = arguments.length; +var i__4519__auto___1394 = (0); +while(true){ +if((i__4519__auto___1394 < len__4518__auto___1393)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1394])); + +var G__1395 = (i__4519__auto___1394 + (1)); +i__4519__auto___1394 = G__1395; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((4)),(0),null)); +return cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__4534__auto__); + +} +}); + +cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$1 = (function (args){ +return cljs.core.seq(args); +}); + +cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2 = (function (a,args){ +return cljs.core.cons(a,args); +}); + +cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3 = (function (a,b,args){ +return cljs.core.cons(a,cljs.core.cons(b,args)); +}); + +cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4 = (function (a,b,c,args){ +return cljs.core.cons(a,cljs.core.cons(b,cljs.core.cons(c,args))); +}); + +cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$variadic = (function (a,b,c,d,more){ +return cljs.core.cons(a,cljs.core.cons(b,cljs.core.cons(c,cljs.core.cons(d,cljs.core.spread(more))))); +}); + +/** @this {Function} */ +cljs.core.list_STAR_.cljs$lang$applyTo = (function (seq1386){ +var G__1387 = cljs.core.first(seq1386); +var seq1386__$1 = cljs.core.next(seq1386); +var G__1388 = cljs.core.first(seq1386__$1); +var seq1386__$2 = cljs.core.next(seq1386__$1); +var G__1389 = cljs.core.first(seq1386__$2); +var seq1386__$3 = cljs.core.next(seq1386__$2); +var G__1390 = cljs.core.first(seq1386__$3); +var seq1386__$4 = cljs.core.next(seq1386__$3); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1387,G__1388,G__1389,G__1390,seq1386__$4); +}); + +cljs.core.list_STAR_.cljs$lang$maxFixedArity = (4); + +/** + * Returns a new, transient version of the collection, in constant time. + */ +cljs.core.transient$ = (function cljs$core$transient(coll){ +return cljs.core._as_transient(coll); +}); +/** + * Returns a new, persistent version of the transient collection, in + * constant time. The transient collection cannot be used after this + * call, any such use will throw an exception. + */ +cljs.core.persistent_BANG_ = (function cljs$core$persistent_BANG_(tcoll){ +return cljs.core._persistent_BANG_(tcoll); +}); +/** + * Adds val to the transient collection, and return tcoll. The 'addition' + * may happen at different 'places' depending on the concrete type. + */ +cljs.core.conj_BANG_ = (function cljs$core$conj_BANG_(var_args){ +var G__1400 = arguments.length; +switch (G__1400) { +case 0: +return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1402 = arguments.length; +var i__4519__auto___1403 = (0); +while(true){ +if((i__4519__auto___1403 < len__4518__auto___1402)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1403])); + +var G__1404 = (i__4519__auto___1403 + (1)); +i__4519__auto___1403 = G__1404; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.transient$(cljs.core.PersistentVector.EMPTY); +}); + +cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$1 = (function (tcoll){ +return tcoll; +}); + +cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (tcoll,val){ +return cljs.core._conj_BANG_(tcoll,val); +}); + +cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (tcoll,val,vals){ +while(true){ +var ntcoll = cljs.core._conj_BANG_(tcoll,val); +if(cljs.core.truth_(vals)){ +var G__1405 = ntcoll; +var G__1406 = cljs.core.first(vals); +var G__1407 = cljs.core.next(vals); +tcoll = G__1405; +val = G__1406; +vals = G__1407; +continue; +} else { +return ntcoll; +} +break; +} +}); + +/** @this {Function} */ +cljs.core.conj_BANG_.cljs$lang$applyTo = (function (seq1397){ +var G__1398 = cljs.core.first(seq1397); +var seq1397__$1 = cljs.core.next(seq1397); +var G__1399 = cljs.core.first(seq1397__$1); +var seq1397__$2 = cljs.core.next(seq1397__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1398,G__1399,seq1397__$2); +}); + +cljs.core.conj_BANG_.cljs$lang$maxFixedArity = (2); + +/** + * When applied to a transient map, adds mapping of key(s) to + * val(s). When applied to a transient vector, sets the val at index. + * Note - index must be <= (count vector). Returns coll. + */ +cljs.core.assoc_BANG_ = (function cljs$core$assoc_BANG_(var_args){ +var G__1413 = arguments.length; +switch (G__1413) { +case 3: +return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1415 = arguments.length; +var i__4519__auto___1416 = (0); +while(true){ +if((i__4519__auto___1416 < len__4518__auto___1415)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1416])); + +var G__1417 = (i__4519__auto___1416 + (1)); +i__4519__auto___1416 = G__1417; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3 = (function (tcoll,key,val){ +return cljs.core._assoc_BANG_(tcoll,key,val); +}); + +cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (tcoll,key,val,kvs){ +while(true){ +var ntcoll = cljs.core._assoc_BANG_(tcoll,key,val); +if(cljs.core.truth_(kvs)){ +var G__1418 = ntcoll; +var G__1419 = cljs.core.first(kvs); +var G__1420 = cljs.core.second(kvs); +var G__1421 = cljs.core.nnext(kvs); +tcoll = G__1418; +key = G__1419; +val = G__1420; +kvs = G__1421; +continue; +} else { +return ntcoll; +} +break; +} +}); + +/** @this {Function} */ +cljs.core.assoc_BANG_.cljs$lang$applyTo = (function (seq1409){ +var G__1410 = cljs.core.first(seq1409); +var seq1409__$1 = cljs.core.next(seq1409); +var G__1411 = cljs.core.first(seq1409__$1); +var seq1409__$2 = cljs.core.next(seq1409__$1); +var G__1412 = cljs.core.first(seq1409__$2); +var seq1409__$3 = cljs.core.next(seq1409__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1410,G__1411,G__1412,seq1409__$3); +}); + +cljs.core.assoc_BANG_.cljs$lang$maxFixedArity = (3); + +/** + * Returns a transient map that doesn't contain a mapping for key(s). + */ +cljs.core.dissoc_BANG_ = (function cljs$core$dissoc_BANG_(var_args){ +var G__1426 = arguments.length; +switch (G__1426) { +case 2: +return cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1428 = arguments.length; +var i__4519__auto___1429 = (0); +while(true){ +if((i__4519__auto___1429 < len__4518__auto___1428)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1429])); + +var G__1430 = (i__4519__auto___1429 + (1)); +i__4519__auto___1429 = G__1430; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (tcoll,key){ +return cljs.core._dissoc_BANG_(tcoll,key); +}); + +cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (tcoll,key,ks){ +while(true){ +var ntcoll = cljs.core._dissoc_BANG_(tcoll,key); +if(cljs.core.truth_(ks)){ +var G__1431 = ntcoll; +var G__1432 = cljs.core.first(ks); +var G__1433 = cljs.core.next(ks); +tcoll = G__1431; +key = G__1432; +ks = G__1433; +continue; +} else { +return ntcoll; +} +break; +} +}); + +/** @this {Function} */ +cljs.core.dissoc_BANG_.cljs$lang$applyTo = (function (seq1423){ +var G__1424 = cljs.core.first(seq1423); +var seq1423__$1 = cljs.core.next(seq1423); +var G__1425 = cljs.core.first(seq1423__$1); +var seq1423__$2 = cljs.core.next(seq1423__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1424,G__1425,seq1423__$2); +}); + +cljs.core.dissoc_BANG_.cljs$lang$maxFixedArity = (2); + +/** + * Removes the last item from a transient vector. If + * the collection is empty, throws an exception. Returns tcoll + */ +cljs.core.pop_BANG_ = (function cljs$core$pop_BANG_(tcoll){ +return cljs.core._pop_BANG_(tcoll); +}); +/** + * disj[oin]. Returns a transient set of the same (hashed/sorted) type, that + * does not contain key(s). + */ +cljs.core.disj_BANG_ = (function cljs$core$disj_BANG_(var_args){ +var G__1438 = arguments.length; +switch (G__1438) { +case 2: +return cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1440 = arguments.length; +var i__4519__auto___1441 = (0); +while(true){ +if((i__4519__auto___1441 < len__4518__auto___1440)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1441])); + +var G__1442 = (i__4519__auto___1441 + (1)); +i__4519__auto___1441 = G__1442; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (tcoll,val){ +return cljs.core._disjoin_BANG_(tcoll,val); +}); + +cljs.core.disj_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (tcoll,val,vals){ +while(true){ +var ntcoll = cljs.core._disjoin_BANG_(tcoll,val); +if(cljs.core.truth_(vals)){ +var G__1443 = ntcoll; +var G__1444 = cljs.core.first(vals); +var G__1445 = cljs.core.next(vals); +tcoll = G__1443; +val = G__1444; +vals = G__1445; +continue; +} else { +return ntcoll; +} +break; +} +}); + +/** @this {Function} */ +cljs.core.disj_BANG_.cljs$lang$applyTo = (function (seq1435){ +var G__1436 = cljs.core.first(seq1435); +var seq1435__$1 = cljs.core.next(seq1435); +var G__1437 = cljs.core.first(seq1435__$1); +var seq1435__$2 = cljs.core.next(seq1435__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1436,G__1437,seq1435__$2); +}); + +cljs.core.disj_BANG_.cljs$lang$maxFixedArity = (2); + + +cljs.core.apply_to = (function cljs$core$apply_to(f,argc,args){ +var args__$1 = cljs.core.seq(args); +if((argc === (0))){ +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +} else { +var a151 = cljs.core._first(args__$1); +var args__$2 = cljs.core._rest(args__$1); +if((argc === (1))){ +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(a151) : f.call(null,a151)); +} else { +var b152 = cljs.core._first(args__$2); +var args__$3 = cljs.core._rest(args__$2); +if((argc === (2))){ +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(a151,b152) : f.call(null,a151,b152)); +} else { +var c153 = cljs.core._first(args__$3); +var args__$4 = cljs.core._rest(args__$3); +if((argc === (3))){ +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(a151,b152,c153) : f.call(null,a151,b152,c153)); +} else { +var d154 = cljs.core._first(args__$4); +var args__$5 = cljs.core._rest(args__$4); +if((argc === (4))){ +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(a151,b152,c153,d154) : f.call(null,a151,b152,c153,d154)); +} else { +var e155 = cljs.core._first(args__$5); +var args__$6 = cljs.core._rest(args__$5); +if((argc === (5))){ +return (f.cljs$core$IFn$_invoke$arity$5 ? f.cljs$core$IFn$_invoke$arity$5(a151,b152,c153,d154,e155) : f.call(null,a151,b152,c153,d154,e155)); +} else { +var f156 = cljs.core._first(args__$6); +var args__$7 = cljs.core._rest(args__$6); +if((argc === (6))){ +return (f.cljs$core$IFn$_invoke$arity$6 ? f.cljs$core$IFn$_invoke$arity$6(a151,b152,c153,d154,e155,f156) : f.call(null,a151,b152,c153,d154,e155,f156)); +} else { +var g157 = cljs.core._first(args__$7); +var args__$8 = cljs.core._rest(args__$7); +if((argc === (7))){ +return (f.cljs$core$IFn$_invoke$arity$7 ? f.cljs$core$IFn$_invoke$arity$7(a151,b152,c153,d154,e155,f156,g157) : f.call(null,a151,b152,c153,d154,e155,f156,g157)); +} else { +var h158 = cljs.core._first(args__$8); +var args__$9 = cljs.core._rest(args__$8); +if((argc === (8))){ +return (f.cljs$core$IFn$_invoke$arity$8 ? f.cljs$core$IFn$_invoke$arity$8(a151,b152,c153,d154,e155,f156,g157,h158) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158)); +} else { +var i159 = cljs.core._first(args__$9); +var args__$10 = cljs.core._rest(args__$9); +if((argc === (9))){ +return (f.cljs$core$IFn$_invoke$arity$9 ? f.cljs$core$IFn$_invoke$arity$9(a151,b152,c153,d154,e155,f156,g157,h158,i159) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159)); +} else { +var j160 = cljs.core._first(args__$10); +var args__$11 = cljs.core._rest(args__$10); +if((argc === (10))){ +return (f.cljs$core$IFn$_invoke$arity$10 ? f.cljs$core$IFn$_invoke$arity$10(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160)); +} else { +var k161 = cljs.core._first(args__$11); +var args__$12 = cljs.core._rest(args__$11); +if((argc === (11))){ +return (f.cljs$core$IFn$_invoke$arity$11 ? f.cljs$core$IFn$_invoke$arity$11(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161)); +} else { +var l162 = cljs.core._first(args__$12); +var args__$13 = cljs.core._rest(args__$12); +if((argc === (12))){ +return (f.cljs$core$IFn$_invoke$arity$12 ? f.cljs$core$IFn$_invoke$arity$12(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162)); +} else { +var m163 = cljs.core._first(args__$13); +var args__$14 = cljs.core._rest(args__$13); +if((argc === (13))){ +return (f.cljs$core$IFn$_invoke$arity$13 ? f.cljs$core$IFn$_invoke$arity$13(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163)); +} else { +var n164 = cljs.core._first(args__$14); +var args__$15 = cljs.core._rest(args__$14); +if((argc === (14))){ +return (f.cljs$core$IFn$_invoke$arity$14 ? f.cljs$core$IFn$_invoke$arity$14(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164)); +} else { +var o165 = cljs.core._first(args__$15); +var args__$16 = cljs.core._rest(args__$15); +if((argc === (15))){ +return (f.cljs$core$IFn$_invoke$arity$15 ? f.cljs$core$IFn$_invoke$arity$15(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165)); +} else { +var p166 = cljs.core._first(args__$16); +var args__$17 = cljs.core._rest(args__$16); +if((argc === (16))){ +return (f.cljs$core$IFn$_invoke$arity$16 ? f.cljs$core$IFn$_invoke$arity$16(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166)); +} else { +var q167 = cljs.core._first(args__$17); +var args__$18 = cljs.core._rest(args__$17); +if((argc === (17))){ +return (f.cljs$core$IFn$_invoke$arity$17 ? f.cljs$core$IFn$_invoke$arity$17(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167)); +} else { +var r168 = cljs.core._first(args__$18); +var args__$19 = cljs.core._rest(args__$18); +if((argc === (18))){ +return (f.cljs$core$IFn$_invoke$arity$18 ? f.cljs$core$IFn$_invoke$arity$18(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167,r168) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167,r168)); +} else { +var s169 = cljs.core._first(args__$19); +var args__$20 = cljs.core._rest(args__$19); +if((argc === (19))){ +return (f.cljs$core$IFn$_invoke$arity$19 ? f.cljs$core$IFn$_invoke$arity$19(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167,r168,s169) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167,r168,s169)); +} else { +var t170 = cljs.core._first(args__$20); +var args__$21 = cljs.core._rest(args__$20); +if((argc === (20))){ +return (f.cljs$core$IFn$_invoke$arity$20 ? f.cljs$core$IFn$_invoke$arity$20(a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167,r168,s169,t170) : f.call(null,a151,b152,c153,d154,e155,f156,g157,h158,i159,j160,k161,l162,m163,n164,o165,p166,q167,r168,s169,t170)); +} else { +throw (new Error("Only up to 20 arguments supported on functions")); +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +}); + +/** + * Internal. DO NOT USE! + * Assumes args was already called with seq beforehand! + */ +cljs.core.apply_to_simple = (function cljs$core$apply_to_simple(var_args){ +var G__1447 = arguments.length; +switch (G__1447) { +case 2: +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +case 6: +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2 = (function (f,args){ +if((args == null)){ +if(f.cljs$core$IFn$_invoke$arity$0){ +return f.cljs$core$IFn$_invoke$arity$0(); +} else { +return f.call(f); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3(f,cljs.core._first(args),cljs.core.next(args)); +} +}); + +cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3 = (function (f,a0,args){ +if((args == null)){ +if(f.cljs$core$IFn$_invoke$arity$1){ +return f.cljs$core$IFn$_invoke$arity$1(a0); +} else { +return f.call(f,a0); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4(f,a0,cljs.core._first(args),cljs.core.next(args)); +} +}); + +cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4 = (function (f,a0,a1,args){ +if((args == null)){ +if(f.cljs$core$IFn$_invoke$arity$2){ +return f.cljs$core$IFn$_invoke$arity$2(a0,a1); +} else { +return f.call(f,a0,a1); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5(f,a0,a1,cljs.core._first(args),cljs.core.next(args)); +} +}); + +cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5 = (function (f,a0,a1,a2,args){ +if((args == null)){ +if(f.cljs$core$IFn$_invoke$arity$3){ +return f.cljs$core$IFn$_invoke$arity$3(a0,a1,a2); +} else { +return f.call(f,a0,a1,a2); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6(f,a0,a1,a2,cljs.core._first(args),cljs.core.next(args)); +} +}); + +cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6 = (function (f,a0,a1,a2,a3,args){ +if((args == null)){ +if(f.cljs$core$IFn$_invoke$arity$4){ +return f.cljs$core$IFn$_invoke$arity$4(a0,a1,a2,a3); +} else { +return f.call(f,a0,a1,a2,a3); +} +} else { +var a4 = cljs.core._first(args); +var next_4 = cljs.core.next(args); +if((next_4 == null)){ +if(f.cljs$core$IFn$_invoke$arity$5){ +return f.cljs$core$IFn$_invoke$arity$5(a0,a1,a2,a3,a4); +} else { +return f.call(f,a0,a1,a2,a3,a4); +} +} else { +var a5 = cljs.core._first(next_4); +var next_5 = cljs.core.next(next_4); +if((next_5 == null)){ +if(f.cljs$core$IFn$_invoke$arity$6){ +return f.cljs$core$IFn$_invoke$arity$6(a0,a1,a2,a3,a4,a5); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5); +} +} else { +var a6 = cljs.core._first(next_5); +var next_6 = cljs.core.next(next_5); +if((next_6 == null)){ +if(f.cljs$core$IFn$_invoke$arity$7){ +return f.cljs$core$IFn$_invoke$arity$7(a0,a1,a2,a3,a4,a5,a6); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6); +} +} else { +var a7 = cljs.core._first(next_6); +var next_7 = cljs.core.next(next_6); +if((next_7 == null)){ +if(f.cljs$core$IFn$_invoke$arity$8){ +return f.cljs$core$IFn$_invoke$arity$8(a0,a1,a2,a3,a4,a5,a6,a7); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7); +} +} else { +var a8 = cljs.core._first(next_7); +var next_8 = cljs.core.next(next_7); +if((next_8 == null)){ +if(f.cljs$core$IFn$_invoke$arity$9){ +return f.cljs$core$IFn$_invoke$arity$9(a0,a1,a2,a3,a4,a5,a6,a7,a8); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8); +} +} else { +var a9 = cljs.core._first(next_8); +var next_9 = cljs.core.next(next_8); +if((next_9 == null)){ +if(f.cljs$core$IFn$_invoke$arity$10){ +return f.cljs$core$IFn$_invoke$arity$10(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9); +} +} else { +var a10 = cljs.core._first(next_9); +var next_10 = cljs.core.next(next_9); +if((next_10 == null)){ +if(f.cljs$core$IFn$_invoke$arity$11){ +return f.cljs$core$IFn$_invoke$arity$11(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); +} +} else { +var a11 = cljs.core._first(next_10); +var next_11 = cljs.core.next(next_10); +if((next_11 == null)){ +if(f.cljs$core$IFn$_invoke$arity$12){ +return f.cljs$core$IFn$_invoke$arity$12(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11); +} +} else { +var a12 = cljs.core._first(next_11); +var next_12 = cljs.core.next(next_11); +if((next_12 == null)){ +if(f.cljs$core$IFn$_invoke$arity$13){ +return f.cljs$core$IFn$_invoke$arity$13(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); +} +} else { +var a13 = cljs.core._first(next_12); +var next_13 = cljs.core.next(next_12); +if((next_13 == null)){ +if(f.cljs$core$IFn$_invoke$arity$14){ +return f.cljs$core$IFn$_invoke$arity$14(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); +} +} else { +var a14 = cljs.core._first(next_13); +var next_14 = cljs.core.next(next_13); +if((next_14 == null)){ +if(f.cljs$core$IFn$_invoke$arity$15){ +return f.cljs$core$IFn$_invoke$arity$15(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14); +} +} else { +var a15 = cljs.core._first(next_14); +var next_15 = cljs.core.next(next_14); +if((next_15 == null)){ +if(f.cljs$core$IFn$_invoke$arity$16){ +return f.cljs$core$IFn$_invoke$arity$16(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15); +} +} else { +var a16 = cljs.core._first(next_15); +var next_16 = cljs.core.next(next_15); +if((next_16 == null)){ +if(f.cljs$core$IFn$_invoke$arity$17){ +return f.cljs$core$IFn$_invoke$arity$17(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16); +} +} else { +var a17 = cljs.core._first(next_16); +var next_17 = cljs.core.next(next_16); +if((next_17 == null)){ +if(f.cljs$core$IFn$_invoke$arity$18){ +return f.cljs$core$IFn$_invoke$arity$18(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17); +} +} else { +var a18 = cljs.core._first(next_17); +var next_18 = cljs.core.next(next_17); +if((next_18 == null)){ +if(f.cljs$core$IFn$_invoke$arity$19){ +return f.cljs$core$IFn$_invoke$arity$19(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18); +} +} else { +var a19 = cljs.core._first(next_18); +var next_19 = cljs.core.next(next_18); +if((next_19 == null)){ +if(f.cljs$core$IFn$_invoke$arity$20){ +return f.cljs$core$IFn$_invoke$arity$20(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19); +} else { +return f.call(f,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19); +} +} else { +var arr__4443__auto__ = [a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19]; +var s__4444__auto___1449 = next_19; +while(true){ +if(s__4444__auto___1449){ +arr__4443__auto__.push(cljs.core._first(s__4444__auto___1449)); + +var G__1450 = cljs.core.next(s__4444__auto___1449); +s__4444__auto___1449 = G__1450; +continue; +} else { +} +break; +} + +return f.apply(f,arr__4443__auto__); +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +}); + +cljs.core.apply_to_simple.cljs$lang$maxFixedArity = 6; + +/** + * Applies fn f to the argument list formed by prepending intervening arguments to args. + */ +cljs.core.apply = (function cljs$core$apply(var_args){ +var G__1458 = arguments.length; +switch (G__1458) { +case 2: +return cljs.core.apply.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.apply.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.apply.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.apply.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1460 = arguments.length; +var i__4519__auto___1461 = (0); +while(true){ +if((i__4519__auto___1461 < len__4518__auto___1460)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1461])); + +var G__1462 = (i__4519__auto___1461 + (1)); +i__4519__auto___1461 = G__1462; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((5)),(0),null)); +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),argseq__4534__auto__); + +} +}); + +cljs.core.apply.cljs$core$IFn$_invoke$arity$2 = (function (f,args){ +if(f.cljs$lang$applyTo){ +var fixed_arity = f.cljs$lang$maxFixedArity; +var bc = cljs.core.bounded_count((fixed_arity + (1)),args); +if((bc <= fixed_arity)){ +return cljs.core.apply_to(f,bc,args); +} else { +return f.cljs$lang$applyTo(args); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$2(f,cljs.core.seq(args)); +} +}); + +cljs.core.apply.cljs$core$IFn$_invoke$arity$3 = (function (f,x,args){ +if(f.cljs$lang$applyTo){ +var arglist = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$2(x,args); +var fixed_arity = f.cljs$lang$maxFixedArity; +var bc = (cljs.core.bounded_count(fixed_arity,args) + (1)); +if((bc <= fixed_arity)){ +return cljs.core.apply_to(f,bc,arglist); +} else { +return f.cljs$lang$applyTo(arglist); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$3(f,x,cljs.core.seq(args)); +} +}); + +cljs.core.apply.cljs$core$IFn$_invoke$arity$4 = (function (f,x,y,args){ +if(f.cljs$lang$applyTo){ +var arglist = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$3(x,y,args); +var fixed_arity = f.cljs$lang$maxFixedArity; +var bc = ((2) + cljs.core.bounded_count((fixed_arity - (1)),args)); +if((bc <= fixed_arity)){ +return cljs.core.apply_to(f,bc,arglist); +} else { +return f.cljs$lang$applyTo(arglist); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$4(f,x,y,cljs.core.seq(args)); +} +}); + +cljs.core.apply.cljs$core$IFn$_invoke$arity$5 = (function (f,x,y,z,args){ +if(f.cljs$lang$applyTo){ +var arglist = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(x,y,z,args); +var fixed_arity = f.cljs$lang$maxFixedArity; +var bc = ((3) + cljs.core.bounded_count((fixed_arity - (2)),args)); +if((bc <= fixed_arity)){ +return cljs.core.apply_to(f,bc,arglist); +} else { +return f.cljs$lang$applyTo(arglist); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$5(f,x,y,z,cljs.core.seq(args)); +} +}); + +cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic = (function (f,a,b,c,d,args){ +if(f.cljs$lang$applyTo){ +var spread_args = cljs.core.spread(args); +var arglist = cljs.core.cons(a,cljs.core.cons(b,cljs.core.cons(c,cljs.core.cons(d,spread_args)))); +var fixed_arity = f.cljs$lang$maxFixedArity; +var bc = ((4) + cljs.core.bounded_count((fixed_arity - (3)),spread_args)); +if((bc <= fixed_arity)){ +return cljs.core.apply_to(f,bc,arglist); +} else { +return f.cljs$lang$applyTo(arglist); +} +} else { +return cljs.core.apply_to_simple.cljs$core$IFn$_invoke$arity$6(f,a,b,c,d,cljs.core.spread(args)); +} +}); + +/** @this {Function} */ +cljs.core.apply.cljs$lang$applyTo = (function (seq1452){ +var G__1453 = cljs.core.first(seq1452); +var seq1452__$1 = cljs.core.next(seq1452); +var G__1454 = cljs.core.first(seq1452__$1); +var seq1452__$2 = cljs.core.next(seq1452__$1); +var G__1455 = cljs.core.first(seq1452__$2); +var seq1452__$3 = cljs.core.next(seq1452__$2); +var G__1456 = cljs.core.first(seq1452__$3); +var seq1452__$4 = cljs.core.next(seq1452__$3); +var G__1457 = cljs.core.first(seq1452__$4); +var seq1452__$5 = cljs.core.next(seq1452__$4); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1453,G__1454,G__1455,G__1456,G__1457,seq1452__$5); +}); + +cljs.core.apply.cljs$lang$maxFixedArity = (5); + +/** + * Returns an object of the same type and value as obj, with + * (apply f (meta obj) args) as its metadata. + */ +cljs.core.vary_meta = (function cljs$core$vary_meta(var_args){ +var G__1471 = arguments.length; +switch (G__1471) { +case 2: +return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +case 6: +return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1488 = arguments.length; +var i__4519__auto___1489 = (0); +while(true){ +if((i__4519__auto___1489 < len__4518__auto___1488)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1489])); + +var G__1490 = (i__4519__auto___1489 + (1)); +i__4519__auto___1489 = G__1490; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((6)),(0),null)); +return cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__4534__auto__); + +} +}); + +cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$2 = (function (obj,f){ +return cljs.core.with_meta(obj,(function (){var G__1472 = cljs.core.meta(obj); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1472) : f.call(null,G__1472)); +})()); +}); + +cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$3 = (function (obj,f,a){ +return cljs.core.with_meta(obj,(function (){var G__1473 = cljs.core.meta(obj); +var G__1474 = a; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1473,G__1474) : f.call(null,G__1473,G__1474)); +})()); +}); + +cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$4 = (function (obj,f,a,b){ +return cljs.core.with_meta(obj,(function (){var G__1475 = cljs.core.meta(obj); +var G__1476 = a; +var G__1477 = b; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1475,G__1476,G__1477) : f.call(null,G__1475,G__1476,G__1477)); +})()); +}); + +cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$5 = (function (obj,f,a,b,c){ +return cljs.core.with_meta(obj,(function (){var G__1478 = cljs.core.meta(obj); +var G__1479 = a; +var G__1480 = b; +var G__1481 = c; +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__1478,G__1479,G__1480,G__1481) : f.call(null,G__1478,G__1479,G__1480,G__1481)); +})()); +}); + +cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$6 = (function (obj,f,a,b,c,d){ +return cljs.core.with_meta(obj,(function (){var G__1482 = cljs.core.meta(obj); +var G__1483 = a; +var G__1484 = b; +var G__1485 = c; +var G__1486 = d; +return (f.cljs$core$IFn$_invoke$arity$5 ? f.cljs$core$IFn$_invoke$arity$5(G__1482,G__1483,G__1484,G__1485,G__1486) : f.call(null,G__1482,G__1483,G__1484,G__1485,G__1486)); +})()); +}); + +cljs.core.vary_meta.cljs$core$IFn$_invoke$arity$variadic = (function (obj,f,a,b,c,d,args){ +return cljs.core.with_meta(obj,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,cljs.core.meta(obj),a,b,c,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([d,args], 0))); +}); + +/** @this {Function} */ +cljs.core.vary_meta.cljs$lang$applyTo = (function (seq1464){ +var G__1465 = cljs.core.first(seq1464); +var seq1464__$1 = cljs.core.next(seq1464); +var G__1466 = cljs.core.first(seq1464__$1); +var seq1464__$2 = cljs.core.next(seq1464__$1); +var G__1467 = cljs.core.first(seq1464__$2); +var seq1464__$3 = cljs.core.next(seq1464__$2); +var G__1468 = cljs.core.first(seq1464__$3); +var seq1464__$4 = cljs.core.next(seq1464__$3); +var G__1469 = cljs.core.first(seq1464__$4); +var seq1464__$5 = cljs.core.next(seq1464__$4); +var G__1470 = cljs.core.first(seq1464__$5); +var seq1464__$6 = cljs.core.next(seq1464__$5); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1465,G__1466,G__1467,G__1468,G__1469,G__1470,seq1464__$6); +}); + +cljs.core.vary_meta.cljs$lang$maxFixedArity = (6); + +/** + * Same as (not (= obj1 obj2)) + */ +cljs.core.not_EQ_ = (function cljs$core$not_EQ_(var_args){ +var G__1495 = arguments.length; +switch (G__1495) { +case 1: +return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1497 = arguments.length; +var i__4519__auto___1498 = (0); +while(true){ +if((i__4519__auto___1498 < len__4518__auto___1497)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1498])); + +var G__1499 = (i__4519__auto___1498 + (1)); +i__4519__auto___1498 = G__1499; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return false; +}); + +cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2 = (function (x,y){ +return !(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)); +}); + +cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$variadic = (function (x,y,more){ +return cljs.core.not(cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core._EQ_,x,y,more)); +}); + +/** @this {Function} */ +cljs.core.not_EQ_.cljs$lang$applyTo = (function (seq1492){ +var G__1493 = cljs.core.first(seq1492); +var seq1492__$1 = cljs.core.next(seq1492); +var G__1494 = cljs.core.first(seq1492__$1); +var seq1492__$2 = cljs.core.next(seq1492__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1493,G__1494,seq1492__$2); +}); + +cljs.core.not_EQ_.cljs$lang$maxFixedArity = (2); + +/** + * If coll is empty, returns nil, else coll + */ +cljs.core.not_empty = (function cljs$core$not_empty(coll){ +if(cljs.core.seq(coll)){ +return coll; +} else { +return null; +} +}); +cljs.core.nil_iter = (function cljs$core$nil_iter(){ +if((typeof cljs !== 'undefined') && (typeof cljs.core !== 'undefined') && (typeof cljs.core.t_cljs$core1500 !== 'undefined')){ +} else { + +/** +* @constructor + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.t_cljs$core1500 = (function (meta1501){ +this.meta1501 = meta1501; +this.cljs$lang$protocol_mask$partition0$ = 393216; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.t_cljs$core1500.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (_1502,meta1501__$1){ +var self__ = this; +var _1502__$1 = this; +return (new cljs.core.t_cljs$core1500(meta1501__$1)); +}); + +cljs.core.t_cljs$core1500.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_1502){ +var self__ = this; +var _1502__$1 = this; +return self__.meta1501; +}); + +cljs.core.t_cljs$core1500.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return false; +}); + +cljs.core.t_cljs$core1500.prototype.next = (function (){ +var self__ = this; +var _ = this; +return (new Error("No such element")); +}); + +cljs.core.t_cljs$core1500.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.t_cljs$core1500.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta1501], null); +}); + +cljs.core.t_cljs$core1500.cljs$lang$type = true; + +cljs.core.t_cljs$core1500.cljs$lang$ctorStr = "cljs.core/t_cljs$core1500"; + +cljs.core.t_cljs$core1500.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/t_cljs$core1500"); +}); + +/** + * Positional factory function for cljs.core/t_cljs$core1500. + */ +cljs.core.__GT_t_cljs$core1500 = (function cljs$core$nil_iter_$___GT_t_cljs$core1500(meta1501){ +return (new cljs.core.t_cljs$core1500(meta1501)); +}); + +} + +return (new cljs.core.t_cljs$core1500(cljs.core.PersistentArrayMap.EMPTY)); +}); + +/** +* @constructor +*/ +cljs.core.StringIter = (function (s,i){ +this.s = s; +this.i = i; +}); +cljs.core.StringIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return (self__.i < self__.s.length); +}); + +cljs.core.StringIter.prototype.next = (function (){ +var self__ = this; +var _ = this; +var ret = self__.s.charAt(self__.i); +self__.i = (self__.i + (1)); + +return ret; +}); + +cljs.core.StringIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.StringIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$s,cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.StringIter.cljs$lang$type = true; + +cljs.core.StringIter.cljs$lang$ctorStr = "cljs.core/StringIter"; + +cljs.core.StringIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/StringIter"); +}); + +/** + * Positional factory function for cljs.core/StringIter. + */ +cljs.core.__GT_StringIter = (function cljs$core$__GT_StringIter(s,i){ +return (new cljs.core.StringIter(s,i)); +}); + +cljs.core.string_iter = (function cljs$core$string_iter(x){ +return (new cljs.core.StringIter(x,(0))); +}); + +/** +* @constructor +*/ +cljs.core.ArrayIter = (function (arr,i){ +this.arr = arr; +this.i = i; +}); +cljs.core.ArrayIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return (self__.i < self__.arr.length); +}); + +cljs.core.ArrayIter.prototype.next = (function (){ +var self__ = this; +var _ = this; +var ret = (self__.arr[self__.i]); +self__.i = (self__.i + (1)); + +return ret; +}); + +cljs.core.ArrayIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.ArrayIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ArrayIter.cljs$lang$type = true; + +cljs.core.ArrayIter.cljs$lang$ctorStr = "cljs.core/ArrayIter"; + +cljs.core.ArrayIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ArrayIter"); +}); + +/** + * Positional factory function for cljs.core/ArrayIter. + */ +cljs.core.__GT_ArrayIter = (function cljs$core$__GT_ArrayIter(arr,i){ +return (new cljs.core.ArrayIter(arr,i)); +}); + +cljs.core.array_iter = (function cljs$core$array_iter(x){ +return (new cljs.core.ArrayIter(x,(0))); +}); +cljs.core.INIT = ({}); +cljs.core.START = ({}); + +/** +* @constructor +*/ +cljs.core.SeqIter = (function (_seq,_next){ +this._seq = _seq; +this._next = _next; +}); +cljs.core.SeqIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +if((self__._seq === cljs.core.INIT)){ +self__._seq = cljs.core.START; + +self__._next = cljs.core.seq(self__._next); +} else { +if((self__._seq === self__._next)){ +self__._next = cljs.core.next(self__._seq); +} else { +} +} + +return !((self__._next == null)); +}); + +cljs.core.SeqIter.prototype.next = (function (){ +var self__ = this; +var this$ = this; +if(!(this$.hasNext())){ +throw (new Error("No such element")); +} else { +self__._seq = self__._next; + +return cljs.core.first(self__._next); +} +}); + +cljs.core.SeqIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.SeqIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$_seq,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$_next,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.SeqIter.cljs$lang$type = true; + +cljs.core.SeqIter.cljs$lang$ctorStr = "cljs.core/SeqIter"; + +cljs.core.SeqIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/SeqIter"); +}); + +/** + * Positional factory function for cljs.core/SeqIter. + */ +cljs.core.__GT_SeqIter = (function cljs$core$__GT_SeqIter(_seq,_next){ +return (new cljs.core.SeqIter(_seq,_next)); +}); + +cljs.core.seq_iter = (function cljs$core$seq_iter(coll){ +return (new cljs.core.SeqIter(cljs.core.INIT,coll)); +}); +cljs.core.iter = (function cljs$core$iter(coll){ +if(cljs.core.iterable_QMARK_(coll)){ +return cljs.core._iterator(coll); +} else { +if((coll == null)){ +return cljs.core.nil_iter(); +} else { +if(typeof coll === 'string'){ +return cljs.core.string_iter(coll); +} else { +if(cljs.core.array_QMARK_(coll)){ +return cljs.core.array_iter(coll); +} else { +if(cljs.core.seqable_QMARK_(coll)){ +return cljs.core.seq_iter(coll); +} else { +throw (new Error(["Cannot create iterator from ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll)].join(''))); + +} +} +} +} +} +}); + +/** +* @constructor +*/ +cljs.core.Many = (function (vals){ +this.vals = vals; +}); +cljs.core.Many.prototype.add = (function (o){ +var self__ = this; +var this$ = this; +self__.vals.push(o); + +return this$; +}); + +cljs.core.Many.prototype.remove = (function (){ +var self__ = this; +var this$ = this; +return self__.vals.shift(); +}); + +cljs.core.Many.prototype.isEmpty = (function (){ +var self__ = this; +var this$ = this; +return (self__.vals.length === (0)); +}); + +cljs.core.Many.prototype.toString = (function (){ +var self__ = this; +var this$ = this; +return ["Many: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.vals)].join(''); +}); + +cljs.core.Many.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$vals], null); +}); + +cljs.core.Many.cljs$lang$type = true; + +cljs.core.Many.cljs$lang$ctorStr = "cljs.core/Many"; + +cljs.core.Many.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Many"); +}); + +/** + * Positional factory function for cljs.core/Many. + */ +cljs.core.__GT_Many = (function cljs$core$__GT_Many(vals){ +return (new cljs.core.Many(vals)); +}); + +cljs.core.NONE = ({}); + +/** +* @constructor +*/ +cljs.core.Single = (function (val){ +this.val = val; +}); +cljs.core.Single.prototype.add = (function (o){ +var self__ = this; +var this$ = this; +if((self__.val === cljs.core.NONE)){ +self__.val = o; + +return this$; +} else { +return (new cljs.core.Many([self__.val,o])); +} +}); + +cljs.core.Single.prototype.remove = (function (){ +var self__ = this; +var this$ = this; +if((self__.val === cljs.core.NONE)){ +throw (new Error(["Removing object from empty buffer"].join(''))); +} else { +var ret = self__.val; +self__.val = cljs.core.NONE; + +return ret; +} +}); + +cljs.core.Single.prototype.isEmpty = (function (){ +var self__ = this; +var this$ = this; +return (self__.val === cljs.core.NONE); +}); + +cljs.core.Single.prototype.toString = (function (){ +var self__ = this; +var this$ = this; +return ["Single: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.val)].join(''); +}); + +cljs.core.Single.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$val,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Single.cljs$lang$type = true; + +cljs.core.Single.cljs$lang$ctorStr = "cljs.core/Single"; + +cljs.core.Single.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Single"); +}); + +/** + * Positional factory function for cljs.core/Single. + */ +cljs.core.__GT_Single = (function cljs$core$__GT_Single(val){ +return (new cljs.core.Single(val)); +}); + + +/** +* @constructor +*/ +cljs.core.Empty = (function (){ +}); +cljs.core.Empty.prototype.add = (function (o){ +var self__ = this; +var this$ = this; +return (new cljs.core.Single(o)); +}); + +cljs.core.Empty.prototype.remove = (function (){ +var self__ = this; +var this$ = this; +throw (new Error(["Removing object from empty buffer"].join(''))); +}); + +cljs.core.Empty.prototype.isEmpty = (function (){ +var self__ = this; +var this$ = this; +return true; +}); + +cljs.core.Empty.prototype.toString = (function (){ +var self__ = this; +var this$ = this; +return "Empty"; +}); + +cljs.core.Empty.getBasis = (function (){ +return cljs.core.PersistentVector.EMPTY; +}); + +cljs.core.Empty.cljs$lang$type = true; + +cljs.core.Empty.cljs$lang$ctorStr = "cljs.core/Empty"; + +cljs.core.Empty.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Empty"); +}); + +/** + * Positional factory function for cljs.core/Empty. + */ +cljs.core.__GT_Empty = (function cljs$core$__GT_Empty(){ +return (new cljs.core.Empty()); +}); + +cljs.core.EMPTY = (new cljs.core.Empty()); + +/** +* @constructor +*/ +cljs.core.MultiIterator = (function (iters){ +this.iters = iters; +}); +cljs.core.MultiIterator.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +var iters__$1 = cljs.core.seq(self__.iters); +while(true){ +if(!((iters__$1 == null))){ +var iter = cljs.core.first(iters__$1); +if(!(iter.hasNext())){ +return false; +} else { +var G__1503 = cljs.core.next(iters__$1); +iters__$1 = G__1503; +continue; +} +} else { +return true; +} +break; +} +}); + +cljs.core.MultiIterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +var nexts = []; +var n__4395__auto___1504 = self__.iters.length; +var i_1505 = (0); +while(true){ +if((i_1505 < n__4395__auto___1504)){ +(nexts[i_1505] = (self__.iters[i_1505]).next()); + +var G__1506 = (i_1505 + (1)); +i_1505 = G__1506; +continue; +} else { +} +break; +} + +return cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(nexts,(0)); +}); + +cljs.core.MultiIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$iters], null); +}); + +cljs.core.MultiIterator.cljs$lang$type = true; + +cljs.core.MultiIterator.cljs$lang$ctorStr = "cljs.core/MultiIterator"; + +cljs.core.MultiIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/MultiIterator"); +}); + +/** + * Positional factory function for cljs.core/MultiIterator. + */ +cljs.core.__GT_MultiIterator = (function cljs$core$__GT_MultiIterator(iters){ +return (new cljs.core.MultiIterator(iters)); +}); + +cljs.core.chunkIteratorSeq = (function cljs$core$chunkIteratorSeq(iter){ +return (new cljs.core.LazySeq(null,(function (){ +if(iter.hasNext()){ +var arr = []; +var n = (0); +while(true){ +if(cljs.core.truth_((function (){var and__3925__auto__ = iter.hasNext(); +if(cljs.core.truth_(and__3925__auto__)){ +return (n < (32)); +} else { +return and__3925__auto__; +} +})())){ +(arr[n] = iter.next()); + +var G__1507 = (n + (1)); +n = G__1507; +continue; +} else { +return cljs.core.chunk_cons(cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$3(arr,(0),n),(cljs.core.chunkIteratorSeq.cljs$core$IFn$_invoke$arity$1 ? cljs.core.chunkIteratorSeq.cljs$core$IFn$_invoke$arity$1(iter) : cljs.core.chunkIteratorSeq.call(null,iter))); +} +break; +} +} else { +return null; +} +}),null,null)); +}); + +/** +* @constructor +*/ +cljs.core.TransformerIterator = (function (buffer,_next,completed,xf,sourceIter,multi){ +this.buffer = buffer; +this._next = _next; +this.completed = completed; +this.xf = xf; +this.sourceIter = sourceIter; +this.multi = multi; +}); +cljs.core.TransformerIterator.prototype.step = (function (){ +var self__ = this; +var this$ = this; +if(!((self__._next === cljs.core.NONE))){ +return true; +} else { +while(true){ +if((self__._next === cljs.core.NONE)){ +if(self__.buffer.isEmpty()){ +if(self__.completed){ +return false; +} else { +if(self__.sourceIter.hasNext()){ +var iter = ((self__.multi)?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(self__.xf,cljs.core.cons(null,self__.sourceIter.next())):(function (){var G__1508 = null; +var G__1509 = self__.sourceIter.next(); +return (self__.xf.cljs$core$IFn$_invoke$arity$2 ? self__.xf.cljs$core$IFn$_invoke$arity$2(G__1508,G__1509) : self__.xf.call(null,G__1508,G__1509)); +})()); +if(cljs.core.reduced_QMARK_(iter)){ +(self__.xf.cljs$core$IFn$_invoke$arity$1 ? self__.xf.cljs$core$IFn$_invoke$arity$1(null) : self__.xf.call(null,null)); + +self__.completed = true; +} else { +} + +continue; +} else { +(self__.xf.cljs$core$IFn$_invoke$arity$1 ? self__.xf.cljs$core$IFn$_invoke$arity$1(null) : self__.xf.call(null,null)); + +self__.completed = true; + +continue; +} +} +} else { +self__._next = self__.buffer.remove(); + +continue; +} +} else { +return true; +} +break; +} +} +}); + +cljs.core.TransformerIterator.prototype.hasNext = (function (){ +var self__ = this; +var this$ = this; +return this$.step(); +}); + +cljs.core.TransformerIterator.prototype.next = (function (){ +var self__ = this; +var this$ = this; +if(this$.hasNext()){ +var ret = self__._next; +self__._next = cljs.core.NONE; + +return ret; +} else { +throw (new Error("No such element")); +} +}); + +cljs.core.TransformerIterator.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.TransformerIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$buffer,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$_next,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$completed,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$xf,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$sourceIter,cljs.core.cst$sym$multi], null); +}); + +cljs.core.TransformerIterator.cljs$lang$type = true; + +cljs.core.TransformerIterator.cljs$lang$ctorStr = "cljs.core/TransformerIterator"; + +cljs.core.TransformerIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/TransformerIterator"); +}); + +/** + * Positional factory function for cljs.core/TransformerIterator. + */ +cljs.core.__GT_TransformerIterator = (function cljs$core$__GT_TransformerIterator(buffer,_next,completed,xf,sourceIter,multi){ +return (new cljs.core.TransformerIterator(buffer,_next,completed,xf,sourceIter,multi)); +}); + +var G__1510_1513 = cljs.core.TransformerIterator.prototype; +var G__1511_1514 = cljs.core.ITER_SYMBOL; +var G__1512_1515 = ((function (G__1510_1513,G__1511_1514){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__1510_1513,G__1511_1514)) +; +goog.object.set(G__1510_1513,G__1511_1514,G__1512_1515); +cljs.core.transformer_iterator = (function cljs$core$transformer_iterator(xform,sourceIter,multi){ +var iterator = (new cljs.core.TransformerIterator(cljs.core.EMPTY,cljs.core.NONE,false,null,sourceIter,multi)); +iterator.xf = (function (){var G__1516 = ((function (iterator){ +return (function() { +var G__1517 = null; +var G__1517__0 = (function (){ +return null; +}); +var G__1517__1 = (function (acc){ +return acc; +}); +var G__1517__2 = (function (acc,o){ +iterator.buffer = iterator.buffer.add(o); + +return acc; +}); +G__1517 = function(acc,o){ +switch(arguments.length){ +case 0: +return G__1517__0.call(this); +case 1: +return G__1517__1.call(this,acc); +case 2: +return G__1517__2.call(this,acc,o); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1517.cljs$core$IFn$_invoke$arity$0 = G__1517__0; +G__1517.cljs$core$IFn$_invoke$arity$1 = G__1517__1; +G__1517.cljs$core$IFn$_invoke$arity$2 = G__1517__2; +return G__1517; +})() +;})(iterator)) +; +return (xform.cljs$core$IFn$_invoke$arity$1 ? xform.cljs$core$IFn$_invoke$arity$1(G__1516) : xform.call(null,G__1516)); +})(); + +return iterator; +}); +cljs.core.TransformerIterator.create = (function (xform,source){ +return cljs.core.transformer_iterator(xform,source,false); +}); +cljs.core.TransformerIterator.createMulti = (function (xform,sources){ +return cljs.core.transformer_iterator(xform,(new cljs.core.MultiIterator(cljs.core.to_array(sources))),true); +}); +/** + * Coerces coll to a (possibly empty) sequence, if it is not already + * one. Will not force a lazy seq. (sequence nil) yields (), When a + * transducer is supplied, returns a lazy sequence of applications of + * the transform to the items in coll(s), i.e. to the set of first + * items of each coll, followed by the set of second + * items in each coll, until any one of the colls is exhausted. Any + * remaining items in other colls are ignored. The transform should accept + * number-of-colls arguments + */ +cljs.core.sequence = (function cljs$core$sequence(var_args){ +var G__1522 = arguments.length; +switch (G__1522) { +case 1: +return cljs.core.sequence.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.sequence.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1524 = arguments.length; +var i__4519__auto___1525 = (0); +while(true){ +if((i__4519__auto___1525 < len__4518__auto___1524)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1525])); + +var G__1526 = (i__4519__auto___1525 + (1)); +i__4519__auto___1525 = G__1526; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.sequence.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +if(cljs.core.seq_QMARK_(coll)){ +return coll; +} else { +var or__3936__auto__ = cljs.core.seq(coll); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return cljs.core.List.EMPTY; +} +} +}); + +cljs.core.sequence.cljs$core$IFn$_invoke$arity$2 = (function (xform,coll){ +var or__3936__auto__ = cljs.core.chunkIteratorSeq(cljs.core.TransformerIterator.create(xform,cljs.core.iter(coll))); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.sequence.cljs$core$IFn$_invoke$arity$variadic = (function (xform,coll,colls){ +var or__3936__auto__ = cljs.core.chunkIteratorSeq(cljs.core.TransformerIterator.createMulti(xform,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.iter,cljs.core.cons(coll,colls)))); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.List.EMPTY; +} +}); + +/** @this {Function} */ +cljs.core.sequence.cljs$lang$applyTo = (function (seq1519){ +var G__1520 = cljs.core.first(seq1519); +var seq1519__$1 = cljs.core.next(seq1519); +var G__1521 = cljs.core.first(seq1519__$1); +var seq1519__$2 = cljs.core.next(seq1519__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1520,G__1521,seq1519__$2); +}); + +cljs.core.sequence.cljs$lang$maxFixedArity = (2); + +/** + * Returns true if (pred x) is logical true for every x in coll, else + * false. + */ +cljs.core.every_QMARK_ = (function cljs$core$every_QMARK_(pred,coll){ +while(true){ +if((cljs.core.seq(coll) == null)){ +return true; +} else { +if(cljs.core.truth_((function (){var G__1527 = cljs.core.first(coll); +return (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__1527) : pred.call(null,G__1527)); +})())){ +var G__1528 = pred; +var G__1529 = cljs.core.next(coll); +pred = G__1528; +coll = G__1529; +continue; +} else { +return false; + +} +} +break; +} +}); +/** + * Returns false if (pred x) is logical true for every x in + * coll, else true. + */ +cljs.core.not_every_QMARK_ = (function cljs$core$not_every_QMARK_(pred,coll){ +return !(cljs.core.every_QMARK_(pred,coll)); +}); +/** + * Returns the first logical true value of (pred x) for any x in coll, + * else nil. One common idiom is to use a set as pred, for example + * this will return :fred if :fred is in the sequence, otherwise nil: + * (some #{:fred} coll) + */ +cljs.core.some = (function cljs$core$some(pred,coll){ +while(true){ +if(cljs.core.seq(coll)){ +var or__3936__auto__ = (function (){var G__1531 = cljs.core.first(coll); +return (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__1531) : pred.call(null,G__1531)); +})(); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var G__1532 = pred; +var G__1533 = cljs.core.next(coll); +pred = G__1532; +coll = G__1533; +continue; +} +} else { +return null; +} +break; +} +}); +/** + * Returns false if (pred x) is logical true for any x in coll, + * else true. + */ +cljs.core.not_any_QMARK_ = (function cljs$core$not_any_QMARK_(pred,coll){ +return cljs.core.not(cljs.core.some(pred,coll)); +}); +/** + * Returns true if n is even, throws an exception if n is not an integer + */ +cljs.core.even_QMARK_ = (function cljs$core$even_QMARK_(n){ +if(cljs.core.integer_QMARK_(n)){ +return ((n & (1)) === (0)); +} else { +throw (new Error(["Argument must be an integer: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)].join(''))); +} +}); +/** + * Returns true if n is odd, throws an exception if n is not an integer + */ +cljs.core.odd_QMARK_ = (function cljs$core$odd_QMARK_(n){ +return !(cljs.core.even_QMARK_(n)); +}); +/** + * Takes a fn f and returns a fn that takes the same arguments as f, + * has the same effects, if any, and returns the opposite truth value. + */ +cljs.core.complement = (function cljs$core$complement(f){ +return (function() { +var G__1534 = null; +var G__1534__0 = (function (){ +return cljs.core.not((f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null))); +}); +var G__1534__1 = (function (x){ +return cljs.core.not((f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null,x))); +}); +var G__1534__2 = (function (x,y){ +return cljs.core.not((f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null,x,y))); +}); +var G__1534__3 = (function() { +var G__1535__delegate = function (x,y,zs){ +return cljs.core.not(cljs.core.apply.cljs$core$IFn$_invoke$arity$4(f,x,y,zs)); +}; +var G__1535 = function (x,y,var_args){ +var zs = null; +if (arguments.length > 2) { +var G__1536__i = 0, G__1536__a = new Array(arguments.length - 2); +while (G__1536__i < G__1536__a.length) {G__1536__a[G__1536__i] = arguments[G__1536__i + 2]; ++G__1536__i;} + zs = new cljs.core.IndexedSeq(G__1536__a,0,null); +} +return G__1535__delegate.call(this,x,y,zs);}; +G__1535.cljs$lang$maxFixedArity = 2; +G__1535.cljs$lang$applyTo = (function (arglist__1537){ +var x = cljs.core.first(arglist__1537); +arglist__1537 = cljs.core.next(arglist__1537); +var y = cljs.core.first(arglist__1537); +var zs = cljs.core.rest(arglist__1537); +return G__1535__delegate(x,y,zs); +}); +G__1535.cljs$core$IFn$_invoke$arity$variadic = G__1535__delegate; +return G__1535; +})() +; +G__1534 = function(x,y,var_args){ +var zs = var_args; +switch(arguments.length){ +case 0: +return G__1534__0.call(this); +case 1: +return G__1534__1.call(this,x); +case 2: +return G__1534__2.call(this,x,y); +default: +var G__1538 = null; +if (arguments.length > 2) { +var G__1539__i = 0, G__1539__a = new Array(arguments.length - 2); +while (G__1539__i < G__1539__a.length) {G__1539__a[G__1539__i] = arguments[G__1539__i + 2]; ++G__1539__i;} +G__1538 = new cljs.core.IndexedSeq(G__1539__a,0,null); +} +return G__1534__3.cljs$core$IFn$_invoke$arity$variadic(x,y, G__1538); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1534.cljs$lang$maxFixedArity = 2; +G__1534.cljs$lang$applyTo = G__1534__3.cljs$lang$applyTo; +G__1534.cljs$core$IFn$_invoke$arity$0 = G__1534__0; +G__1534.cljs$core$IFn$_invoke$arity$1 = G__1534__1; +G__1534.cljs$core$IFn$_invoke$arity$2 = G__1534__2; +G__1534.cljs$core$IFn$_invoke$arity$variadic = G__1534__3.cljs$core$IFn$_invoke$arity$variadic; +return G__1534; +})() +}); +/** + * Returns a function that takes any number of arguments and returns x. + */ +cljs.core.constantly = (function cljs$core$constantly(x){ +return (function() { +var G__1540__delegate = function (args){ +return x; +}; +var G__1540 = function (var_args){ +var args = null; +if (arguments.length > 0) { +var G__1541__i = 0, G__1541__a = new Array(arguments.length - 0); +while (G__1541__i < G__1541__a.length) {G__1541__a[G__1541__i] = arguments[G__1541__i + 0]; ++G__1541__i;} + args = new cljs.core.IndexedSeq(G__1541__a,0,null); +} +return G__1540__delegate.call(this,args);}; +G__1540.cljs$lang$maxFixedArity = 0; +G__1540.cljs$lang$applyTo = (function (arglist__1542){ +var args = cljs.core.seq(arglist__1542); +return G__1540__delegate(args); +}); +G__1540.cljs$core$IFn$_invoke$arity$variadic = G__1540__delegate; +return G__1540; +})() +; +}); +/** + * Takes a set of functions and returns a fn that is the composition + * of those fns. The returned fn takes a variable number of args, + * applies the rightmost of fns to the args, the next + * fn (right-to-left) to the result, etc. + */ +cljs.core.comp = (function cljs$core$comp(var_args){ +var G__1548 = arguments.length; +switch (G__1548) { +case 0: +return cljs.core.comp.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.comp.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.comp.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.comp.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1566 = arguments.length; +var i__4519__auto___1567 = (0); +while(true){ +if((i__4519__auto___1567 < len__4518__auto___1566)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1567])); + +var G__1568 = (i__4519__auto___1567 + (1)); +i__4519__auto___1567 = G__1568; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.comp.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.identity; +}); + +cljs.core.comp.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return f; +}); + +cljs.core.comp.cljs$core$IFn$_invoke$arity$2 = (function (f,g){ +return (function() { +var G__1569 = null; +var G__1569__0 = (function (){ +var G__1549 = (g.cljs$core$IFn$_invoke$arity$0 ? g.cljs$core$IFn$_invoke$arity$0() : g.call(null)); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1549) : f.call(null,G__1549)); +}); +var G__1569__1 = (function (x){ +var G__1550 = (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(x) : g.call(null,x)); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1550) : f.call(null,G__1550)); +}); +var G__1569__2 = (function (x,y){ +var G__1551 = (g.cljs$core$IFn$_invoke$arity$2 ? g.cljs$core$IFn$_invoke$arity$2(x,y) : g.call(null,x,y)); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1551) : f.call(null,G__1551)); +}); +var G__1569__3 = (function (x,y,z){ +var G__1552 = (g.cljs$core$IFn$_invoke$arity$3 ? g.cljs$core$IFn$_invoke$arity$3(x,y,z) : g.call(null,x,y,z)); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1552) : f.call(null,G__1552)); +}); +var G__1569__4 = (function() { +var G__1570__delegate = function (x,y,z,args){ +var G__1553 = cljs.core.apply.cljs$core$IFn$_invoke$arity$5(g,x,y,z,args); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1553) : f.call(null,G__1553)); +}; +var G__1570 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1571__i = 0, G__1571__a = new Array(arguments.length - 3); +while (G__1571__i < G__1571__a.length) {G__1571__a[G__1571__i] = arguments[G__1571__i + 3]; ++G__1571__i;} + args = new cljs.core.IndexedSeq(G__1571__a,0,null); +} +return G__1570__delegate.call(this,x,y,z,args);}; +G__1570.cljs$lang$maxFixedArity = 3; +G__1570.cljs$lang$applyTo = (function (arglist__1572){ +var x = cljs.core.first(arglist__1572); +arglist__1572 = cljs.core.next(arglist__1572); +var y = cljs.core.first(arglist__1572); +arglist__1572 = cljs.core.next(arglist__1572); +var z = cljs.core.first(arglist__1572); +var args = cljs.core.rest(arglist__1572); +return G__1570__delegate(x,y,z,args); +}); +G__1570.cljs$core$IFn$_invoke$arity$variadic = G__1570__delegate; +return G__1570; +})() +; +G__1569 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__1569__0.call(this); +case 1: +return G__1569__1.call(this,x); +case 2: +return G__1569__2.call(this,x,y); +case 3: +return G__1569__3.call(this,x,y,z); +default: +var G__1573 = null; +if (arguments.length > 3) { +var G__1574__i = 0, G__1574__a = new Array(arguments.length - 3); +while (G__1574__i < G__1574__a.length) {G__1574__a[G__1574__i] = arguments[G__1574__i + 3]; ++G__1574__i;} +G__1573 = new cljs.core.IndexedSeq(G__1574__a,0,null); +} +return G__1569__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1573); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1569.cljs$lang$maxFixedArity = 3; +G__1569.cljs$lang$applyTo = G__1569__4.cljs$lang$applyTo; +G__1569.cljs$core$IFn$_invoke$arity$0 = G__1569__0; +G__1569.cljs$core$IFn$_invoke$arity$1 = G__1569__1; +G__1569.cljs$core$IFn$_invoke$arity$2 = G__1569__2; +G__1569.cljs$core$IFn$_invoke$arity$3 = G__1569__3; +G__1569.cljs$core$IFn$_invoke$arity$variadic = G__1569__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1569; +})() +}); + +cljs.core.comp.cljs$core$IFn$_invoke$arity$3 = (function (f,g,h){ +return (function() { +var G__1575 = null; +var G__1575__0 = (function (){ +var G__1554 = (function (){var G__1555 = (h.cljs$core$IFn$_invoke$arity$0 ? h.cljs$core$IFn$_invoke$arity$0() : h.call(null)); +return (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__1555) : g.call(null,G__1555)); +})(); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1554) : f.call(null,G__1554)); +}); +var G__1575__1 = (function (x){ +var G__1556 = (function (){var G__1557 = (h.cljs$core$IFn$_invoke$arity$1 ? h.cljs$core$IFn$_invoke$arity$1(x) : h.call(null,x)); +return (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__1557) : g.call(null,G__1557)); +})(); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1556) : f.call(null,G__1556)); +}); +var G__1575__2 = (function (x,y){ +var G__1558 = (function (){var G__1559 = (h.cljs$core$IFn$_invoke$arity$2 ? h.cljs$core$IFn$_invoke$arity$2(x,y) : h.call(null,x,y)); +return (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__1559) : g.call(null,G__1559)); +})(); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1558) : f.call(null,G__1558)); +}); +var G__1575__3 = (function (x,y,z){ +var G__1560 = (function (){var G__1561 = (h.cljs$core$IFn$_invoke$arity$3 ? h.cljs$core$IFn$_invoke$arity$3(x,y,z) : h.call(null,x,y,z)); +return (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__1561) : g.call(null,G__1561)); +})(); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1560) : f.call(null,G__1560)); +}); +var G__1575__4 = (function() { +var G__1576__delegate = function (x,y,z,args){ +var G__1562 = (function (){var G__1563 = cljs.core.apply.cljs$core$IFn$_invoke$arity$5(h,x,y,z,args); +return (g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(G__1563) : g.call(null,G__1563)); +})(); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1562) : f.call(null,G__1562)); +}; +var G__1576 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1577__i = 0, G__1577__a = new Array(arguments.length - 3); +while (G__1577__i < G__1577__a.length) {G__1577__a[G__1577__i] = arguments[G__1577__i + 3]; ++G__1577__i;} + args = new cljs.core.IndexedSeq(G__1577__a,0,null); +} +return G__1576__delegate.call(this,x,y,z,args);}; +G__1576.cljs$lang$maxFixedArity = 3; +G__1576.cljs$lang$applyTo = (function (arglist__1578){ +var x = cljs.core.first(arglist__1578); +arglist__1578 = cljs.core.next(arglist__1578); +var y = cljs.core.first(arglist__1578); +arglist__1578 = cljs.core.next(arglist__1578); +var z = cljs.core.first(arglist__1578); +var args = cljs.core.rest(arglist__1578); +return G__1576__delegate(x,y,z,args); +}); +G__1576.cljs$core$IFn$_invoke$arity$variadic = G__1576__delegate; +return G__1576; +})() +; +G__1575 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__1575__0.call(this); +case 1: +return G__1575__1.call(this,x); +case 2: +return G__1575__2.call(this,x,y); +case 3: +return G__1575__3.call(this,x,y,z); +default: +var G__1579 = null; +if (arguments.length > 3) { +var G__1580__i = 0, G__1580__a = new Array(arguments.length - 3); +while (G__1580__i < G__1580__a.length) {G__1580__a[G__1580__i] = arguments[G__1580__i + 3]; ++G__1580__i;} +G__1579 = new cljs.core.IndexedSeq(G__1580__a,0,null); +} +return G__1575__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1579); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1575.cljs$lang$maxFixedArity = 3; +G__1575.cljs$lang$applyTo = G__1575__4.cljs$lang$applyTo; +G__1575.cljs$core$IFn$_invoke$arity$0 = G__1575__0; +G__1575.cljs$core$IFn$_invoke$arity$1 = G__1575__1; +G__1575.cljs$core$IFn$_invoke$arity$2 = G__1575__2; +G__1575.cljs$core$IFn$_invoke$arity$3 = G__1575__3; +G__1575.cljs$core$IFn$_invoke$arity$variadic = G__1575__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1575; +})() +}); + +cljs.core.comp.cljs$core$IFn$_invoke$arity$variadic = (function (f1,f2,f3,fs){ +var fs__$1 = cljs.core.reverse(cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(f1,f2,f3,fs)); +return ((function (fs__$1){ +return (function() { +var G__1581__delegate = function (args){ +var ret = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.first(fs__$1),args); +var fs__$2 = cljs.core.next(fs__$1); +while(true){ +if(fs__$2){ +var G__1582 = (function (){var fexpr__1564 = cljs.core.first(fs__$2); +return (fexpr__1564.cljs$core$IFn$_invoke$arity$1 ? fexpr__1564.cljs$core$IFn$_invoke$arity$1(ret) : fexpr__1564.call(null,ret)); +})(); +var G__1583 = cljs.core.next(fs__$2); +ret = G__1582; +fs__$2 = G__1583; +continue; +} else { +return ret; +} +break; +} +}; +var G__1581 = function (var_args){ +var args = null; +if (arguments.length > 0) { +var G__1584__i = 0, G__1584__a = new Array(arguments.length - 0); +while (G__1584__i < G__1584__a.length) {G__1584__a[G__1584__i] = arguments[G__1584__i + 0]; ++G__1584__i;} + args = new cljs.core.IndexedSeq(G__1584__a,0,null); +} +return G__1581__delegate.call(this,args);}; +G__1581.cljs$lang$maxFixedArity = 0; +G__1581.cljs$lang$applyTo = (function (arglist__1585){ +var args = cljs.core.seq(arglist__1585); +return G__1581__delegate(args); +}); +G__1581.cljs$core$IFn$_invoke$arity$variadic = G__1581__delegate; +return G__1581; +})() +; +;})(fs__$1)) +}); + +/** @this {Function} */ +cljs.core.comp.cljs$lang$applyTo = (function (seq1544){ +var G__1545 = cljs.core.first(seq1544); +var seq1544__$1 = cljs.core.next(seq1544); +var G__1546 = cljs.core.first(seq1544__$1); +var seq1544__$2 = cljs.core.next(seq1544__$1); +var G__1547 = cljs.core.first(seq1544__$2); +var seq1544__$3 = cljs.core.next(seq1544__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1545,G__1546,G__1547,seq1544__$3); +}); + +cljs.core.comp.cljs$lang$maxFixedArity = (3); + +/** + * Takes a function f and fewer than the normal arguments to f, and + * returns a fn that takes a variable number of additional args. When + * called, the returned function calls f with args + additional args. + */ +cljs.core.partial = (function cljs$core$partial(var_args){ +var G__1592 = arguments.length; +switch (G__1592) { +case 1: +return cljs.core.partial.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.partial.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.partial.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.partial.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1594 = arguments.length; +var i__4519__auto___1595 = (0); +while(true){ +if((i__4519__auto___1595 < len__4518__auto___1594)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1595])); + +var G__1596 = (i__4519__auto___1595 + (1)); +i__4519__auto___1595 = G__1596; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((4)),(0),null)); +return cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__4534__auto__); + +} +}); + +cljs.core.partial.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return f; +}); + +cljs.core.partial.cljs$core$IFn$_invoke$arity$2 = (function (f,arg1){ +return (function() { +var G__1597 = null; +var G__1597__0 = (function (){ +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(arg1) : f.call(null,arg1)); +}); +var G__1597__1 = (function (x){ +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(arg1,x) : f.call(null,arg1,x)); +}); +var G__1597__2 = (function (x,y){ +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(arg1,x,y) : f.call(null,arg1,x,y)); +}); +var G__1597__3 = (function (x,y,z){ +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(arg1,x,y,z) : f.call(null,arg1,x,y,z)); +}); +var G__1597__4 = (function() { +var G__1598__delegate = function (x,y,z,args){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,arg1,x,y,z,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([args], 0)); +}; +var G__1598 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1599__i = 0, G__1599__a = new Array(arguments.length - 3); +while (G__1599__i < G__1599__a.length) {G__1599__a[G__1599__i] = arguments[G__1599__i + 3]; ++G__1599__i;} + args = new cljs.core.IndexedSeq(G__1599__a,0,null); +} +return G__1598__delegate.call(this,x,y,z,args);}; +G__1598.cljs$lang$maxFixedArity = 3; +G__1598.cljs$lang$applyTo = (function (arglist__1600){ +var x = cljs.core.first(arglist__1600); +arglist__1600 = cljs.core.next(arglist__1600); +var y = cljs.core.first(arglist__1600); +arglist__1600 = cljs.core.next(arglist__1600); +var z = cljs.core.first(arglist__1600); +var args = cljs.core.rest(arglist__1600); +return G__1598__delegate(x,y,z,args); +}); +G__1598.cljs$core$IFn$_invoke$arity$variadic = G__1598__delegate; +return G__1598; +})() +; +G__1597 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__1597__0.call(this); +case 1: +return G__1597__1.call(this,x); +case 2: +return G__1597__2.call(this,x,y); +case 3: +return G__1597__3.call(this,x,y,z); +default: +var G__1601 = null; +if (arguments.length > 3) { +var G__1602__i = 0, G__1602__a = new Array(arguments.length - 3); +while (G__1602__i < G__1602__a.length) {G__1602__a[G__1602__i] = arguments[G__1602__i + 3]; ++G__1602__i;} +G__1601 = new cljs.core.IndexedSeq(G__1602__a,0,null); +} +return G__1597__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1601); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1597.cljs$lang$maxFixedArity = 3; +G__1597.cljs$lang$applyTo = G__1597__4.cljs$lang$applyTo; +G__1597.cljs$core$IFn$_invoke$arity$0 = G__1597__0; +G__1597.cljs$core$IFn$_invoke$arity$1 = G__1597__1; +G__1597.cljs$core$IFn$_invoke$arity$2 = G__1597__2; +G__1597.cljs$core$IFn$_invoke$arity$3 = G__1597__3; +G__1597.cljs$core$IFn$_invoke$arity$variadic = G__1597__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1597; +})() +}); + +cljs.core.partial.cljs$core$IFn$_invoke$arity$3 = (function (f,arg1,arg2){ +return (function() { +var G__1603 = null; +var G__1603__0 = (function (){ +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(arg1,arg2) : f.call(null,arg1,arg2)); +}); +var G__1603__1 = (function (x){ +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(arg1,arg2,x) : f.call(null,arg1,arg2,x)); +}); +var G__1603__2 = (function (x,y){ +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(arg1,arg2,x,y) : f.call(null,arg1,arg2,x,y)); +}); +var G__1603__3 = (function (x,y,z){ +return (f.cljs$core$IFn$_invoke$arity$5 ? f.cljs$core$IFn$_invoke$arity$5(arg1,arg2,x,y,z) : f.call(null,arg1,arg2,x,y,z)); +}); +var G__1603__4 = (function() { +var G__1604__delegate = function (x,y,z,args){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,arg1,arg2,x,y,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([z,args], 0)); +}; +var G__1604 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1605__i = 0, G__1605__a = new Array(arguments.length - 3); +while (G__1605__i < G__1605__a.length) {G__1605__a[G__1605__i] = arguments[G__1605__i + 3]; ++G__1605__i;} + args = new cljs.core.IndexedSeq(G__1605__a,0,null); +} +return G__1604__delegate.call(this,x,y,z,args);}; +G__1604.cljs$lang$maxFixedArity = 3; +G__1604.cljs$lang$applyTo = (function (arglist__1606){ +var x = cljs.core.first(arglist__1606); +arglist__1606 = cljs.core.next(arglist__1606); +var y = cljs.core.first(arglist__1606); +arglist__1606 = cljs.core.next(arglist__1606); +var z = cljs.core.first(arglist__1606); +var args = cljs.core.rest(arglist__1606); +return G__1604__delegate(x,y,z,args); +}); +G__1604.cljs$core$IFn$_invoke$arity$variadic = G__1604__delegate; +return G__1604; +})() +; +G__1603 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__1603__0.call(this); +case 1: +return G__1603__1.call(this,x); +case 2: +return G__1603__2.call(this,x,y); +case 3: +return G__1603__3.call(this,x,y,z); +default: +var G__1607 = null; +if (arguments.length > 3) { +var G__1608__i = 0, G__1608__a = new Array(arguments.length - 3); +while (G__1608__i < G__1608__a.length) {G__1608__a[G__1608__i] = arguments[G__1608__i + 3]; ++G__1608__i;} +G__1607 = new cljs.core.IndexedSeq(G__1608__a,0,null); +} +return G__1603__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1607); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1603.cljs$lang$maxFixedArity = 3; +G__1603.cljs$lang$applyTo = G__1603__4.cljs$lang$applyTo; +G__1603.cljs$core$IFn$_invoke$arity$0 = G__1603__0; +G__1603.cljs$core$IFn$_invoke$arity$1 = G__1603__1; +G__1603.cljs$core$IFn$_invoke$arity$2 = G__1603__2; +G__1603.cljs$core$IFn$_invoke$arity$3 = G__1603__3; +G__1603.cljs$core$IFn$_invoke$arity$variadic = G__1603__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1603; +})() +}); + +cljs.core.partial.cljs$core$IFn$_invoke$arity$4 = (function (f,arg1,arg2,arg3){ +return (function() { +var G__1609 = null; +var G__1609__0 = (function (){ +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(arg1,arg2,arg3) : f.call(null,arg1,arg2,arg3)); +}); +var G__1609__1 = (function (x){ +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(arg1,arg2,arg3,x) : f.call(null,arg1,arg2,arg3,x)); +}); +var G__1609__2 = (function (x,y){ +return (f.cljs$core$IFn$_invoke$arity$5 ? f.cljs$core$IFn$_invoke$arity$5(arg1,arg2,arg3,x,y) : f.call(null,arg1,arg2,arg3,x,y)); +}); +var G__1609__3 = (function (x,y,z){ +return (f.cljs$core$IFn$_invoke$arity$6 ? f.cljs$core$IFn$_invoke$arity$6(arg1,arg2,arg3,x,y,z) : f.call(null,arg1,arg2,arg3,x,y,z)); +}); +var G__1609__4 = (function() { +var G__1610__delegate = function (x,y,z,args){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,arg1,arg2,arg3,x,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([y,z,args], 0)); +}; +var G__1610 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1611__i = 0, G__1611__a = new Array(arguments.length - 3); +while (G__1611__i < G__1611__a.length) {G__1611__a[G__1611__i] = arguments[G__1611__i + 3]; ++G__1611__i;} + args = new cljs.core.IndexedSeq(G__1611__a,0,null); +} +return G__1610__delegate.call(this,x,y,z,args);}; +G__1610.cljs$lang$maxFixedArity = 3; +G__1610.cljs$lang$applyTo = (function (arglist__1612){ +var x = cljs.core.first(arglist__1612); +arglist__1612 = cljs.core.next(arglist__1612); +var y = cljs.core.first(arglist__1612); +arglist__1612 = cljs.core.next(arglist__1612); +var z = cljs.core.first(arglist__1612); +var args = cljs.core.rest(arglist__1612); +return G__1610__delegate(x,y,z,args); +}); +G__1610.cljs$core$IFn$_invoke$arity$variadic = G__1610__delegate; +return G__1610; +})() +; +G__1609 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__1609__0.call(this); +case 1: +return G__1609__1.call(this,x); +case 2: +return G__1609__2.call(this,x,y); +case 3: +return G__1609__3.call(this,x,y,z); +default: +var G__1613 = null; +if (arguments.length > 3) { +var G__1614__i = 0, G__1614__a = new Array(arguments.length - 3); +while (G__1614__i < G__1614__a.length) {G__1614__a[G__1614__i] = arguments[G__1614__i + 3]; ++G__1614__i;} +G__1613 = new cljs.core.IndexedSeq(G__1614__a,0,null); +} +return G__1609__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1613); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1609.cljs$lang$maxFixedArity = 3; +G__1609.cljs$lang$applyTo = G__1609__4.cljs$lang$applyTo; +G__1609.cljs$core$IFn$_invoke$arity$0 = G__1609__0; +G__1609.cljs$core$IFn$_invoke$arity$1 = G__1609__1; +G__1609.cljs$core$IFn$_invoke$arity$2 = G__1609__2; +G__1609.cljs$core$IFn$_invoke$arity$3 = G__1609__3; +G__1609.cljs$core$IFn$_invoke$arity$variadic = G__1609__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1609; +})() +}); + +cljs.core.partial.cljs$core$IFn$_invoke$arity$variadic = (function (f,arg1,arg2,arg3,more){ +return (function() { +var G__1615__delegate = function (args){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,arg1,arg2,arg3,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(more,args)); +}; +var G__1615 = function (var_args){ +var args = null; +if (arguments.length > 0) { +var G__1616__i = 0, G__1616__a = new Array(arguments.length - 0); +while (G__1616__i < G__1616__a.length) {G__1616__a[G__1616__i] = arguments[G__1616__i + 0]; ++G__1616__i;} + args = new cljs.core.IndexedSeq(G__1616__a,0,null); +} +return G__1615__delegate.call(this,args);}; +G__1615.cljs$lang$maxFixedArity = 0; +G__1615.cljs$lang$applyTo = (function (arglist__1617){ +var args = cljs.core.seq(arglist__1617); +return G__1615__delegate(args); +}); +G__1615.cljs$core$IFn$_invoke$arity$variadic = G__1615__delegate; +return G__1615; +})() +; +}); + +/** @this {Function} */ +cljs.core.partial.cljs$lang$applyTo = (function (seq1587){ +var G__1588 = cljs.core.first(seq1587); +var seq1587__$1 = cljs.core.next(seq1587); +var G__1589 = cljs.core.first(seq1587__$1); +var seq1587__$2 = cljs.core.next(seq1587__$1); +var G__1590 = cljs.core.first(seq1587__$2); +var seq1587__$3 = cljs.core.next(seq1587__$2); +var G__1591 = cljs.core.first(seq1587__$3); +var seq1587__$4 = cljs.core.next(seq1587__$3); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1588,G__1589,G__1590,G__1591,seq1587__$4); +}); + +cljs.core.partial.cljs$lang$maxFixedArity = (4); + +/** + * Takes a function f, and returns a function that calls f, replacing + * a nil first argument to f with the supplied value x. Higher arity + * versions can replace arguments in the second and third + * positions (y, z). Note that the function f can take any number of + * arguments, not just the one(s) being nil-patched. + */ +cljs.core.fnil = (function cljs$core$fnil(var_args){ +var G__1619 = arguments.length; +switch (G__1619) { +case 2: +return cljs.core.fnil.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.fnil.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.fnil.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.fnil.cljs$core$IFn$_invoke$arity$2 = (function (f,x){ +return (function() { +var G__1637 = null; +var G__1637__1 = (function (a){ +var G__1620 = (((a == null))?x:a); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1620) : f.call(null,G__1620)); +}); +var G__1637__2 = (function (a,b){ +var G__1621 = (((a == null))?x:a); +var G__1622 = b; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1621,G__1622) : f.call(null,G__1621,G__1622)); +}); +var G__1637__3 = (function (a,b,c){ +var G__1623 = (((a == null))?x:a); +var G__1624 = b; +var G__1625 = c; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1623,G__1624,G__1625) : f.call(null,G__1623,G__1624,G__1625)); +}); +var G__1637__4 = (function() { +var G__1638__delegate = function (a,b,c,ds){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,(((a == null))?x:a),b,c,ds); +}; +var G__1638 = function (a,b,c,var_args){ +var ds = null; +if (arguments.length > 3) { +var G__1639__i = 0, G__1639__a = new Array(arguments.length - 3); +while (G__1639__i < G__1639__a.length) {G__1639__a[G__1639__i] = arguments[G__1639__i + 3]; ++G__1639__i;} + ds = new cljs.core.IndexedSeq(G__1639__a,0,null); +} +return G__1638__delegate.call(this,a,b,c,ds);}; +G__1638.cljs$lang$maxFixedArity = 3; +G__1638.cljs$lang$applyTo = (function (arglist__1640){ +var a = cljs.core.first(arglist__1640); +arglist__1640 = cljs.core.next(arglist__1640); +var b = cljs.core.first(arglist__1640); +arglist__1640 = cljs.core.next(arglist__1640); +var c = cljs.core.first(arglist__1640); +var ds = cljs.core.rest(arglist__1640); +return G__1638__delegate(a,b,c,ds); +}); +G__1638.cljs$core$IFn$_invoke$arity$variadic = G__1638__delegate; +return G__1638; +})() +; +G__1637 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 1: +return G__1637__1.call(this,a); +case 2: +return G__1637__2.call(this,a,b); +case 3: +return G__1637__3.call(this,a,b,c); +default: +var G__1641 = null; +if (arguments.length > 3) { +var G__1642__i = 0, G__1642__a = new Array(arguments.length - 3); +while (G__1642__i < G__1642__a.length) {G__1642__a[G__1642__i] = arguments[G__1642__i + 3]; ++G__1642__i;} +G__1641 = new cljs.core.IndexedSeq(G__1642__a,0,null); +} +return G__1637__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, G__1641); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1637.cljs$lang$maxFixedArity = 3; +G__1637.cljs$lang$applyTo = G__1637__4.cljs$lang$applyTo; +G__1637.cljs$core$IFn$_invoke$arity$1 = G__1637__1; +G__1637.cljs$core$IFn$_invoke$arity$2 = G__1637__2; +G__1637.cljs$core$IFn$_invoke$arity$3 = G__1637__3; +G__1637.cljs$core$IFn$_invoke$arity$variadic = G__1637__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1637; +})() +}); + +cljs.core.fnil.cljs$core$IFn$_invoke$arity$3 = (function (f,x,y){ +return (function() { +var G__1643 = null; +var G__1643__2 = (function (a,b){ +var G__1626 = (((a == null))?x:a); +var G__1627 = (((b == null))?y:b); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1626,G__1627) : f.call(null,G__1626,G__1627)); +}); +var G__1643__3 = (function (a,b,c){ +var G__1628 = (((a == null))?x:a); +var G__1629 = (((b == null))?y:b); +var G__1630 = c; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1628,G__1629,G__1630) : f.call(null,G__1628,G__1629,G__1630)); +}); +var G__1643__4 = (function() { +var G__1644__delegate = function (a,b,c,ds){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,(((a == null))?x:a),(((b == null))?y:b),c,ds); +}; +var G__1644 = function (a,b,c,var_args){ +var ds = null; +if (arguments.length > 3) { +var G__1645__i = 0, G__1645__a = new Array(arguments.length - 3); +while (G__1645__i < G__1645__a.length) {G__1645__a[G__1645__i] = arguments[G__1645__i + 3]; ++G__1645__i;} + ds = new cljs.core.IndexedSeq(G__1645__a,0,null); +} +return G__1644__delegate.call(this,a,b,c,ds);}; +G__1644.cljs$lang$maxFixedArity = 3; +G__1644.cljs$lang$applyTo = (function (arglist__1646){ +var a = cljs.core.first(arglist__1646); +arglist__1646 = cljs.core.next(arglist__1646); +var b = cljs.core.first(arglist__1646); +arglist__1646 = cljs.core.next(arglist__1646); +var c = cljs.core.first(arglist__1646); +var ds = cljs.core.rest(arglist__1646); +return G__1644__delegate(a,b,c,ds); +}); +G__1644.cljs$core$IFn$_invoke$arity$variadic = G__1644__delegate; +return G__1644; +})() +; +G__1643 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 2: +return G__1643__2.call(this,a,b); +case 3: +return G__1643__3.call(this,a,b,c); +default: +var G__1647 = null; +if (arguments.length > 3) { +var G__1648__i = 0, G__1648__a = new Array(arguments.length - 3); +while (G__1648__i < G__1648__a.length) {G__1648__a[G__1648__i] = arguments[G__1648__i + 3]; ++G__1648__i;} +G__1647 = new cljs.core.IndexedSeq(G__1648__a,0,null); +} +return G__1643__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, G__1647); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1643.cljs$lang$maxFixedArity = 3; +G__1643.cljs$lang$applyTo = G__1643__4.cljs$lang$applyTo; +G__1643.cljs$core$IFn$_invoke$arity$2 = G__1643__2; +G__1643.cljs$core$IFn$_invoke$arity$3 = G__1643__3; +G__1643.cljs$core$IFn$_invoke$arity$variadic = G__1643__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1643; +})() +}); + +cljs.core.fnil.cljs$core$IFn$_invoke$arity$4 = (function (f,x,y,z){ +return (function() { +var G__1649 = null; +var G__1649__2 = (function (a,b){ +var G__1631 = (((a == null))?x:a); +var G__1632 = (((b == null))?y:b); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1631,G__1632) : f.call(null,G__1631,G__1632)); +}); +var G__1649__3 = (function (a,b,c){ +var G__1633 = (((a == null))?x:a); +var G__1634 = (((b == null))?y:b); +var G__1635 = (((c == null))?z:c); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1633,G__1634,G__1635) : f.call(null,G__1633,G__1634,G__1635)); +}); +var G__1649__4 = (function() { +var G__1650__delegate = function (a,b,c,ds){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,(((a == null))?x:a),(((b == null))?y:b),(((c == null))?z:c),ds); +}; +var G__1650 = function (a,b,c,var_args){ +var ds = null; +if (arguments.length > 3) { +var G__1651__i = 0, G__1651__a = new Array(arguments.length - 3); +while (G__1651__i < G__1651__a.length) {G__1651__a[G__1651__i] = arguments[G__1651__i + 3]; ++G__1651__i;} + ds = new cljs.core.IndexedSeq(G__1651__a,0,null); +} +return G__1650__delegate.call(this,a,b,c,ds);}; +G__1650.cljs$lang$maxFixedArity = 3; +G__1650.cljs$lang$applyTo = (function (arglist__1652){ +var a = cljs.core.first(arglist__1652); +arglist__1652 = cljs.core.next(arglist__1652); +var b = cljs.core.first(arglist__1652); +arglist__1652 = cljs.core.next(arglist__1652); +var c = cljs.core.first(arglist__1652); +var ds = cljs.core.rest(arglist__1652); +return G__1650__delegate(a,b,c,ds); +}); +G__1650.cljs$core$IFn$_invoke$arity$variadic = G__1650__delegate; +return G__1650; +})() +; +G__1649 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 2: +return G__1649__2.call(this,a,b); +case 3: +return G__1649__3.call(this,a,b,c); +default: +var G__1653 = null; +if (arguments.length > 3) { +var G__1654__i = 0, G__1654__a = new Array(arguments.length - 3); +while (G__1654__i < G__1654__a.length) {G__1654__a[G__1654__i] = arguments[G__1654__i + 3]; ++G__1654__i;} +G__1653 = new cljs.core.IndexedSeq(G__1654__a,0,null); +} +return G__1649__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, G__1653); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1649.cljs$lang$maxFixedArity = 3; +G__1649.cljs$lang$applyTo = G__1649__4.cljs$lang$applyTo; +G__1649.cljs$core$IFn$_invoke$arity$2 = G__1649__2; +G__1649.cljs$core$IFn$_invoke$arity$3 = G__1649__3; +G__1649.cljs$core$IFn$_invoke$arity$variadic = G__1649__4.cljs$core$IFn$_invoke$arity$variadic; +return G__1649; +})() +}); + +cljs.core.fnil.cljs$lang$maxFixedArity = 4; + +/** + * Returns a lazy sequence consisting of the result of applying f to 0 + * and the first item of coll, followed by applying f to 1 and the second + * item in coll, etc, until coll is exhausted. Thus function f should + * accept 2 arguments, index and item. Returns a stateful transducer when + * no collection is provided. + */ +cljs.core.map_indexed = (function cljs$core$map_indexed(var_args){ +var G__1656 = arguments.length; +switch (G__1656) { +case 1: +return cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (function (rf){ +var i = cljs.core.volatile_BANG_((-1)); +return ((function (i){ +return (function() { +var G__1670 = null; +var G__1670__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1670__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1670__2 = (function (result,input){ +var G__1657 = result; +var G__1658 = (function (){var G__1659 = cljs.core._vreset_BANG_(i,(cljs.core._deref(i) + (1))); +var G__1660 = input; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1659,G__1660) : f.call(null,G__1659,G__1660)); +})(); +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__1657,G__1658) : rf.call(null,G__1657,G__1658)); +}); +G__1670 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1670__0.call(this); +case 1: +return G__1670__1.call(this,result); +case 2: +return G__1670__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1670.cljs$core$IFn$_invoke$arity$0 = G__1670__0; +G__1670.cljs$core$IFn$_invoke$arity$1 = G__1670__1; +G__1670.cljs$core$IFn$_invoke$arity$2 = G__1670__2; +return G__1670; +})() +;})(i)) +}); +}); + +cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +var mapi = (function cljs$core$mapi(idx,coll__$1){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll__$1); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s)){ +var c = cljs.core.chunk_first(s); +var size = cljs.core.count(c); +var b = cljs.core.chunk_buffer(size); +var n__4395__auto___1671 = size; +var i_1672 = (0); +while(true){ +if((i_1672 < n__4395__auto___1671)){ +cljs.core.chunk_append(b,(function (){var G__1665 = (idx + i_1672); +var G__1666 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c,i_1672); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1665,G__1666) : f.call(null,G__1665,G__1666)); +})()); + +var G__1673 = (i_1672 + (1)); +i_1672 = G__1673; +continue; +} else { +} +break; +} + +return cljs.core.chunk_cons(cljs.core.chunk(b),cljs$core$mapi((idx + size),cljs.core.chunk_rest(s))); +} else { +return cljs.core.cons((function (){var G__1667 = idx; +var G__1668 = cljs.core.first(s); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1667,G__1668) : f.call(null,G__1667,G__1668)); +})(),cljs$core$mapi((idx + (1)),cljs.core.rest(s))); +} +} else { +return null; +} +}),null,null)); +}); +return mapi((0),coll); +}); + +cljs.core.map_indexed.cljs$lang$maxFixedArity = 2; + +/** + * Returns a lazy sequence of the non-nil results of (f item). Note, + * this means false return values will be included. f must be free of + * side-effects. Returns a transducer when no collection is provided. + */ +cljs.core.keep = (function cljs$core$keep(var_args){ +var G__1675 = arguments.length; +switch (G__1675) { +case 1: +return cljs.core.keep.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.keep.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.keep.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (function (rf){ +return (function() { +var G__1679 = null; +var G__1679__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1679__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1679__2 = (function (result,input){ +var v = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(input) : f.call(null,input)); +if((v == null)){ +return result; +} else { +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null,result,v)); +} +}); +G__1679 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1679__0.call(this); +case 1: +return G__1679__1.call(this,result); +case 2: +return G__1679__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1679.cljs$core$IFn$_invoke$arity$0 = G__1679__0; +G__1679.cljs$core$IFn$_invoke$arity$1 = G__1679__1; +G__1679.cljs$core$IFn$_invoke$arity$2 = G__1679__2; +return G__1679; +})() +}); +}); + +cljs.core.keep.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s)){ +var c = cljs.core.chunk_first(s); +var size = cljs.core.count(c); +var b = cljs.core.chunk_buffer(size); +var n__4395__auto___1680 = size; +var i_1681 = (0); +while(true){ +if((i_1681 < n__4395__auto___1680)){ +var x_1682 = (function (){var G__1676 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c,i_1681); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1676) : f.call(null,G__1676)); +})(); +if((x_1682 == null)){ +} else { +cljs.core.chunk_append(b,x_1682); +} + +var G__1683 = (i_1681 + (1)); +i_1681 = G__1683; +continue; +} else { +} +break; +} + +return cljs.core.chunk_cons(cljs.core.chunk(b),cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f,cljs.core.chunk_rest(s))); +} else { +var x = (function (){var G__1677 = cljs.core.first(s); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1677) : f.call(null,G__1677)); +})(); +if((x == null)){ +return cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f,cljs.core.rest(s)); +} else { +return cljs.core.cons(x,cljs.core.keep.cljs$core$IFn$_invoke$arity$2(f,cljs.core.rest(s))); +} +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.keep.cljs$lang$maxFixedArity = 2; + + +/** +* @constructor + * @implements {cljs.core.IWatchable} + * @implements {cljs.core.IAtom} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IDeref} +*/ +cljs.core.Atom = (function (state,meta,validator,watches){ +this.state = state; +this.meta = meta; +this.validator = validator; +this.watches = watches; +this.cljs$lang$protocol_mask$partition1$ = 16386; +this.cljs$lang$protocol_mask$partition0$ = 6455296; +}); +cljs.core.Atom.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Atom.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (o,other){ +var self__ = this; +var o__$1 = this; +return (o__$1 === other); +}); + +cljs.core.Atom.prototype.cljs$core$IDeref$_deref$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.state; +}); + +cljs.core.Atom.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.meta; +}); + +cljs.core.Atom.prototype.cljs$core$IWatchable$_notify_watches$arity$3 = (function (this$,oldval,newval){ +var self__ = this; +var this$__$1 = this; +var seq__1684 = cljs.core.seq(self__.watches); +var chunk__1685 = null; +var count__1686 = (0); +var i__1687 = (0); +while(true){ +if((i__1687 < count__1686)){ +var vec__1688 = chunk__1685.cljs$core$IIndexed$_nth$arity$2(null,i__1687); +var key = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1688,(0),null); +var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1688,(1),null); +(f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(key,this$__$1,oldval,newval) : f.call(null,key,this$__$1,oldval,newval)); + + +var G__1694 = seq__1684; +var G__1695 = chunk__1685; +var G__1696 = count__1686; +var G__1697 = (i__1687 + (1)); +seq__1684 = G__1694; +chunk__1685 = G__1695; +count__1686 = G__1696; +i__1687 = G__1697; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__1684); +if(temp__5457__auto__){ +var seq__1684__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__1684__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__1684__$1); +var G__1698 = cljs.core.chunk_rest(seq__1684__$1); +var G__1699 = c__4338__auto__; +var G__1700 = cljs.core.count(c__4338__auto__); +var G__1701 = (0); +seq__1684 = G__1698; +chunk__1685 = G__1699; +count__1686 = G__1700; +i__1687 = G__1701; +continue; +} else { +var vec__1691 = cljs.core.first(seq__1684__$1); +var key = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1691,(0),null); +var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1691,(1),null); +(f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(key,this$__$1,oldval,newval) : f.call(null,key,this$__$1,oldval,newval)); + + +var G__1702 = cljs.core.next(seq__1684__$1); +var G__1703 = null; +var G__1704 = (0); +var G__1705 = (0); +seq__1684 = G__1702; +chunk__1685 = G__1703; +count__1686 = G__1704; +i__1687 = G__1705; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.Atom.prototype.cljs$core$IWatchable$_add_watch$arity$3 = (function (this$,key,f){ +var self__ = this; +var this$__$1 = this; +this$__$1.watches = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.watches,key,f); + +return this$__$1; +}); + +cljs.core.Atom.prototype.cljs$core$IWatchable$_remove_watch$arity$2 = (function (this$,key){ +var self__ = this; +var this$__$1 = this; +return this$__$1.watches = cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.watches,key); +}); + +cljs.core.Atom.prototype.cljs$core$IHash$_hash$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return goog.getUid(this$__$1); +}); + +cljs.core.Atom.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$state,cljs.core.cst$sym$meta,cljs.core.cst$sym$validator,cljs.core.cst$sym$watches], null); +}); + +cljs.core.Atom.cljs$lang$type = true; + +cljs.core.Atom.cljs$lang$ctorStr = "cljs.core/Atom"; + +cljs.core.Atom.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Atom"); +}); + +/** + * Positional factory function for cljs.core/Atom. + */ +cljs.core.__GT_Atom = (function cljs$core$__GT_Atom(state,meta,validator,watches){ +return (new cljs.core.Atom(state,meta,validator,watches)); +}); + +/** + * Creates and returns an Atom with an initial value of x and zero or + * more options (in any order): + * + * :meta metadata-map + * + * :validator validate-fn + * + * If metadata-map is supplied, it will be come the metadata on the + * atom. validate-fn must be nil or a side-effect-free fn of one + * argument, which will be passed the intended new state on any state + * change. If the new state is unacceptable, the validate-fn should + * return false or throw an Error. If either of these error conditions + * occur, then the value of the atom will not change. + */ +cljs.core.atom = (function cljs$core$atom(var_args){ +var G__1709 = arguments.length; +switch (G__1709) { +case 1: +return cljs.core.atom.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1714 = arguments.length; +var i__4519__auto___1715 = (0); +while(true){ +if((i__4519__auto___1715 < len__4518__auto___1714)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1715])); + +var G__1716 = (i__4519__auto___1715 + (1)); +i__4519__auto___1715 = G__1716; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((1)),(0),null)); +return cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4534__auto__); + +} +}); + +cljs.core.atom.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (new cljs.core.Atom(x,null,null,null)); +}); + +cljs.core.atom.cljs$core$IFn$_invoke$arity$variadic = (function (x,p__1710){ +var map__1711 = p__1710; +var map__1711__$1 = ((((!((map__1711 == null)))?(((((map__1711.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === map__1711.cljs$core$ISeq$))))?true:false):false))?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,map__1711):map__1711); +var meta = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__1711__$1,cljs.core.cst$kw$meta); +var validator = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__1711__$1,cljs.core.cst$kw$validator); +return (new cljs.core.Atom(x,meta,validator,null)); +}); + +/** @this {Function} */ +cljs.core.atom.cljs$lang$applyTo = (function (seq1707){ +var G__1708 = cljs.core.first(seq1707); +var seq1707__$1 = cljs.core.next(seq1707); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1708,seq1707__$1); +}); + +cljs.core.atom.cljs$lang$maxFixedArity = (1); + +/** + * Sets the value of atom to newval without regard for the + * current value. Returns new-value. + */ +cljs.core.reset_BANG_ = (function cljs$core$reset_BANG_(a,new_value){ +if((a instanceof cljs.core.Atom)){ +var validate = a.validator; +if((validate == null)){ +} else { +if(cljs.core.truth_((validate.cljs$core$IFn$_invoke$arity$1 ? validate.cljs$core$IFn$_invoke$arity$1(new_value) : validate.call(null,new_value)))){ +} else { +throw (new Error("Validator rejected reference state")); +} +} + +var old_value = a.state; +a.state = new_value; + +if((a.watches == null)){ +} else { +cljs.core._notify_watches(a,old_value,new_value); +} + +return new_value; +} else { +return cljs.core._reset_BANG_(a,new_value); +} +}); +/** + * Sets the value of atom to newval. Returns [old new], the value of the + * atom before and after the reset. + */ +cljs.core.reset_vals_BANG_ = (function cljs$core$reset_vals_BANG_(a,new_value){ +var validate = a.validator; +if((validate == null)){ +} else { +if(cljs.core.truth_((validate.cljs$core$IFn$_invoke$arity$1 ? validate.cljs$core$IFn$_invoke$arity$1(new_value) : validate.call(null,new_value)))){ +} else { +throw (new Error("Validator rejected reference state")); +} +} + +var old_value = a.state; +a.state = new_value; + +if((a.watches == null)){ +} else { +cljs.core._notify_watches(a,old_value,new_value); +} + +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [old_value,new_value], null); +}); +/** + * Atomically swaps the value of atom to be: + * (apply f current-value-of-atom args). Note that f may be called + * multiple times, and thus should be free of side effects. Returns + * the value that was swapped in. + */ +cljs.core.swap_BANG_ = (function cljs$core$swap_BANG_(var_args){ +var G__1723 = arguments.length; +switch (G__1723) { +case 2: +return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1731 = arguments.length; +var i__4519__auto___1732 = (0); +while(true){ +if((i__4519__auto___1732 < len__4518__auto___1731)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1732])); + +var G__1733 = (i__4519__auto___1732 + (1)); +i__4519__auto___1732 = G__1733; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((4)),(0),null)); +return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__4534__auto__); + +} +}); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (a,f){ +if((a instanceof cljs.core.Atom)){ +return cljs.core.reset_BANG_(a,(function (){var G__1724 = a.state; +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1724) : f.call(null,G__1724)); +})()); +} else { +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$2(a,f); +} +}); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3 = (function (a,f,x){ +if((a instanceof cljs.core.Atom)){ +return cljs.core.reset_BANG_(a,(function (){var G__1725 = a.state; +var G__1726 = x; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1725,G__1726) : f.call(null,G__1725,G__1726)); +})()); +} else { +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$3(a,f,x); +} +}); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4 = (function (a,f,x,y){ +if((a instanceof cljs.core.Atom)){ +return cljs.core.reset_BANG_(a,(function (){var G__1727 = a.state; +var G__1728 = x; +var G__1729 = y; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1727,G__1728,G__1729) : f.call(null,G__1727,G__1728,G__1729)); +})()); +} else { +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$4(a,f,x,y); +} +}); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (a,f,x,y,more){ +if((a instanceof cljs.core.Atom)){ +return cljs.core.reset_BANG_(a,cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,a.state,x,y,more)); +} else { +return cljs.core._swap_BANG_.cljs$core$IFn$_invoke$arity$5(a,f,x,y,more); +} +}); + +/** @this {Function} */ +cljs.core.swap_BANG_.cljs$lang$applyTo = (function (seq1718){ +var G__1719 = cljs.core.first(seq1718); +var seq1718__$1 = cljs.core.next(seq1718); +var G__1720 = cljs.core.first(seq1718__$1); +var seq1718__$2 = cljs.core.next(seq1718__$1); +var G__1721 = cljs.core.first(seq1718__$2); +var seq1718__$3 = cljs.core.next(seq1718__$2); +var G__1722 = cljs.core.first(seq1718__$3); +var seq1718__$4 = cljs.core.next(seq1718__$3); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1719,G__1720,G__1721,G__1722,seq1718__$4); +}); + +cljs.core.swap_BANG_.cljs$lang$maxFixedArity = (4); + +/** + * Atomically swaps the value of atom to be: + * (apply f current-value-of-atom args). Note that f may be called + * multiple times, and thus should be free of side effects. + * Returns [old new], the value of the atom before and after the swap. + */ +cljs.core.swap_vals_BANG_ = (function cljs$core$swap_vals_BANG_(var_args){ +var G__1740 = arguments.length; +switch (G__1740) { +case 2: +return cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1748 = arguments.length; +var i__4519__auto___1749 = (0); +while(true){ +if((i__4519__auto___1749 < len__4518__auto___1748)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1749])); + +var G__1750 = (i__4519__auto___1749 + (1)); +i__4519__auto___1749 = G__1750; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((4)),(0),null)); +return cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__4534__auto__); + +} +}); + +cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (a,f){ +return cljs.core.reset_vals_BANG_(a,(function (){var G__1741 = a.state; +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1741) : f.call(null,G__1741)); +})()); +}); + +cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$3 = (function (a,f,x){ +return cljs.core.reset_vals_BANG_(a,(function (){var G__1742 = a.state; +var G__1743 = x; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1742,G__1743) : f.call(null,G__1742,G__1743)); +})()); +}); + +cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$4 = (function (a,f,x,y){ +return cljs.core.reset_vals_BANG_(a,(function (){var G__1744 = a.state; +var G__1745 = x; +var G__1746 = y; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1744,G__1745,G__1746) : f.call(null,G__1744,G__1745,G__1746)); +})()); +}); + +cljs.core.swap_vals_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (a,f,x,y,more){ +return cljs.core.reset_vals_BANG_(a,cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,a.state,x,y,more)); +}); + +/** @this {Function} */ +cljs.core.swap_vals_BANG_.cljs$lang$applyTo = (function (seq1735){ +var G__1736 = cljs.core.first(seq1735); +var seq1735__$1 = cljs.core.next(seq1735); +var G__1737 = cljs.core.first(seq1735__$1); +var seq1735__$2 = cljs.core.next(seq1735__$1); +var G__1738 = cljs.core.first(seq1735__$2); +var seq1735__$3 = cljs.core.next(seq1735__$2); +var G__1739 = cljs.core.first(seq1735__$3); +var seq1735__$4 = cljs.core.next(seq1735__$3); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1736,G__1737,G__1738,G__1739,seq1735__$4); +}); + +cljs.core.swap_vals_BANG_.cljs$lang$maxFixedArity = (4); + +/** + * Atomically sets the value of atom to newval if and only if the + * current value of the atom is equal to oldval. Returns true if + * set happened, else false. + */ +cljs.core.compare_and_set_BANG_ = (function cljs$core$compare_and_set_BANG_(a,oldval,newval){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a.cljs$core$IDeref$_deref$arity$1(null),oldval)){ +cljs.core.reset_BANG_(a,newval); + +return true; +} else { +return false; +} +}); +/** + * Sets the validator-fn for an atom. validator-fn must be nil or a + * side-effect-free fn of one argument, which will be passed the intended + * new state on any state change. If the new state is unacceptable, the + * validator-fn should return false or throw an Error. If the current state + * is not acceptable to the new validator, an Error will be thrown and the + * validator will not be changed. + */ +cljs.core.set_validator_BANG_ = (function cljs$core$set_validator_BANG_(iref,val){ +if(((!((val == null))) && (cljs.core.not((function (){var G__1752 = cljs.core._deref(iref); +return (val.cljs$core$IFn$_invoke$arity$1 ? val.cljs$core$IFn$_invoke$arity$1(G__1752) : val.call(null,G__1752)); +})())))){ +throw (new Error("Validator rejected reference state")); +} else { +} + +return iref.validator = val; +}); +/** + * Gets the validator-fn for a var/ref/agent/atom. + */ +cljs.core.get_validator = (function cljs$core$get_validator(iref){ +return iref.validator; +}); + +/** +* @constructor + * @implements {cljs.core.IVolatile} + * @implements {cljs.core.IDeref} +*/ +cljs.core.Volatile = (function (state){ +this.state = state; +this.cljs$lang$protocol_mask$partition0$ = 32768; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.Volatile.prototype.cljs$core$IVolatile$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Volatile.prototype.cljs$core$IVolatile$_vreset_BANG_$arity$2 = (function (_,new_state){ +var self__ = this; +var ___$1 = this; +return self__.state = new_state; +}); + +cljs.core.Volatile.prototype.cljs$core$IDeref$_deref$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return self__.state; +}); + +cljs.core.Volatile.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$state,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Volatile.cljs$lang$type = true; + +cljs.core.Volatile.cljs$lang$ctorStr = "cljs.core/Volatile"; + +cljs.core.Volatile.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Volatile"); +}); + +/** + * Positional factory function for cljs.core/Volatile. + */ +cljs.core.__GT_Volatile = (function cljs$core$__GT_Volatile(state){ +return (new cljs.core.Volatile(state)); +}); + +/** + * Creates and returns a Volatile with an initial value of val. + */ +cljs.core.volatile_BANG_ = (function cljs$core$volatile_BANG_(val){ +return (new cljs.core.Volatile(val)); +}); +/** + * Returns true if x is a volatile. + */ +cljs.core.volatile_QMARK_ = (function cljs$core$volatile_QMARK_(x){ +return (x instanceof cljs.core.Volatile); +}); +/** + * Sets the value of volatile to newval without regard for the + * current value. Returns newval. + */ +cljs.core.vreset_BANG_ = (function cljs$core$vreset_BANG_(vol,newval){ +return cljs.core._vreset_BANG_(vol,newval); +}); +/** + * Returns a lazy sequence of the non-nil results of (f index item). Note, + * this means false return values will be included. f must be free of + * side-effects. Returns a stateful transducer when no collection is + * provided. + */ +cljs.core.keep_indexed = (function cljs$core$keep_indexed(var_args){ +var G__1754 = arguments.length; +switch (G__1754) { +case 1: +return cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (function (rf){ +var ia = cljs.core.volatile_BANG_((-1)); +return ((function (ia){ +return (function() { +var G__1764 = null; +var G__1764__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1764__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1764__2 = (function (result,input){ +var i = cljs.core._vreset_BANG_(ia,(cljs.core._deref(ia) + (1))); +var v = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(i,input) : f.call(null,i,input)); +if((v == null)){ +return result; +} else { +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null,result,v)); +} +}); +G__1764 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1764__0.call(this); +case 1: +return G__1764__1.call(this,result); +case 2: +return G__1764__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1764.cljs$core$IFn$_invoke$arity$0 = G__1764__0; +G__1764.cljs$core$IFn$_invoke$arity$1 = G__1764__1; +G__1764.cljs$core$IFn$_invoke$arity$2 = G__1764__2; +return G__1764; +})() +;})(ia)) +}); +}); + +cljs.core.keep_indexed.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +var keepi = (function cljs$core$keepi(idx,coll__$1){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll__$1); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s)){ +var c = cljs.core.chunk_first(s); +var size = cljs.core.count(c); +var b = cljs.core.chunk_buffer(size); +var n__4395__auto___1765 = size; +var i_1766 = (0); +while(true){ +if((i_1766 < n__4395__auto___1765)){ +var x_1767 = (function (){var G__1759 = (idx + i_1766); +var G__1760 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c,i_1766); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1759,G__1760) : f.call(null,G__1759,G__1760)); +})(); +if((x_1767 == null)){ +} else { +cljs.core.chunk_append(b,x_1767); +} + +var G__1768 = (i_1766 + (1)); +i_1766 = G__1768; +continue; +} else { +} +break; +} + +return cljs.core.chunk_cons(cljs.core.chunk(b),cljs$core$keepi((idx + size),cljs.core.chunk_rest(s))); +} else { +var x = (function (){var G__1761 = idx; +var G__1762 = cljs.core.first(s); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1761,G__1762) : f.call(null,G__1761,G__1762)); +})(); +if((x == null)){ +return cljs$core$keepi((idx + (1)),cljs.core.rest(s)); +} else { +return cljs.core.cons(x,cljs$core$keepi((idx + (1)),cljs.core.rest(s))); +} +} +} else { +return null; +} +}),null,null)); +}); +return keepi((0),coll); +}); + +cljs.core.keep_indexed.cljs$lang$maxFixedArity = 2; + +/** + * Takes a set of predicates and returns a function f that returns true if all of its + * composing predicates return a logical true value against all of its arguments, else it returns + * false. Note that f is short-circuiting in that it will stop execution on the first + * argument that triggers a logical false result against the original predicates. + */ +cljs.core.every_pred = (function cljs$core$every_pred(var_args){ +var G__1780 = arguments.length; +switch (G__1780) { +case 1: +return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1782 = arguments.length; +var i__4519__auto___1783 = (0); +while(true){ +if((i__4519__auto___1783 < len__4518__auto___1782)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1783])); + +var G__1784 = (i__4519__auto___1783 + (1)); +i__4519__auto___1783 = G__1784; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.every_pred.cljs$core$IFn$_invoke$arity$1 = (function (p){ +return (function() { +var cljs$core$ep1 = null; +var cljs$core$ep1__0 = (function (){ +return true; +}); +var cljs$core$ep1__1 = (function (x){ +return cljs.core.boolean$((p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null,x))); +}); +var cljs$core$ep1__2 = (function (x,y){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +return (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null,y)); +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep1__3 = (function (x,y,z){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$1)){ +return (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(z) : p.call(null,z)); +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep1__4 = (function() { +var G__1785__delegate = function (x,y,z,args){ +return cljs.core.boolean$((function (){var and__3925__auto__ = cljs$core$ep1.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.every_QMARK_(p,args); +} else { +return and__3925__auto__; +} +})()); +}; +var G__1785 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1786__i = 0, G__1786__a = new Array(arguments.length - 3); +while (G__1786__i < G__1786__a.length) {G__1786__a[G__1786__i] = arguments[G__1786__i + 3]; ++G__1786__i;} + args = new cljs.core.IndexedSeq(G__1786__a,0,null); +} +return G__1785__delegate.call(this,x,y,z,args);}; +G__1785.cljs$lang$maxFixedArity = 3; +G__1785.cljs$lang$applyTo = (function (arglist__1787){ +var x = cljs.core.first(arglist__1787); +arglist__1787 = cljs.core.next(arglist__1787); +var y = cljs.core.first(arglist__1787); +arglist__1787 = cljs.core.next(arglist__1787); +var z = cljs.core.first(arglist__1787); +var args = cljs.core.rest(arglist__1787); +return G__1785__delegate(x,y,z,args); +}); +G__1785.cljs$core$IFn$_invoke$arity$variadic = G__1785__delegate; +return G__1785; +})() +; +cljs$core$ep1 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$ep1__0.call(this); +case 1: +return cljs$core$ep1__1.call(this,x); +case 2: +return cljs$core$ep1__2.call(this,x,y); +case 3: +return cljs$core$ep1__3.call(this,x,y,z); +default: +var G__1788 = null; +if (arguments.length > 3) { +var G__1789__i = 0, G__1789__a = new Array(arguments.length - 3); +while (G__1789__i < G__1789__a.length) {G__1789__a[G__1789__i] = arguments[G__1789__i + 3]; ++G__1789__i;} +G__1788 = new cljs.core.IndexedSeq(G__1789__a,0,null); +} +return cljs$core$ep1__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1788); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$ep1.cljs$lang$maxFixedArity = 3; +cljs$core$ep1.cljs$lang$applyTo = cljs$core$ep1__4.cljs$lang$applyTo; +cljs$core$ep1.cljs$core$IFn$_invoke$arity$0 = cljs$core$ep1__0; +cljs$core$ep1.cljs$core$IFn$_invoke$arity$1 = cljs$core$ep1__1; +cljs$core$ep1.cljs$core$IFn$_invoke$arity$2 = cljs$core$ep1__2; +cljs$core$ep1.cljs$core$IFn$_invoke$arity$3 = cljs$core$ep1__3; +cljs$core$ep1.cljs$core$IFn$_invoke$arity$variadic = cljs$core$ep1__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$ep1; +})() +}); + +cljs.core.every_pred.cljs$core$IFn$_invoke$arity$2 = (function (p1,p2){ +return (function() { +var cljs$core$ep2 = null; +var cljs$core$ep2__0 = (function (){ +return true; +}); +var cljs$core$ep2__1 = (function (x){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep2__2 = (function (x,y){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$1)){ +var and__3925__auto____$2 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$2)){ +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +} else { +return and__3925__auto____$2; +} +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep2__3 = (function (x,y,z){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$1)){ +var and__3925__auto____$2 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null,z)); +if(cljs.core.truth_(and__3925__auto____$2)){ +var and__3925__auto____$3 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$3)){ +var and__3925__auto____$4 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$4)){ +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null,z)); +} else { +return and__3925__auto____$4; +} +} else { +return and__3925__auto____$3; +} +} else { +return and__3925__auto____$2; +} +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep2__4 = (function() { +var G__1790__delegate = function (x,y,z,args){ +return cljs.core.boolean$((function (){var and__3925__auto__ = cljs$core$ep2.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.every_QMARK_(((function (and__3925__auto__){ +return (function (p1__1769_SHARP_){ +var and__3925__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__1769_SHARP_) : p1.call(null,p1__1769_SHARP_)); +if(cljs.core.truth_(and__3925__auto____$1)){ +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__1769_SHARP_) : p2.call(null,p1__1769_SHARP_)); +} else { +return and__3925__auto____$1; +} +});})(and__3925__auto__)) +,args); +} else { +return and__3925__auto__; +} +})()); +}; +var G__1790 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1791__i = 0, G__1791__a = new Array(arguments.length - 3); +while (G__1791__i < G__1791__a.length) {G__1791__a[G__1791__i] = arguments[G__1791__i + 3]; ++G__1791__i;} + args = new cljs.core.IndexedSeq(G__1791__a,0,null); +} +return G__1790__delegate.call(this,x,y,z,args);}; +G__1790.cljs$lang$maxFixedArity = 3; +G__1790.cljs$lang$applyTo = (function (arglist__1792){ +var x = cljs.core.first(arglist__1792); +arglist__1792 = cljs.core.next(arglist__1792); +var y = cljs.core.first(arglist__1792); +arglist__1792 = cljs.core.next(arglist__1792); +var z = cljs.core.first(arglist__1792); +var args = cljs.core.rest(arglist__1792); +return G__1790__delegate(x,y,z,args); +}); +G__1790.cljs$core$IFn$_invoke$arity$variadic = G__1790__delegate; +return G__1790; +})() +; +cljs$core$ep2 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$ep2__0.call(this); +case 1: +return cljs$core$ep2__1.call(this,x); +case 2: +return cljs$core$ep2__2.call(this,x,y); +case 3: +return cljs$core$ep2__3.call(this,x,y,z); +default: +var G__1793 = null; +if (arguments.length > 3) { +var G__1794__i = 0, G__1794__a = new Array(arguments.length - 3); +while (G__1794__i < G__1794__a.length) {G__1794__a[G__1794__i] = arguments[G__1794__i + 3]; ++G__1794__i;} +G__1793 = new cljs.core.IndexedSeq(G__1794__a,0,null); +} +return cljs$core$ep2__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1793); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$ep2.cljs$lang$maxFixedArity = 3; +cljs$core$ep2.cljs$lang$applyTo = cljs$core$ep2__4.cljs$lang$applyTo; +cljs$core$ep2.cljs$core$IFn$_invoke$arity$0 = cljs$core$ep2__0; +cljs$core$ep2.cljs$core$IFn$_invoke$arity$1 = cljs$core$ep2__1; +cljs$core$ep2.cljs$core$IFn$_invoke$arity$2 = cljs$core$ep2__2; +cljs$core$ep2.cljs$core$IFn$_invoke$arity$3 = cljs$core$ep2__3; +cljs$core$ep2.cljs$core$IFn$_invoke$arity$variadic = cljs$core$ep2__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$ep2; +})() +}); + +cljs.core.every_pred.cljs$core$IFn$_invoke$arity$3 = (function (p1,p2,p3){ +return (function() { +var cljs$core$ep3 = null; +var cljs$core$ep3__0 = (function (){ +return true; +}); +var cljs$core$ep3__1 = (function (x){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$1)){ +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null,x)); +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep3__2 = (function (x,y){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$1)){ +var and__3925__auto____$2 = (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$2)){ +var and__3925__auto____$3 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$3)){ +var and__3925__auto____$4 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$4)){ +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null,y)); +} else { +return and__3925__auto____$4; +} +} else { +return and__3925__auto____$3; +} +} else { +return and__3925__auto____$2; +} +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep3__3 = (function (x,y,z){ +return cljs.core.boolean$((function (){var and__3925__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$1)){ +var and__3925__auto____$2 = (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null,x)); +if(cljs.core.truth_(and__3925__auto____$2)){ +var and__3925__auto____$3 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$3)){ +var and__3925__auto____$4 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$4)){ +var and__3925__auto____$5 = (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$5)){ +var and__3925__auto____$6 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null,z)); +if(cljs.core.truth_(and__3925__auto____$6)){ +var and__3925__auto____$7 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null,z)); +if(cljs.core.truth_(and__3925__auto____$7)){ +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(z) : p3.call(null,z)); +} else { +return and__3925__auto____$7; +} +} else { +return and__3925__auto____$6; +} +} else { +return and__3925__auto____$5; +} +} else { +return and__3925__auto____$4; +} +} else { +return and__3925__auto____$3; +} +} else { +return and__3925__auto____$2; +} +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +})()); +}); +var cljs$core$ep3__4 = (function() { +var G__1795__delegate = function (x,y,z,args){ +return cljs.core.boolean$((function (){var and__3925__auto__ = cljs$core$ep3.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.every_QMARK_(((function (and__3925__auto__){ +return (function (p1__1770_SHARP_){ +var and__3925__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__1770_SHARP_) : p1.call(null,p1__1770_SHARP_)); +if(cljs.core.truth_(and__3925__auto____$1)){ +var and__3925__auto____$2 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__1770_SHARP_) : p2.call(null,p1__1770_SHARP_)); +if(cljs.core.truth_(and__3925__auto____$2)){ +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(p1__1770_SHARP_) : p3.call(null,p1__1770_SHARP_)); +} else { +return and__3925__auto____$2; +} +} else { +return and__3925__auto____$1; +} +});})(and__3925__auto__)) +,args); +} else { +return and__3925__auto__; +} +})()); +}; +var G__1795 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1796__i = 0, G__1796__a = new Array(arguments.length - 3); +while (G__1796__i < G__1796__a.length) {G__1796__a[G__1796__i] = arguments[G__1796__i + 3]; ++G__1796__i;} + args = new cljs.core.IndexedSeq(G__1796__a,0,null); +} +return G__1795__delegate.call(this,x,y,z,args);}; +G__1795.cljs$lang$maxFixedArity = 3; +G__1795.cljs$lang$applyTo = (function (arglist__1797){ +var x = cljs.core.first(arglist__1797); +arglist__1797 = cljs.core.next(arglist__1797); +var y = cljs.core.first(arglist__1797); +arglist__1797 = cljs.core.next(arglist__1797); +var z = cljs.core.first(arglist__1797); +var args = cljs.core.rest(arglist__1797); +return G__1795__delegate(x,y,z,args); +}); +G__1795.cljs$core$IFn$_invoke$arity$variadic = G__1795__delegate; +return G__1795; +})() +; +cljs$core$ep3 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$ep3__0.call(this); +case 1: +return cljs$core$ep3__1.call(this,x); +case 2: +return cljs$core$ep3__2.call(this,x,y); +case 3: +return cljs$core$ep3__3.call(this,x,y,z); +default: +var G__1798 = null; +if (arguments.length > 3) { +var G__1799__i = 0, G__1799__a = new Array(arguments.length - 3); +while (G__1799__i < G__1799__a.length) {G__1799__a[G__1799__i] = arguments[G__1799__i + 3]; ++G__1799__i;} +G__1798 = new cljs.core.IndexedSeq(G__1799__a,0,null); +} +return cljs$core$ep3__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1798); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$ep3.cljs$lang$maxFixedArity = 3; +cljs$core$ep3.cljs$lang$applyTo = cljs$core$ep3__4.cljs$lang$applyTo; +cljs$core$ep3.cljs$core$IFn$_invoke$arity$0 = cljs$core$ep3__0; +cljs$core$ep3.cljs$core$IFn$_invoke$arity$1 = cljs$core$ep3__1; +cljs$core$ep3.cljs$core$IFn$_invoke$arity$2 = cljs$core$ep3__2; +cljs$core$ep3.cljs$core$IFn$_invoke$arity$3 = cljs$core$ep3__3; +cljs$core$ep3.cljs$core$IFn$_invoke$arity$variadic = cljs$core$ep3__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$ep3; +})() +}); + +cljs.core.every_pred.cljs$core$IFn$_invoke$arity$variadic = (function (p1,p2,p3,ps){ +var ps__$1 = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(p1,p2,p3,ps); +return ((function (ps__$1){ +return (function() { +var cljs$core$epn = null; +var cljs$core$epn__0 = (function (){ +return true; +}); +var cljs$core$epn__1 = (function (x){ +return cljs.core.every_QMARK_(((function (ps__$1){ +return (function (p1__1771_SHARP_){ +return (p1__1771_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1771_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__1771_SHARP_.call(null,x)); +});})(ps__$1)) +,ps__$1); +}); +var cljs$core$epn__2 = (function (x,y){ +return cljs.core.every_QMARK_(((function (ps__$1){ +return (function (p1__1772_SHARP_){ +var and__3925__auto__ = (p1__1772_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1772_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__1772_SHARP_.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +return (p1__1772_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1772_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__1772_SHARP_.call(null,y)); +} else { +return and__3925__auto__; +} +});})(ps__$1)) +,ps__$1); +}); +var cljs$core$epn__3 = (function (x,y,z){ +return cljs.core.every_QMARK_(((function (ps__$1){ +return (function (p1__1773_SHARP_){ +var and__3925__auto__ = (p1__1773_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1773_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__1773_SHARP_.call(null,x)); +if(cljs.core.truth_(and__3925__auto__)){ +var and__3925__auto____$1 = (p1__1773_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1773_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__1773_SHARP_.call(null,y)); +if(cljs.core.truth_(and__3925__auto____$1)){ +return (p1__1773_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1773_SHARP_.cljs$core$IFn$_invoke$arity$1(z) : p1__1773_SHARP_.call(null,z)); +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +});})(ps__$1)) +,ps__$1); +}); +var cljs$core$epn__4 = (function() { +var G__1800__delegate = function (x,y,z,args){ +return cljs.core.boolean$((function (){var and__3925__auto__ = cljs$core$epn.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.every_QMARK_(((function (and__3925__auto__,ps__$1){ +return (function (p1__1774_SHARP_){ +return cljs.core.every_QMARK_(p1__1774_SHARP_,args); +});})(and__3925__auto__,ps__$1)) +,ps__$1); +} else { +return and__3925__auto__; +} +})()); +}; +var G__1800 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1801__i = 0, G__1801__a = new Array(arguments.length - 3); +while (G__1801__i < G__1801__a.length) {G__1801__a[G__1801__i] = arguments[G__1801__i + 3]; ++G__1801__i;} + args = new cljs.core.IndexedSeq(G__1801__a,0,null); +} +return G__1800__delegate.call(this,x,y,z,args);}; +G__1800.cljs$lang$maxFixedArity = 3; +G__1800.cljs$lang$applyTo = (function (arglist__1802){ +var x = cljs.core.first(arglist__1802); +arglist__1802 = cljs.core.next(arglist__1802); +var y = cljs.core.first(arglist__1802); +arglist__1802 = cljs.core.next(arglist__1802); +var z = cljs.core.first(arglist__1802); +var args = cljs.core.rest(arglist__1802); +return G__1800__delegate(x,y,z,args); +}); +G__1800.cljs$core$IFn$_invoke$arity$variadic = G__1800__delegate; +return G__1800; +})() +; +cljs$core$epn = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$epn__0.call(this); +case 1: +return cljs$core$epn__1.call(this,x); +case 2: +return cljs$core$epn__2.call(this,x,y); +case 3: +return cljs$core$epn__3.call(this,x,y,z); +default: +var G__1803 = null; +if (arguments.length > 3) { +var G__1804__i = 0, G__1804__a = new Array(arguments.length - 3); +while (G__1804__i < G__1804__a.length) {G__1804__a[G__1804__i] = arguments[G__1804__i + 3]; ++G__1804__i;} +G__1803 = new cljs.core.IndexedSeq(G__1804__a,0,null); +} +return cljs$core$epn__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1803); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$epn.cljs$lang$maxFixedArity = 3; +cljs$core$epn.cljs$lang$applyTo = cljs$core$epn__4.cljs$lang$applyTo; +cljs$core$epn.cljs$core$IFn$_invoke$arity$0 = cljs$core$epn__0; +cljs$core$epn.cljs$core$IFn$_invoke$arity$1 = cljs$core$epn__1; +cljs$core$epn.cljs$core$IFn$_invoke$arity$2 = cljs$core$epn__2; +cljs$core$epn.cljs$core$IFn$_invoke$arity$3 = cljs$core$epn__3; +cljs$core$epn.cljs$core$IFn$_invoke$arity$variadic = cljs$core$epn__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$epn; +})() +;})(ps__$1)) +}); + +/** @this {Function} */ +cljs.core.every_pred.cljs$lang$applyTo = (function (seq1776){ +var G__1777 = cljs.core.first(seq1776); +var seq1776__$1 = cljs.core.next(seq1776); +var G__1778 = cljs.core.first(seq1776__$1); +var seq1776__$2 = cljs.core.next(seq1776__$1); +var G__1779 = cljs.core.first(seq1776__$2); +var seq1776__$3 = cljs.core.next(seq1776__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1777,G__1778,G__1779,seq1776__$3); +}); + +cljs.core.every_pred.cljs$lang$maxFixedArity = (3); + +/** + * Takes a set of predicates and returns a function f that returns the first logical true value + * returned by one of its composing predicates against any of its arguments, else it returns + * logical false. Note that f is short-circuiting in that it will stop execution on the first + * argument that triggers a logical true result against the original predicates. + */ +cljs.core.some_fn = (function cljs$core$some_fn(var_args){ +var G__1816 = arguments.length; +switch (G__1816) { +case 1: +return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1818 = arguments.length; +var i__4519__auto___1819 = (0); +while(true){ +if((i__4519__auto___1819 < len__4518__auto___1818)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1819])); + +var G__1820 = (i__4519__auto___1819 + (1)); +i__4519__auto___1819 = G__1820; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.some_fn.cljs$core$IFn$_invoke$arity$1 = (function (p){ +return (function() { +var cljs$core$sp1 = null; +var cljs$core$sp1__0 = (function (){ +return null; +}); +var cljs$core$sp1__1 = (function (x){ +return (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null,x)); +}); +var cljs$core$sp1__2 = (function (x,y){ +var or__3936__auto__ = (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null,y)); +} +}); +var cljs$core$sp1__3 = (function (x,y,z){ +var or__3936__auto__ = (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(x) : p.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(y) : p.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +return (p.cljs$core$IFn$_invoke$arity$1 ? p.cljs$core$IFn$_invoke$arity$1(z) : p.call(null,z)); +} +} +}); +var cljs$core$sp1__4 = (function() { +var G__1821__delegate = function (x,y,z,args){ +var or__3936__auto__ = cljs$core$sp1.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.some(p,args); +} +}; +var G__1821 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1822__i = 0, G__1822__a = new Array(arguments.length - 3); +while (G__1822__i < G__1822__a.length) {G__1822__a[G__1822__i] = arguments[G__1822__i + 3]; ++G__1822__i;} + args = new cljs.core.IndexedSeq(G__1822__a,0,null); +} +return G__1821__delegate.call(this,x,y,z,args);}; +G__1821.cljs$lang$maxFixedArity = 3; +G__1821.cljs$lang$applyTo = (function (arglist__1823){ +var x = cljs.core.first(arglist__1823); +arglist__1823 = cljs.core.next(arglist__1823); +var y = cljs.core.first(arglist__1823); +arglist__1823 = cljs.core.next(arglist__1823); +var z = cljs.core.first(arglist__1823); +var args = cljs.core.rest(arglist__1823); +return G__1821__delegate(x,y,z,args); +}); +G__1821.cljs$core$IFn$_invoke$arity$variadic = G__1821__delegate; +return G__1821; +})() +; +cljs$core$sp1 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$sp1__0.call(this); +case 1: +return cljs$core$sp1__1.call(this,x); +case 2: +return cljs$core$sp1__2.call(this,x,y); +case 3: +return cljs$core$sp1__3.call(this,x,y,z); +default: +var G__1824 = null; +if (arguments.length > 3) { +var G__1825__i = 0, G__1825__a = new Array(arguments.length - 3); +while (G__1825__i < G__1825__a.length) {G__1825__a[G__1825__i] = arguments[G__1825__i + 3]; ++G__1825__i;} +G__1824 = new cljs.core.IndexedSeq(G__1825__a,0,null); +} +return cljs$core$sp1__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1824); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$sp1.cljs$lang$maxFixedArity = 3; +cljs$core$sp1.cljs$lang$applyTo = cljs$core$sp1__4.cljs$lang$applyTo; +cljs$core$sp1.cljs$core$IFn$_invoke$arity$0 = cljs$core$sp1__0; +cljs$core$sp1.cljs$core$IFn$_invoke$arity$1 = cljs$core$sp1__1; +cljs$core$sp1.cljs$core$IFn$_invoke$arity$2 = cljs$core$sp1__2; +cljs$core$sp1.cljs$core$IFn$_invoke$arity$3 = cljs$core$sp1__3; +cljs$core$sp1.cljs$core$IFn$_invoke$arity$variadic = cljs$core$sp1__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$sp1; +})() +}); + +cljs.core.some_fn.cljs$core$IFn$_invoke$arity$2 = (function (p1,p2){ +return (function() { +var cljs$core$sp2 = null; +var cljs$core$sp2__0 = (function (){ +return null; +}); +var cljs$core$sp2__1 = (function (x){ +var or__3936__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +} +}); +var cljs$core$sp2__2 = (function (x,y){ +var or__3936__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$2)){ +return or__3936__auto____$2; +} else { +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +} +} +} +}); +var cljs$core$sp2__3 = (function (x,y,z){ +var or__3936__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null,z)); +if(cljs.core.truth_(or__3936__auto____$2)){ +return or__3936__auto____$2; +} else { +var or__3936__auto____$3 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$3)){ +return or__3936__auto____$3; +} else { +var or__3936__auto____$4 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$4)){ +return or__3936__auto____$4; +} else { +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null,z)); +} +} +} +} +} +}); +var cljs$core$sp2__4 = (function() { +var G__1826__delegate = function (x,y,z,args){ +var or__3936__auto__ = cljs$core$sp2.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.some(((function (or__3936__auto__){ +return (function (p1__1805_SHARP_){ +var or__3936__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__1805_SHARP_) : p1.call(null,p1__1805_SHARP_)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +return (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__1805_SHARP_) : p2.call(null,p1__1805_SHARP_)); +} +});})(or__3936__auto__)) +,args); +} +}; +var G__1826 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1827__i = 0, G__1827__a = new Array(arguments.length - 3); +while (G__1827__i < G__1827__a.length) {G__1827__a[G__1827__i] = arguments[G__1827__i + 3]; ++G__1827__i;} + args = new cljs.core.IndexedSeq(G__1827__a,0,null); +} +return G__1826__delegate.call(this,x,y,z,args);}; +G__1826.cljs$lang$maxFixedArity = 3; +G__1826.cljs$lang$applyTo = (function (arglist__1828){ +var x = cljs.core.first(arglist__1828); +arglist__1828 = cljs.core.next(arglist__1828); +var y = cljs.core.first(arglist__1828); +arglist__1828 = cljs.core.next(arglist__1828); +var z = cljs.core.first(arglist__1828); +var args = cljs.core.rest(arglist__1828); +return G__1826__delegate(x,y,z,args); +}); +G__1826.cljs$core$IFn$_invoke$arity$variadic = G__1826__delegate; +return G__1826; +})() +; +cljs$core$sp2 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$sp2__0.call(this); +case 1: +return cljs$core$sp2__1.call(this,x); +case 2: +return cljs$core$sp2__2.call(this,x,y); +case 3: +return cljs$core$sp2__3.call(this,x,y,z); +default: +var G__1829 = null; +if (arguments.length > 3) { +var G__1830__i = 0, G__1830__a = new Array(arguments.length - 3); +while (G__1830__i < G__1830__a.length) {G__1830__a[G__1830__i] = arguments[G__1830__i + 3]; ++G__1830__i;} +G__1829 = new cljs.core.IndexedSeq(G__1830__a,0,null); +} +return cljs$core$sp2__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1829); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$sp2.cljs$lang$maxFixedArity = 3; +cljs$core$sp2.cljs$lang$applyTo = cljs$core$sp2__4.cljs$lang$applyTo; +cljs$core$sp2.cljs$core$IFn$_invoke$arity$0 = cljs$core$sp2__0; +cljs$core$sp2.cljs$core$IFn$_invoke$arity$1 = cljs$core$sp2__1; +cljs$core$sp2.cljs$core$IFn$_invoke$arity$2 = cljs$core$sp2__2; +cljs$core$sp2.cljs$core$IFn$_invoke$arity$3 = cljs$core$sp2__3; +cljs$core$sp2.cljs$core$IFn$_invoke$arity$variadic = cljs$core$sp2__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$sp2; +})() +}); + +cljs.core.some_fn.cljs$core$IFn$_invoke$arity$3 = (function (p1,p2,p3){ +return (function() { +var cljs$core$sp3 = null; +var cljs$core$sp3__0 = (function (){ +return null; +}); +var cljs$core$sp3__1 = (function (x){ +var or__3936__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null,x)); +} +} +}); +var cljs$core$sp3__2 = (function (x,y){ +var or__3936__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$2)){ +return or__3936__auto____$2; +} else { +var or__3936__auto____$3 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$3)){ +return or__3936__auto____$3; +} else { +var or__3936__auto____$4 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$4)){ +return or__3936__auto____$4; +} else { +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null,y)); +} +} +} +} +} +}); +var cljs$core$sp3__3 = (function (x,y,z){ +var or__3936__auto__ = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(x) : p1.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(x) : p2.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(x) : p3.call(null,x)); +if(cljs.core.truth_(or__3936__auto____$2)){ +return or__3936__auto____$2; +} else { +var or__3936__auto____$3 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(y) : p1.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$3)){ +return or__3936__auto____$3; +} else { +var or__3936__auto____$4 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(y) : p2.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$4)){ +return or__3936__auto____$4; +} else { +var or__3936__auto____$5 = (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(y) : p3.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$5)){ +return or__3936__auto____$5; +} else { +var or__3936__auto____$6 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(z) : p1.call(null,z)); +if(cljs.core.truth_(or__3936__auto____$6)){ +return or__3936__auto____$6; +} else { +var or__3936__auto____$7 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(z) : p2.call(null,z)); +if(cljs.core.truth_(or__3936__auto____$7)){ +return or__3936__auto____$7; +} else { +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(z) : p3.call(null,z)); +} +} +} +} +} +} +} +} +}); +var cljs$core$sp3__4 = (function() { +var G__1831__delegate = function (x,y,z,args){ +var or__3936__auto__ = cljs$core$sp3.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.some(((function (or__3936__auto__){ +return (function (p1__1806_SHARP_){ +var or__3936__auto____$1 = (p1.cljs$core$IFn$_invoke$arity$1 ? p1.cljs$core$IFn$_invoke$arity$1(p1__1806_SHARP_) : p1.call(null,p1__1806_SHARP_)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = (p2.cljs$core$IFn$_invoke$arity$1 ? p2.cljs$core$IFn$_invoke$arity$1(p1__1806_SHARP_) : p2.call(null,p1__1806_SHARP_)); +if(cljs.core.truth_(or__3936__auto____$2)){ +return or__3936__auto____$2; +} else { +return (p3.cljs$core$IFn$_invoke$arity$1 ? p3.cljs$core$IFn$_invoke$arity$1(p1__1806_SHARP_) : p3.call(null,p1__1806_SHARP_)); +} +} +});})(or__3936__auto__)) +,args); +} +}; +var G__1831 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1832__i = 0, G__1832__a = new Array(arguments.length - 3); +while (G__1832__i < G__1832__a.length) {G__1832__a[G__1832__i] = arguments[G__1832__i + 3]; ++G__1832__i;} + args = new cljs.core.IndexedSeq(G__1832__a,0,null); +} +return G__1831__delegate.call(this,x,y,z,args);}; +G__1831.cljs$lang$maxFixedArity = 3; +G__1831.cljs$lang$applyTo = (function (arglist__1833){ +var x = cljs.core.first(arglist__1833); +arglist__1833 = cljs.core.next(arglist__1833); +var y = cljs.core.first(arglist__1833); +arglist__1833 = cljs.core.next(arglist__1833); +var z = cljs.core.first(arglist__1833); +var args = cljs.core.rest(arglist__1833); +return G__1831__delegate(x,y,z,args); +}); +G__1831.cljs$core$IFn$_invoke$arity$variadic = G__1831__delegate; +return G__1831; +})() +; +cljs$core$sp3 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$sp3__0.call(this); +case 1: +return cljs$core$sp3__1.call(this,x); +case 2: +return cljs$core$sp3__2.call(this,x,y); +case 3: +return cljs$core$sp3__3.call(this,x,y,z); +default: +var G__1834 = null; +if (arguments.length > 3) { +var G__1835__i = 0, G__1835__a = new Array(arguments.length - 3); +while (G__1835__i < G__1835__a.length) {G__1835__a[G__1835__i] = arguments[G__1835__i + 3]; ++G__1835__i;} +G__1834 = new cljs.core.IndexedSeq(G__1835__a,0,null); +} +return cljs$core$sp3__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1834); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$sp3.cljs$lang$maxFixedArity = 3; +cljs$core$sp3.cljs$lang$applyTo = cljs$core$sp3__4.cljs$lang$applyTo; +cljs$core$sp3.cljs$core$IFn$_invoke$arity$0 = cljs$core$sp3__0; +cljs$core$sp3.cljs$core$IFn$_invoke$arity$1 = cljs$core$sp3__1; +cljs$core$sp3.cljs$core$IFn$_invoke$arity$2 = cljs$core$sp3__2; +cljs$core$sp3.cljs$core$IFn$_invoke$arity$3 = cljs$core$sp3__3; +cljs$core$sp3.cljs$core$IFn$_invoke$arity$variadic = cljs$core$sp3__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$sp3; +})() +}); + +cljs.core.some_fn.cljs$core$IFn$_invoke$arity$variadic = (function (p1,p2,p3,ps){ +var ps__$1 = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(p1,p2,p3,ps); +return ((function (ps__$1){ +return (function() { +var cljs$core$spn = null; +var cljs$core$spn__0 = (function (){ +return null; +}); +var cljs$core$spn__1 = (function (x){ +return cljs.core.some(((function (ps__$1){ +return (function (p1__1807_SHARP_){ +return (p1__1807_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1807_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__1807_SHARP_.call(null,x)); +});})(ps__$1)) +,ps__$1); +}); +var cljs$core$spn__2 = (function (x,y){ +return cljs.core.some(((function (ps__$1){ +return (function (p1__1808_SHARP_){ +var or__3936__auto__ = (p1__1808_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1808_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__1808_SHARP_.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return (p1__1808_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1808_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__1808_SHARP_.call(null,y)); +} +});})(ps__$1)) +,ps__$1); +}); +var cljs$core$spn__3 = (function (x,y,z){ +return cljs.core.some(((function (ps__$1){ +return (function (p1__1809_SHARP_){ +var or__3936__auto__ = (p1__1809_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1809_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p1__1809_SHARP_.call(null,x)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (p1__1809_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1809_SHARP_.cljs$core$IFn$_invoke$arity$1(y) : p1__1809_SHARP_.call(null,y)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +return (p1__1809_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p1__1809_SHARP_.cljs$core$IFn$_invoke$arity$1(z) : p1__1809_SHARP_.call(null,z)); +} +} +});})(ps__$1)) +,ps__$1); +}); +var cljs$core$spn__4 = (function() { +var G__1836__delegate = function (x,y,z,args){ +var or__3936__auto__ = cljs$core$spn.cljs$core$IFn$_invoke$arity$3(x,y,z); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.some(((function (or__3936__auto__,ps__$1){ +return (function (p1__1810_SHARP_){ +return cljs.core.some(p1__1810_SHARP_,args); +});})(or__3936__auto__,ps__$1)) +,ps__$1); +} +}; +var G__1836 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__1837__i = 0, G__1837__a = new Array(arguments.length - 3); +while (G__1837__i < G__1837__a.length) {G__1837__a[G__1837__i] = arguments[G__1837__i + 3]; ++G__1837__i;} + args = new cljs.core.IndexedSeq(G__1837__a,0,null); +} +return G__1836__delegate.call(this,x,y,z,args);}; +G__1836.cljs$lang$maxFixedArity = 3; +G__1836.cljs$lang$applyTo = (function (arglist__1838){ +var x = cljs.core.first(arglist__1838); +arglist__1838 = cljs.core.next(arglist__1838); +var y = cljs.core.first(arglist__1838); +arglist__1838 = cljs.core.next(arglist__1838); +var z = cljs.core.first(arglist__1838); +var args = cljs.core.rest(arglist__1838); +return G__1836__delegate(x,y,z,args); +}); +G__1836.cljs$core$IFn$_invoke$arity$variadic = G__1836__delegate; +return G__1836; +})() +; +cljs$core$spn = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return cljs$core$spn__0.call(this); +case 1: +return cljs$core$spn__1.call(this,x); +case 2: +return cljs$core$spn__2.call(this,x,y); +case 3: +return cljs$core$spn__3.call(this,x,y,z); +default: +var G__1839 = null; +if (arguments.length > 3) { +var G__1840__i = 0, G__1840__a = new Array(arguments.length - 3); +while (G__1840__i < G__1840__a.length) {G__1840__a[G__1840__i] = arguments[G__1840__i + 3]; ++G__1840__i;} +G__1839 = new cljs.core.IndexedSeq(G__1840__a,0,null); +} +return cljs$core$spn__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__1839); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +cljs$core$spn.cljs$lang$maxFixedArity = 3; +cljs$core$spn.cljs$lang$applyTo = cljs$core$spn__4.cljs$lang$applyTo; +cljs$core$spn.cljs$core$IFn$_invoke$arity$0 = cljs$core$spn__0; +cljs$core$spn.cljs$core$IFn$_invoke$arity$1 = cljs$core$spn__1; +cljs$core$spn.cljs$core$IFn$_invoke$arity$2 = cljs$core$spn__2; +cljs$core$spn.cljs$core$IFn$_invoke$arity$3 = cljs$core$spn__3; +cljs$core$spn.cljs$core$IFn$_invoke$arity$variadic = cljs$core$spn__4.cljs$core$IFn$_invoke$arity$variadic; +return cljs$core$spn; +})() +;})(ps__$1)) +}); + +/** @this {Function} */ +cljs.core.some_fn.cljs$lang$applyTo = (function (seq1812){ +var G__1813 = cljs.core.first(seq1812); +var seq1812__$1 = cljs.core.next(seq1812); +var G__1814 = cljs.core.first(seq1812__$1); +var seq1812__$2 = cljs.core.next(seq1812__$1); +var G__1815 = cljs.core.first(seq1812__$2); +var seq1812__$3 = cljs.core.next(seq1812__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1813,G__1814,G__1815,seq1812__$3); +}); + +cljs.core.some_fn.cljs$lang$maxFixedArity = (3); + +/** + * Returns a lazy sequence consisting of the result of applying f to + * the set of first items of each coll, followed by applying f to the + * set of second items in each coll, until any one of the colls is + * exhausted. Any remaining items in other colls are ignored. Function + * f should accept number-of-colls arguments. Returns a transducer when + * no collection is provided. + */ +cljs.core.map = (function cljs$core$map(var_args){ +var G__1848 = arguments.length; +switch (G__1848) { +case 1: +return cljs.core.map.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.map.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.map.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.map.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1861 = arguments.length; +var i__4519__auto___1862 = (0); +while(true){ +if((i__4519__auto___1862 < len__4518__auto___1861)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1862])); + +var G__1863 = (i__4519__auto___1862 + (1)); +i__4519__auto___1862 = G__1863; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((4)),(0),null)); +return cljs.core.map.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__4534__auto__); + +} +}); + +cljs.core.map.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (function (rf){ +return (function() { +var G__1864 = null; +var G__1864__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1864__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1864__2 = (function (result,input){ +var G__1849 = result; +var G__1850 = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(input) : f.call(null,input)); +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__1849,G__1850) : rf.call(null,G__1849,G__1850)); +}); +var G__1864__3 = (function() { +var G__1865__delegate = function (result,input,inputs){ +var G__1851 = result; +var G__1852 = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,input,inputs); +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__1851,G__1852) : rf.call(null,G__1851,G__1852)); +}; +var G__1865 = function (result,input,var_args){ +var inputs = null; +if (arguments.length > 2) { +var G__1866__i = 0, G__1866__a = new Array(arguments.length - 2); +while (G__1866__i < G__1866__a.length) {G__1866__a[G__1866__i] = arguments[G__1866__i + 2]; ++G__1866__i;} + inputs = new cljs.core.IndexedSeq(G__1866__a,0,null); +} +return G__1865__delegate.call(this,result,input,inputs);}; +G__1865.cljs$lang$maxFixedArity = 2; +G__1865.cljs$lang$applyTo = (function (arglist__1867){ +var result = cljs.core.first(arglist__1867); +arglist__1867 = cljs.core.next(arglist__1867); +var input = cljs.core.first(arglist__1867); +var inputs = cljs.core.rest(arglist__1867); +return G__1865__delegate(result,input,inputs); +}); +G__1865.cljs$core$IFn$_invoke$arity$variadic = G__1865__delegate; +return G__1865; +})() +; +G__1864 = function(result,input,var_args){ +var inputs = var_args; +switch(arguments.length){ +case 0: +return G__1864__0.call(this); +case 1: +return G__1864__1.call(this,result); +case 2: +return G__1864__2.call(this,result,input); +default: +var G__1868 = null; +if (arguments.length > 2) { +var G__1869__i = 0, G__1869__a = new Array(arguments.length - 2); +while (G__1869__i < G__1869__a.length) {G__1869__a[G__1869__i] = arguments[G__1869__i + 2]; ++G__1869__i;} +G__1868 = new cljs.core.IndexedSeq(G__1869__a,0,null); +} +return G__1864__3.cljs$core$IFn$_invoke$arity$variadic(result,input, G__1868); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1864.cljs$lang$maxFixedArity = 2; +G__1864.cljs$lang$applyTo = G__1864__3.cljs$lang$applyTo; +G__1864.cljs$core$IFn$_invoke$arity$0 = G__1864__0; +G__1864.cljs$core$IFn$_invoke$arity$1 = G__1864__1; +G__1864.cljs$core$IFn$_invoke$arity$2 = G__1864__2; +G__1864.cljs$core$IFn$_invoke$arity$variadic = G__1864__3.cljs$core$IFn$_invoke$arity$variadic; +return G__1864; +})() +}); +}); + +cljs.core.map.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s)){ +var c = cljs.core.chunk_first(s); +var size = cljs.core.count(c); +var b = cljs.core.chunk_buffer(size); +var n__4395__auto___1870 = size; +var i_1871 = (0); +while(true){ +if((i_1871 < n__4395__auto___1870)){ +cljs.core.chunk_append(b,(function (){var G__1853 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c,i_1871); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1853) : f.call(null,G__1853)); +})()); + +var G__1872 = (i_1871 + (1)); +i_1871 = G__1872; +continue; +} else { +} +break; +} + +return cljs.core.chunk_cons(cljs.core.chunk(b),cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,cljs.core.chunk_rest(s))); +} else { +return cljs.core.cons((function (){var G__1854 = cljs.core.first(s); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__1854) : f.call(null,G__1854)); +})(),cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,cljs.core.rest(s))); +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.map.cljs$core$IFn$_invoke$arity$3 = (function (f,c1,c2){ +return (new cljs.core.LazySeq(null,(function (){ +var s1 = cljs.core.seq(c1); +var s2 = cljs.core.seq(c2); +if(((s1) && (s2))){ +return cljs.core.cons((function (){var G__1855 = cljs.core.first(s1); +var G__1856 = cljs.core.first(s2); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1855,G__1856) : f.call(null,G__1855,G__1856)); +})(),cljs.core.map.cljs$core$IFn$_invoke$arity$3(f,cljs.core.rest(s1),cljs.core.rest(s2))); +} else { +return null; +} +}),null,null)); +}); + +cljs.core.map.cljs$core$IFn$_invoke$arity$4 = (function (f,c1,c2,c3){ +return (new cljs.core.LazySeq(null,(function (){ +var s1 = cljs.core.seq(c1); +var s2 = cljs.core.seq(c2); +var s3 = cljs.core.seq(c3); +if(((s1) && (s2) && (s3))){ +return cljs.core.cons((function (){var G__1857 = cljs.core.first(s1); +var G__1858 = cljs.core.first(s2); +var G__1859 = cljs.core.first(s3); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__1857,G__1858,G__1859) : f.call(null,G__1857,G__1858,G__1859)); +})(),cljs.core.map.cljs$core$IFn$_invoke$arity$4(f,cljs.core.rest(s1),cljs.core.rest(s2),cljs.core.rest(s3))); +} else { +return null; +} +}),null,null)); +}); + +cljs.core.map.cljs$core$IFn$_invoke$arity$variadic = (function (f,c1,c2,c3,colls){ +var step = (function cljs$core$step(cs){ +return (new cljs.core.LazySeq(null,(function (){ +var ss = cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.seq,cs); +if(cljs.core.every_QMARK_(cljs.core.identity,ss)){ +return cljs.core.cons(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.first,ss),cljs$core$step(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.rest,ss))); +} else { +return null; +} +}),null,null)); +}); +return cljs.core.map.cljs$core$IFn$_invoke$arity$2(((function (step){ +return (function (p1__1841_SHARP_){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,p1__1841_SHARP_); +});})(step)) +,step(cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(colls,c3,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([c2,c1], 0)))); +}); + +/** @this {Function} */ +cljs.core.map.cljs$lang$applyTo = (function (seq1843){ +var G__1844 = cljs.core.first(seq1843); +var seq1843__$1 = cljs.core.next(seq1843); +var G__1845 = cljs.core.first(seq1843__$1); +var seq1843__$2 = cljs.core.next(seq1843__$1); +var G__1846 = cljs.core.first(seq1843__$2); +var seq1843__$3 = cljs.core.next(seq1843__$2); +var G__1847 = cljs.core.first(seq1843__$3); +var seq1843__$4 = cljs.core.next(seq1843__$3); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1844,G__1845,G__1846,G__1847,seq1843__$4); +}); + +cljs.core.map.cljs$lang$maxFixedArity = (4); + +/** + * Returns a lazy sequence of the first n items in coll, or all items if + * there are fewer than n. Returns a stateful transducer when + * no collection is provided. + */ +cljs.core.take = (function cljs$core$take(var_args){ +var G__1874 = arguments.length; +switch (G__1874) { +case 1: +return cljs.core.take.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.take.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.take.cljs$core$IFn$_invoke$arity$1 = (function (n){ +if(typeof n === 'number'){ +} else { +throw (new Error("Assert failed: (number? n)")); +} + +return (function (rf){ +var na = cljs.core.volatile_BANG_(n); +return ((function (na){ +return (function() { +var G__1876 = null; +var G__1876__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1876__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1876__2 = (function (result,input){ +var n__$1 = cljs.core.deref(na); +var nn = cljs.core._vreset_BANG_(na,(cljs.core._deref(na) - (1))); +var result__$1 = (((n__$1 > (0)))?(rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)):result); +if(!((nn > (0)))){ +return cljs.core.ensure_reduced(result__$1); +} else { +return result__$1; +} +}); +G__1876 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1876__0.call(this); +case 1: +return G__1876__1.call(this,result); +case 2: +return G__1876__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1876.cljs$core$IFn$_invoke$arity$0 = G__1876__0; +G__1876.cljs$core$IFn$_invoke$arity$1 = G__1876__1; +G__1876.cljs$core$IFn$_invoke$arity$2 = G__1876__2; +return G__1876; +})() +;})(na)) +}); +}); + +cljs.core.take.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +if(typeof n === 'number'){ +} else { +throw (new Error("Assert failed: (number? n)")); +} + +return (new cljs.core.LazySeq(null,(function (){ +if((n > (0))){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +return cljs.core.cons(cljs.core.first(s),cljs.core.take.cljs$core$IFn$_invoke$arity$2((n - (1)),cljs.core.rest(s))); +} else { +return null; +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.take.cljs$lang$maxFixedArity = 2; + +/** + * Returns a lazy sequence of all but the first n items in coll. + * Returns a stateful transducer when no collection is provided. + */ +cljs.core.drop = (function cljs$core$drop(var_args){ +var G__1878 = arguments.length; +switch (G__1878) { +case 1: +return cljs.core.drop.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.drop.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.drop.cljs$core$IFn$_invoke$arity$1 = (function (n){ +if(typeof n === 'number'){ +} else { +throw (new Error("Assert failed: (number? n)")); +} + +return (function (rf){ +var na = cljs.core.volatile_BANG_(n); +return ((function (na){ +return (function() { +var G__1880 = null; +var G__1880__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1880__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1880__2 = (function (result,input){ +var n__$1 = cljs.core.deref(na); +cljs.core._vreset_BANG_(na,(cljs.core._deref(na) - (1))); + +if((n__$1 > (0))){ +return result; +} else { +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} +}); +G__1880 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1880__0.call(this); +case 1: +return G__1880__1.call(this,result); +case 2: +return G__1880__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1880.cljs$core$IFn$_invoke$arity$0 = G__1880__0; +G__1880.cljs$core$IFn$_invoke$arity$1 = G__1880__1; +G__1880.cljs$core$IFn$_invoke$arity$2 = G__1880__2; +return G__1880; +})() +;})(na)) +}); +}); + +cljs.core.drop.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +if(typeof n === 'number'){ +} else { +throw (new Error("Assert failed: (number? n)")); +} + +var step = (function (n__$1,coll__$1){ +while(true){ +var s = cljs.core.seq(coll__$1); +if((((n__$1 > (0))) && (s))){ +var G__1881 = (n__$1 - (1)); +var G__1882 = cljs.core.rest(s); +n__$1 = G__1881; +coll__$1 = G__1882; +continue; +} else { +return s; +} +break; +} +}); +return (new cljs.core.LazySeq(null,((function (step){ +return (function (){ +return step(n,coll); +});})(step)) +,null,null)); +}); + +cljs.core.drop.cljs$lang$maxFixedArity = 2; + +/** + * Return a lazy sequence of all but the last n (default 1) items in coll + */ +cljs.core.drop_last = (function cljs$core$drop_last(var_args){ +var G__1884 = arguments.length; +switch (G__1884) { +case 1: +return cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.drop_last.cljs$core$IFn$_invoke$arity$1 = (function (s){ +return cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2((1),s); +}); + +cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2 = (function (n,s){ +return cljs.core.map.cljs$core$IFn$_invoke$arity$3((function (x,_){ +return x; +}),s,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,s)); +}); + +cljs.core.drop_last.cljs$lang$maxFixedArity = 2; + +/** + * Returns a seq of the last n items in coll. Depending on the type + * of coll may be no better than linear time. For vectors, see also subvec. + */ +cljs.core.take_last = (function cljs$core$take_last(n,coll){ +var s = cljs.core.seq(coll); +var lead = cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,coll)); +while(true){ +if(lead){ +var G__1886 = cljs.core.next(s); +var G__1887 = cljs.core.next(lead); +s = G__1886; +lead = G__1887; +continue; +} else { +return s; +} +break; +} +}); +/** + * Returns a lazy sequence of the items in coll starting from the + * first item for which (pred item) returns logical false. Returns a + * stateful transducer when no collection is provided. + */ +cljs.core.drop_while = (function cljs$core$drop_while(var_args){ +var G__1889 = arguments.length; +switch (G__1889) { +case 1: +return cljs.core.drop_while.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.drop_while.cljs$core$IFn$_invoke$arity$1 = (function (pred){ +return (function (rf){ +var da = cljs.core.volatile_BANG_(true); +return ((function (da){ +return (function() { +var G__1893 = null; +var G__1893__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1893__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1893__2 = (function (result,input){ +var drop_QMARK_ = cljs.core.deref(da); +if(cljs.core.truth_((function (){var and__3925__auto__ = drop_QMARK_; +if(cljs.core.truth_(and__3925__auto__)){ +return (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null,input)); +} else { +return and__3925__auto__; +} +})())){ +return result; +} else { +cljs.core.vreset_BANG_(da,null); + +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} +}); +G__1893 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1893__0.call(this); +case 1: +return G__1893__1.call(this,result); +case 2: +return G__1893__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1893.cljs$core$IFn$_invoke$arity$0 = G__1893__0; +G__1893.cljs$core$IFn$_invoke$arity$1 = G__1893__1; +G__1893.cljs$core$IFn$_invoke$arity$2 = G__1893__2; +return G__1893; +})() +;})(da)) +}); +}); + +cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){ +var step = (function (pred__$1,coll__$1){ +while(true){ +var s = cljs.core.seq(coll__$1); +if(cljs.core.truth_((function (){var and__3925__auto__ = s; +if(and__3925__auto__){ +var G__1891 = cljs.core.first(s); +return (pred__$1.cljs$core$IFn$_invoke$arity$1 ? pred__$1.cljs$core$IFn$_invoke$arity$1(G__1891) : pred__$1.call(null,G__1891)); +} else { +return and__3925__auto__; +} +})())){ +var G__1894 = pred__$1; +var G__1895 = cljs.core.rest(s); +pred__$1 = G__1894; +coll__$1 = G__1895; +continue; +} else { +return s; +} +break; +} +}); +return (new cljs.core.LazySeq(null,((function (step){ +return (function (){ +return step(pred,coll); +});})(step)) +,null,null)); +}); + +cljs.core.drop_while.cljs$lang$maxFixedArity = 2; + + +/** +* @constructor + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IPending} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Cycle = (function (meta,all,prev,current,_next){ +this.meta = meta; +this.all = all; +this.prev = prev; +this.current = current; +this._next = _next; +this.cljs$lang$protocol_mask$partition0$ = 26083532; +this.cljs$lang$protocol_mask$partition1$ = 1; +}); +cljs.core.Cycle.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.Cycle.prototype.currentval = (function (){ +var self__ = this; +var coll = this; +if(self__.current){ +} else { +var temp__5455__auto___1900 = cljs.core.next(self__.prev); +if(temp__5455__auto___1900){ +var c_1901 = temp__5455__auto___1900; +self__.current = c_1901; +} else { +self__.current = self__.all; +} +} + +return self__.current; +}); + +cljs.core.Cycle.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.Cycle.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ISeq$_rest$arity$1(null); +}); + +cljs.core.Cycle.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.Cycle.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return !((self__.current == null)); +}); + +cljs.core.Cycle.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +var s = coll__$1.currentval(); +var ret = cljs.core.first(s); +while(true){ +var s__$1 = (function (){var or__3936__auto__ = cljs.core.next(s); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return self__.all; +} +})(); +var ret__$1 = (function (){var G__1896 = ret; +var G__1897 = cljs.core.first(s__$1); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1896,G__1897) : f.call(null,G__1896,G__1897)); +})(); +if(cljs.core.reduced_QMARK_(ret__$1)){ +return cljs.core.deref(ret__$1); +} else { +var G__1902 = s__$1; +var G__1903 = ret__$1; +s = G__1902; +ret = G__1903; +continue; +} +break; +} +}); + +cljs.core.Cycle.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +var s = coll__$1.currentval(); +var ret = start; +while(true){ +var ret__$1 = (function (){var G__1898 = ret; +var G__1899 = cljs.core.first(s); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__1898,G__1899) : f.call(null,G__1898,G__1899)); +})(); +if(cljs.core.reduced_QMARK_(ret__$1)){ +return cljs.core.deref(ret__$1); +} else { +var G__1904 = (function (){var or__3936__auto__ = cljs.core.next(s); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return self__.all; +} +})(); +var G__1905 = ret__$1; +s = G__1904; +ret = G__1905; +continue; +} +break; +} +}); + +cljs.core.Cycle.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.first(coll__$1.currentval()); +}); + +cljs.core.Cycle.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__._next == null)){ +self__._next = (new cljs.core.Cycle(null,self__.all,coll__$1.currentval(),null,null)); +} else { +} + +return self__._next; +}); + +cljs.core.Cycle.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.Cycle.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.Cycle(meta__$1,self__.all,self__.prev,self__.current,self__._next)); +}); + +cljs.core.Cycle.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.Cycle.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$all,cljs.core.cst$sym$prev,cljs.core.with_meta(cljs.core.cst$sym$current,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$_next,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Cycle.cljs$lang$type = true; + +cljs.core.Cycle.cljs$lang$ctorStr = "cljs.core/Cycle"; + +cljs.core.Cycle.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Cycle"); +}); + +/** + * Positional factory function for cljs.core/Cycle. + */ +cljs.core.__GT_Cycle = (function cljs$core$__GT_Cycle(meta,all,prev,current,_next){ +return (new cljs.core.Cycle(meta,all,prev,current,_next)); +}); + +/** + * Returns a lazy (infinite!) sequence of repetitions of the items in coll. + */ +cljs.core.cycle = (function cljs$core$cycle(coll){ +var temp__5455__auto__ = cljs.core.seq(coll); +if(temp__5455__auto__){ +var vals = temp__5455__auto__; +return (new cljs.core.Cycle(null,vals,null,vals,null)); +} else { +return cljs.core.List.EMPTY; +} +}); +/** + * Returns a vector of [(take n coll) (drop n coll)] + */ +cljs.core.split_at = (function cljs$core$split_at(n,coll){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,coll),cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,coll)], null); +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IPending} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Repeat = (function (meta,count,val,next,__hash){ +this.meta = meta; +this.count = count; +this.val = val; +this.next = next; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32374988; +this.cljs$lang$protocol_mask$partition1$ = 1; +}); +cljs.core.Repeat.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.Repeat.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Repeat.prototype.indexOf = (function() { +var G__1906 = null; +var G__1906__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__1906__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1906 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1906__1.call(this,x); +case 2: +return G__1906__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1906.cljs$core$IFn$_invoke$arity$1 = G__1906__1; +G__1906.cljs$core$IFn$_invoke$arity$2 = G__1906__2; +return G__1906; +})() +; + +cljs.core.Repeat.prototype.lastIndexOf = (function() { +var G__1907 = null; +var G__1907__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,self__.count); +}); +var G__1907__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__1907 = function(x,start){ +switch(arguments.length){ +case 1: +return G__1907__1.call(this,x); +case 2: +return G__1907__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1907.cljs$core$IFn$_invoke$arity$1 = G__1907__1; +G__1907.cljs$core$IFn$_invoke$arity$2 = G__1907__2; +return G__1907; +})() +; + +cljs.core.Repeat.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.Repeat.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.next == null)){ +if((self__.count > (1))){ +self__.next = (new cljs.core.Repeat(null,(self__.count - (1)),self__.val,null,null)); + +return self__.next; +} else { +if(((-1) === self__.count)){ +return coll__$1; +} else { +return null; +} +} +} else { +return self__.next; +} +}); + +cljs.core.Repeat.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.Repeat.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.Repeat.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.Repeat.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return false; +}); + +cljs.core.Repeat.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +if((self__.count === (-1))){ +var ret = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(self__.val,self__.val) : f.call(null,self__.val,self__.val)); +while(true){ +if(cljs.core.reduced_QMARK_(ret)){ +return cljs.core.deref(ret); +} else { +var G__1908 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null,ret,self__.val)); +ret = G__1908; +continue; +} +break; +} +} else { +var i = (1); +var ret = self__.val; +while(true){ +if((i < self__.count)){ +var ret__$1 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null,ret,self__.val)); +if(cljs.core.reduced_QMARK_(ret__$1)){ +return cljs.core.deref(ret__$1); +} else { +var G__1909 = (i + (1)); +var G__1910 = ret__$1; +i = G__1909; +ret = G__1910; +continue; +} +} else { +return ret; +} +break; +} +} +}); + +cljs.core.Repeat.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +if((self__.count === (-1))){ +var ret = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(start,self__.val) : f.call(null,start,self__.val)); +while(true){ +if(cljs.core.reduced_QMARK_(ret)){ +return cljs.core.deref(ret); +} else { +var G__1911 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null,ret,self__.val)); +ret = G__1911; +continue; +} +break; +} +} else { +var i = (0); +var ret = start; +while(true){ +if((i < self__.count)){ +var ret__$1 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,self__.val) : f.call(null,ret,self__.val)); +if(cljs.core.reduced_QMARK_(ret__$1)){ +return cljs.core.deref(ret__$1); +} else { +var G__1912 = (i + (1)); +var G__1913 = ret__$1; +i = G__1912; +ret = G__1913; +continue; +} +} else { +return ret; +} +break; +} +} +}); + +cljs.core.Repeat.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.val; +}); + +cljs.core.Repeat.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.next == null)){ +if((self__.count > (1))){ +self__.next = (new cljs.core.Repeat(null,(self__.count - (1)),self__.val,null,null)); + +return self__.next; +} else { +if(((-1) === self__.count)){ +return coll__$1; +} else { +return cljs.core.List.EMPTY; +} +} +} else { +return self__.next; +} +}); + +cljs.core.Repeat.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.Repeat.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.Repeat(meta__$1,self__.count,self__.val,self__.next,null)); +}); + +cljs.core.Repeat.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.Repeat.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$count,cljs.core.cst$sym$val,cljs.core.with_meta(cljs.core.cst$sym$next,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Repeat.cljs$lang$type = true; + +cljs.core.Repeat.cljs$lang$ctorStr = "cljs.core/Repeat"; + +cljs.core.Repeat.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Repeat"); +}); + +/** + * Positional factory function for cljs.core/Repeat. + */ +cljs.core.__GT_Repeat = (function cljs$core$__GT_Repeat(meta,count,val,next,__hash){ +return (new cljs.core.Repeat(meta,count,val,next,__hash)); +}); + +/** + * Returns a lazy (infinite!, or length n if supplied) sequence of xs. + */ +cljs.core.repeat = (function cljs$core$repeat(var_args){ +var G__1915 = arguments.length; +switch (G__1915) { +case 1: +return cljs.core.repeat.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.repeat.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.repeat.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (new cljs.core.Repeat(null,(-1),x,null,null)); +}); + +cljs.core.repeat.cljs$core$IFn$_invoke$arity$2 = (function (n,x){ +if((n > (0))){ +return (new cljs.core.Repeat(null,n,x,null,null)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.repeat.cljs$lang$maxFixedArity = 2; + +/** + * DEPRECATED: Use 'repeat' instead. + * Returns a lazy seq of n xs. + */ +cljs.core.replicate = (function cljs$core$replicate(n,x){ +return cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(x)); +}); +/** + * Takes a function of no args, presumably with side effects, and + * returns an infinite (or length n if supplied) lazy sequence of calls + * to it + */ +cljs.core.repeatedly = (function cljs$core$repeatedly(var_args){ +var G__1918 = arguments.length; +switch (G__1918) { +case 1: +return cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (new cljs.core.LazySeq(null,(function (){ +return cljs.core.cons((f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)),cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1(f)); +}),null,null)); +}); + +cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$2 = (function (n,f){ +return cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.repeatedly.cljs$core$IFn$_invoke$arity$1(f)); +}); + +cljs.core.repeatedly.cljs$lang$maxFixedArity = 2; + +cljs.core.UNREALIZED_SEED = ({}); + +/** +* @constructor + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IPending} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Iterate = (function (meta,f,prev_seed,seed,next){ +this.meta = meta; +this.f = f; +this.prev_seed = prev_seed; +this.seed = seed; +this.next = next; +this.cljs$lang$protocol_mask$partition0$ = 26083532; +this.cljs$lang$protocol_mask$partition1$ = 1; +}); +cljs.core.Iterate.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.Iterate.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.Iterate.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ISeq$_rest$arity$1(null); +}); + +cljs.core.Iterate.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.Iterate.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return !((self__.seed === cljs.core.UNREALIZED_SEED)); +}); + +cljs.core.Iterate.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,rf){ +var self__ = this; +var coll__$1 = this; +var first = coll__$1.cljs$core$ISeq$_first$arity$1(null); +var v = (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(first) : self__.f.call(null,first)); +var ret = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(first,v) : rf.call(null,first,v)); +var v__$1 = v; +while(true){ +if(cljs.core.reduced_QMARK_(ret)){ +return cljs.core.deref(ret); +} else { +var v__$2 = (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(v__$1) : self__.f.call(null,v__$1)); +var G__1920 = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(ret,v__$2) : rf.call(null,ret,v__$2)); +var G__1921 = v__$2; +ret = G__1920; +v__$1 = G__1921; +continue; +} +break; +} +}); + +cljs.core.Iterate.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,rf,start){ +var self__ = this; +var coll__$1 = this; +var v = coll__$1.cljs$core$ISeq$_first$arity$1(null); +var ret = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(start,v) : rf.call(null,start,v)); +var v__$1 = v; +while(true){ +if(cljs.core.reduced_QMARK_(ret)){ +return cljs.core.deref(ret); +} else { +var v__$2 = (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(v__$1) : self__.f.call(null,v__$1)); +var G__1922 = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(ret,v__$2) : rf.call(null,ret,v__$2)); +var G__1923 = v__$2; +ret = G__1922; +v__$1 = G__1923; +continue; +} +break; +} +}); + +cljs.core.Iterate.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((cljs.core.UNREALIZED_SEED === self__.seed)){ +self__.seed = (self__.f.cljs$core$IFn$_invoke$arity$1 ? self__.f.cljs$core$IFn$_invoke$arity$1(self__.prev_seed) : self__.f.call(null,self__.prev_seed)); +} else { +} + +return self__.seed; +}); + +cljs.core.Iterate.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.next == null)){ +self__.next = (new cljs.core.Iterate(null,self__.f,coll__$1.cljs$core$ISeq$_first$arity$1(null),cljs.core.UNREALIZED_SEED,null)); +} else { +} + +return self__.next; +}); + +cljs.core.Iterate.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.Iterate.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.Iterate(meta__$1,self__.f,self__.prev_seed,self__.seed,self__.next)); +}); + +cljs.core.Iterate.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.Iterate.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$f,cljs.core.cst$sym$prev_DASH_seed,cljs.core.with_meta(cljs.core.cst$sym$seed,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$next,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Iterate.cljs$lang$type = true; + +cljs.core.Iterate.cljs$lang$ctorStr = "cljs.core/Iterate"; + +cljs.core.Iterate.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Iterate"); +}); + +/** + * Positional factory function for cljs.core/Iterate. + */ +cljs.core.__GT_Iterate = (function cljs$core$__GT_Iterate(meta,f,prev_seed,seed,next){ +return (new cljs.core.Iterate(meta,f,prev_seed,seed,next)); +}); + +/** + * Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects + */ +cljs.core.iterate = (function cljs$core$iterate(f,x){ +return (new cljs.core.Iterate(null,f,null,x,null)); +}); +/** + * Returns a lazy seq of the first item in each coll, then the second etc. + */ +cljs.core.interleave = (function cljs$core$interleave(var_args){ +var G__1928 = arguments.length; +switch (G__1928) { +case 0: +return cljs.core.interleave.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.interleave.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.interleave.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1930 = arguments.length; +var i__4519__auto___1931 = (0); +while(true){ +if((i__4519__auto___1931 < len__4518__auto___1930)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1931])); + +var G__1932 = (i__4519__auto___1931 + (1)); +i__4519__auto___1931 = G__1932; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((2)),(0),null)); +return cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4534__auto__); + +} +}); + +cljs.core.interleave.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.List.EMPTY; +}); + +cljs.core.interleave.cljs$core$IFn$_invoke$arity$1 = (function (c1){ +return (new cljs.core.LazySeq(null,(function (){ +return c1; +}),null,null)); +}); + +cljs.core.interleave.cljs$core$IFn$_invoke$arity$2 = (function (c1,c2){ +return (new cljs.core.LazySeq(null,(function (){ +var s1 = cljs.core.seq(c1); +var s2 = cljs.core.seq(c2); +if(((s1) && (s2))){ +return cljs.core.cons(cljs.core.first(s1),cljs.core.cons(cljs.core.first(s2),cljs.core.interleave.cljs$core$IFn$_invoke$arity$2(cljs.core.rest(s1),cljs.core.rest(s2)))); +} else { +return null; +} +}),null,null)); +}); + +cljs.core.interleave.cljs$core$IFn$_invoke$arity$variadic = (function (c1,c2,colls){ +return (new cljs.core.LazySeq(null,(function (){ +var ss = cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.seq,cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(colls,c2,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([c1], 0))); +if(cljs.core.every_QMARK_(cljs.core.identity,ss)){ +return cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.first,ss),cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.interleave,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.rest,ss))); +} else { +return null; +} +}),null,null)); +}); + +/** @this {Function} */ +cljs.core.interleave.cljs$lang$applyTo = (function (seq1925){ +var G__1926 = cljs.core.first(seq1925); +var seq1925__$1 = cljs.core.next(seq1925); +var G__1927 = cljs.core.first(seq1925__$1); +var seq1925__$2 = cljs.core.next(seq1925__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1926,G__1927,seq1925__$2); +}); + +cljs.core.interleave.cljs$lang$maxFixedArity = (2); + +/** + * Returns a lazy seq of the elements of coll separated by sep. + * Returns a stateful transducer when no collection is provided. + */ +cljs.core.interpose = (function cljs$core$interpose(var_args){ +var G__1934 = arguments.length; +switch (G__1934) { +case 1: +return cljs.core.interpose.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.interpose.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.interpose.cljs$core$IFn$_invoke$arity$1 = (function (sep){ +return (function (rf){ +var started = cljs.core.volatile_BANG_(false); +return ((function (started){ +return (function() { +var G__1936 = null; +var G__1936__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1936__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1936__2 = (function (result,input){ +if(cljs.core.truth_(cljs.core.deref(started))){ +var sepr = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,sep) : rf.call(null,result,sep)); +if(cljs.core.reduced_QMARK_(sepr)){ +return sepr; +} else { +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(sepr,input) : rf.call(null,sepr,input)); +} +} else { +cljs.core.vreset_BANG_(started,true); + +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} +}); +G__1936 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1936__0.call(this); +case 1: +return G__1936__1.call(this,result); +case 2: +return G__1936__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1936.cljs$core$IFn$_invoke$arity$0 = G__1936__0; +G__1936.cljs$core$IFn$_invoke$arity$1 = G__1936__1; +G__1936.cljs$core$IFn$_invoke$arity$2 = G__1936__2; +return G__1936; +})() +;})(started)) +}); +}); + +cljs.core.interpose.cljs$core$IFn$_invoke$arity$2 = (function (sep,coll){ +return cljs.core.drop.cljs$core$IFn$_invoke$arity$2((1),cljs.core.interleave.cljs$core$IFn$_invoke$arity$2(cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(sep),coll)); +}); + +cljs.core.interpose.cljs$lang$maxFixedArity = 2; + +/** + * Take a collection of collections, and return a lazy seq + * of items from the inner collection + */ +cljs.core.flatten1 = (function cljs$core$flatten1(colls){ +var cat = (function cljs$core$flatten1_$_cat(coll,colls__$1){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5455__auto__ = cljs.core.seq(coll); +if(temp__5455__auto__){ +var coll__$1 = temp__5455__auto__; +return cljs.core.cons(cljs.core.first(coll__$1),cljs$core$flatten1_$_cat(cljs.core.rest(coll__$1),colls__$1)); +} else { +if(cljs.core.seq(colls__$1)){ +return cljs$core$flatten1_$_cat(cljs.core.first(colls__$1),cljs.core.rest(colls__$1)); +} else { +return null; +} +} +}),null,null)); +}); +return cat(null,colls); +}); +/** + * Returns the result of applying concat to the result of applying map + * to f and colls. Thus function f should return a collection. Returns + * a transducer when no collections are provided + */ +cljs.core.mapcat = (function cljs$core$mapcat(var_args){ +var G__1940 = arguments.length; +switch (G__1940) { +case 1: +return cljs.core.mapcat.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1942 = arguments.length; +var i__4519__auto___1943 = (0); +while(true){ +if((i__4519__auto___1943 < len__4518__auto___1942)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1943])); + +var G__1944 = (i__4519__auto___1943 + (1)); +i__4519__auto___1943 = G__1944; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((1)),(0),null)); +return cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4534__auto__); + +} +}); + +cljs.core.mapcat.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return cljs.core.comp.cljs$core$IFn$_invoke$arity$2(cljs.core.map.cljs$core$IFn$_invoke$arity$1(f),cljs.core.cat); +}); + +cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic = (function (f,colls){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.map,f,colls)); +}); + +/** @this {Function} */ +cljs.core.mapcat.cljs$lang$applyTo = (function (seq1938){ +var G__1939 = cljs.core.first(seq1938); +var seq1938__$1 = cljs.core.next(seq1938); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1939,seq1938__$1); +}); + +cljs.core.mapcat.cljs$lang$maxFixedArity = (1); + +/** + * Returns a lazy sequence of the items in coll for which + * (pred item) returns logical true. pred must be free of side-effects. + * Returns a transducer when no collection is provided. + */ +cljs.core.filter = (function cljs$core$filter(var_args){ +var G__1946 = arguments.length; +switch (G__1946) { +case 1: +return cljs.core.filter.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.filter.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.filter.cljs$core$IFn$_invoke$arity$1 = (function (pred){ +return (function (rf){ +return (function() { +var G__1949 = null; +var G__1949__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__1949__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__1949__2 = (function (result,input){ +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null,input)))){ +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} else { +return result; +} +}); +G__1949 = function(result,input){ +switch(arguments.length){ +case 0: +return G__1949__0.call(this); +case 1: +return G__1949__1.call(this,result); +case 2: +return G__1949__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__1949.cljs$core$IFn$_invoke$arity$0 = G__1949__0; +G__1949.cljs$core$IFn$_invoke$arity$1 = G__1949__1; +G__1949.cljs$core$IFn$_invoke$arity$2 = G__1949__2; +return G__1949; +})() +}); +}); + +cljs.core.filter.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s)){ +var c = cljs.core.chunk_first(s); +var size = cljs.core.count(c); +var b = cljs.core.chunk_buffer(size); +var n__4395__auto___1950 = size; +var i_1951 = (0); +while(true){ +if((i_1951 < n__4395__auto___1950)){ +if(cljs.core.truth_((function (){var G__1947 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c,i_1951); +return (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__1947) : pred.call(null,G__1947)); +})())){ +cljs.core.chunk_append(b,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c,i_1951)); +} else { +} + +var G__1952 = (i_1951 + (1)); +i_1951 = G__1952; +continue; +} else { +} +break; +} + +return cljs.core.chunk_cons(cljs.core.chunk(b),cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred,cljs.core.chunk_rest(s))); +} else { +var f = cljs.core.first(s); +var r = cljs.core.rest(s); +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(f) : pred.call(null,f)))){ +return cljs.core.cons(f,cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred,r)); +} else { +return cljs.core.filter.cljs$core$IFn$_invoke$arity$2(pred,r); +} +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.filter.cljs$lang$maxFixedArity = 2; + +/** + * Returns a lazy sequence of the items in coll for which + * (pred item) returns logical false. pred must be free of side-effects. + * Returns a transducer when no collection is provided. + */ +cljs.core.remove = (function cljs$core$remove(var_args){ +var G__1954 = arguments.length; +switch (G__1954) { +case 1: +return cljs.core.remove.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.remove.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.remove.cljs$core$IFn$_invoke$arity$1 = (function (pred){ +return cljs.core.filter.cljs$core$IFn$_invoke$arity$1(cljs.core.complement(pred)); +}); + +cljs.core.remove.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){ +return cljs.core.filter.cljs$core$IFn$_invoke$arity$2(cljs.core.complement(pred),coll); +}); + +cljs.core.remove.cljs$lang$maxFixedArity = 2; + +/** + * Returns a lazy sequence of the nodes in a tree, via a depth-first walk. + * branch? must be a fn of one arg that returns true if passed a node + * that can have children (but may not). children must be a fn of one + * arg that returns a sequence of the children. Will only be called on + * nodes for which branch? returns true. Root is the root node of the + * tree. + */ +cljs.core.tree_seq = (function cljs$core$tree_seq(branch_QMARK_,children,root){ +var walk = (function cljs$core$tree_seq_$_walk(node){ +return (new cljs.core.LazySeq(null,(function (){ +return cljs.core.cons(node,(cljs.core.truth_((branch_QMARK_.cljs$core$IFn$_invoke$arity$1 ? branch_QMARK_.cljs$core$IFn$_invoke$arity$1(node) : branch_QMARK_.call(null,node)))?cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs$core$tree_seq_$_walk,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(children.cljs$core$IFn$_invoke$arity$1 ? children.cljs$core$IFn$_invoke$arity$1(node) : children.call(null,node))], 0)):null)); +}),null,null)); +}); +return walk(root); +}); +/** + * Takes any nested combination of sequential things (lists, vectors, + * etc.) and returns their contents as a single, flat sequence. + * (flatten nil) returns nil. + */ +cljs.core.flatten = (function cljs$core$flatten(x){ +return cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (p1__1956_SHARP_){ +return !(cljs.core.sequential_QMARK_(p1__1956_SHARP_)); +}),cljs.core.rest(cljs.core.tree_seq(cljs.core.sequential_QMARK_,cljs.core.seq,x))); +}); +/** + * Returns a new coll consisting of to-coll with all of the items of + * from-coll conjoined. A transducer may be supplied. + */ +cljs.core.into = (function cljs$core$into(var_args){ +var G__1958 = arguments.length; +switch (G__1958) { +case 0: +return cljs.core.into.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.into.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.into.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.into.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.into.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.PersistentVector.EMPTY; +}); + +cljs.core.into.cljs$core$IFn$_invoke$arity$1 = (function (to){ +return to; +}); + +cljs.core.into.cljs$core$IFn$_invoke$arity$2 = (function (to,from){ +if(!((to == null))){ +if(((!((to == null)))?(((((to.cljs$lang$protocol_mask$partition1$ & (4))) || ((cljs.core.PROTOCOL_SENTINEL === to.cljs$core$IEditableCollection$))))?true:false):false)){ +return cljs.core._with_meta(cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj_BANG_,cljs.core.transient$(to),from)),cljs.core.meta(to)); +} else { +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,to,from); +} +} else { +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,cljs.core.List.EMPTY,from); +} +}); + +cljs.core.into.cljs$core$IFn$_invoke$arity$3 = (function (to,xform,from){ +if(((!((to == null)))?(((((to.cljs$lang$protocol_mask$partition1$ & (4))) || ((cljs.core.PROTOCOL_SENTINEL === to.cljs$core$IEditableCollection$))))?true:false):false)){ +return cljs.core._with_meta(cljs.core.persistent_BANG_(cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(xform,cljs.core.conj_BANG_,cljs.core.transient$(to),from)),cljs.core.meta(to)); +} else { +return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(xform,cljs.core.conj,to,from); +} +}); + +cljs.core.into.cljs$lang$maxFixedArity = 3; + +/** + * Returns a vector consisting of the result of applying f to the + * set of first items of each coll, followed by applying f to the set + * of second items in each coll, until any one of the colls is + * exhausted. Any remaining items in other colls are ignored. Function + * f should accept number-of-colls arguments. + */ +cljs.core.mapv = (function cljs$core$mapv(var_args){ +var G__1968 = arguments.length; +switch (G__1968) { +case 2: +return cljs.core.mapv.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.mapv.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.mapv.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___1970 = arguments.length; +var i__4519__auto___1971 = (0); +while(true){ +if((i__4519__auto___1971 < len__4518__auto___1970)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___1971])); + +var G__1972 = (i__4519__auto___1971 + (1)); +i__4519__auto___1971 = G__1972; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((4)),(0),null)); +return cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),argseq__4534__auto__); + +} +}); + +cljs.core.mapv.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +return cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (v,o){ +return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(v,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(o) : f.call(null,o))); +}),cljs.core.transient$(cljs.core.PersistentVector.EMPTY),coll)); +}); + +cljs.core.mapv.cljs$core$IFn$_invoke$arity$3 = (function (f,c1,c2){ +return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$3(f,c1,c2)); +}); + +cljs.core.mapv.cljs$core$IFn$_invoke$arity$4 = (function (f,c1,c2,c3){ +return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$4(f,c1,c2,c3)); +}); + +cljs.core.mapv.cljs$core$IFn$_invoke$arity$variadic = (function (f,c1,c2,c3,colls){ +return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentVector.EMPTY,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(cljs.core.map,f,c1,c2,c3,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([colls], 0))); +}); + +/** @this {Function} */ +cljs.core.mapv.cljs$lang$applyTo = (function (seq1963){ +var G__1964 = cljs.core.first(seq1963); +var seq1963__$1 = cljs.core.next(seq1963); +var G__1965 = cljs.core.first(seq1963__$1); +var seq1963__$2 = cljs.core.next(seq1963__$1); +var G__1966 = cljs.core.first(seq1963__$2); +var seq1963__$3 = cljs.core.next(seq1963__$2); +var G__1967 = cljs.core.first(seq1963__$3); +var seq1963__$4 = cljs.core.next(seq1963__$3); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1964,G__1965,G__1966,G__1967,seq1963__$4); +}); + +cljs.core.mapv.cljs$lang$maxFixedArity = (4); + +/** + * Returns a vector of the items in coll for which + * (pred item) returns logical true. pred must be free of side-effects. + */ +cljs.core.filterv = (function cljs$core$filterv(pred,coll){ +return cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (v,o){ +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(o) : pred.call(null,o)))){ +return cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(v,o); +} else { +return v; +} +}),cljs.core.transient$(cljs.core.PersistentVector.EMPTY),coll)); +}); +/** + * Returns a lazy sequence of lists of n items each, at offsets step + * apart. If step is not supplied, defaults to n, i.e. the partitions + * do not overlap. If a pad collection is supplied, use its elements as + * necessary to complete last partition up to n items. In case there are + * not enough padding elements, return a partition with less than n items. + */ +cljs.core.partition = (function cljs$core$partition(var_args){ +var G__1974 = arguments.length; +switch (G__1974) { +case 2: +return cljs.core.partition.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.partition.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.partition.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.partition.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +return cljs.core.partition.cljs$core$IFn$_invoke$arity$3(n,n,coll); +}); + +cljs.core.partition.cljs$core$IFn$_invoke$arity$3 = (function (n,step,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +var p = cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,s); +if((n === cljs.core.count(p))){ +return cljs.core.cons(p,cljs.core.partition.cljs$core$IFn$_invoke$arity$3(n,step,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step,s))); +} else { +return null; +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.partition.cljs$core$IFn$_invoke$arity$4 = (function (n,step,pad,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +var p = cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,s); +if((n === cljs.core.count(p))){ +return cljs.core.cons(p,cljs.core.partition.cljs$core$IFn$_invoke$arity$4(n,step,pad,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step,s))); +} else { +return (new cljs.core.List(null,cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(p,pad)),null,(1),null)); +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.partition.cljs$lang$maxFixedArity = 4; + +/** + * Returns the value in a nested associative structure, + * where ks is a sequence of keys. Returns nil if the key is not present, + * or the not-found value if supplied. + */ +cljs.core.get_in = (function cljs$core$get_in(var_args){ +var G__1977 = arguments.length; +switch (G__1977) { +case 2: +return cljs.core.get_in.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.get_in.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.get_in.cljs$core$IFn$_invoke$arity$2 = (function (m,ks){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.get,m,ks); +}); + +cljs.core.get_in.cljs$core$IFn$_invoke$arity$3 = (function (m,ks,not_found){ +var sentinel = cljs.core.lookup_sentinel; +var m__$1 = m; +var ks__$1 = cljs.core.seq(ks); +while(true){ +if(!((ks__$1 == null))){ +var m__$2 = cljs.core.get.cljs$core$IFn$_invoke$arity$3(m__$1,cljs.core.first(ks__$1),sentinel); +if((sentinel === m__$2)){ +return not_found; +} else { +var G__1979 = sentinel; +var G__1980 = m__$2; +var G__1981 = cljs.core.next(ks__$1); +sentinel = G__1979; +m__$1 = G__1980; +ks__$1 = G__1981; +continue; +} +} else { +return m__$1; +} +break; +} +}); + +cljs.core.get_in.cljs$lang$maxFixedArity = 3; + +/** + * Associates a value in a nested associative structure, where ks is a + * sequence of keys and v is the new value and returns a new nested structure. + * If any levels do not exist, hash-maps will be created. + */ +cljs.core.assoc_in = (function cljs$core$assoc_in(m,p__1982,v){ +var vec__1983 = p__1982; +var seq__1984 = cljs.core.seq(vec__1983); +var first__1985 = cljs.core.first(seq__1984); +var seq__1984__$1 = cljs.core.next(seq__1984); +var k = first__1985; +var ks = seq__1984__$1; +if(ks){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__1986 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__1987 = ks; +var G__1988 = v; +return (cljs.core.assoc_in.cljs$core$IFn$_invoke$arity$3 ? cljs.core.assoc_in.cljs$core$IFn$_invoke$arity$3(G__1986,G__1987,G__1988) : cljs.core.assoc_in.call(null,G__1986,G__1987,G__1988)); +})()); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v); +} +}); +/** + * 'Updates' a value in a nested associative structure, where ks is a + * sequence of keys and f is a function that will take the old value + * and any supplied args and return the new value, and returns a new + * nested structure. If any levels do not exist, hash-maps will be + * created. + */ +cljs.core.update_in = (function cljs$core$update_in(var_args){ +var G__1997 = arguments.length; +switch (G__1997) { +case 3: +return cljs.core.update_in.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.update_in.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.update_in.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +case 6: +return cljs.core.update_in.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___2029 = arguments.length; +var i__4519__auto___2030 = (0); +while(true){ +if((i__4519__auto___2030 < len__4518__auto___2029)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___2030])); + +var G__2031 = (i__4519__auto___2030 + (1)); +i__4519__auto___2030 = G__2031; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((6)),(0),null)); +return cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__4534__auto__); + +} +}); + +cljs.core.update_in.cljs$core$IFn$_invoke$arity$3 = (function (m,p__1998,f){ +var vec__1999 = p__1998; +var seq__2000 = cljs.core.seq(vec__1999); +var first__2001 = cljs.core.first(seq__2000); +var seq__2000__$1 = cljs.core.next(seq__2000); +var k = first__2001; +var ks = seq__2000__$1; +if(ks){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),ks,f)); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2002 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__2002) : f.call(null,G__2002)); +})()); +} +}); + +cljs.core.update_in.cljs$core$IFn$_invoke$arity$4 = (function (m,p__2003,f,a){ +var vec__2004 = p__2003; +var seq__2005 = cljs.core.seq(vec__2004); +var first__2006 = cljs.core.first(seq__2005); +var seq__2005__$1 = cljs.core.next(seq__2005); +var k = first__2006; +var ks = seq__2005__$1; +if(ks){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.update_in.cljs$core$IFn$_invoke$arity$4(cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),ks,f,a)); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2007 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2008 = a; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2007,G__2008) : f.call(null,G__2007,G__2008)); +})()); +} +}); + +cljs.core.update_in.cljs$core$IFn$_invoke$arity$5 = (function (m,p__2009,f,a,b){ +var vec__2010 = p__2009; +var seq__2011 = cljs.core.seq(vec__2010); +var first__2012 = cljs.core.first(seq__2011); +var seq__2011__$1 = cljs.core.next(seq__2011); +var k = first__2012; +var ks = seq__2011__$1; +if(ks){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.update_in.cljs$core$IFn$_invoke$arity$5(cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),ks,f,a,b)); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2013 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2014 = a; +var G__2015 = b; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2013,G__2014,G__2015) : f.call(null,G__2013,G__2014,G__2015)); +})()); +} +}); + +cljs.core.update_in.cljs$core$IFn$_invoke$arity$6 = (function (m,p__2016,f,a,b,c){ +var vec__2017 = p__2016; +var seq__2018 = cljs.core.seq(vec__2017); +var first__2019 = cljs.core.first(seq__2018); +var seq__2018__$1 = cljs.core.next(seq__2018); +var k = first__2019; +var ks = seq__2018__$1; +if(ks){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.update_in.cljs$core$IFn$_invoke$arity$6(cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),ks,f,a,b,c)); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2020 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2021 = a; +var G__2022 = b; +var G__2023 = c; +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__2020,G__2021,G__2022,G__2023) : f.call(null,G__2020,G__2021,G__2022,G__2023)); +})()); +} +}); + +cljs.core.update_in.cljs$core$IFn$_invoke$arity$variadic = (function (m,p__2024,f,a,b,c,args){ +var vec__2025 = p__2024; +var seq__2026 = cljs.core.seq(vec__2025); +var first__2027 = cljs.core.first(seq__2026); +var seq__2026__$1 = cljs.core.next(seq__2026); +var k = first__2027; +var ks = seq__2026__$1; +if(ks){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(cljs.core.update_in,cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),ks,f,a,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([b,c,args], 0))); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),a,b,c,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([args], 0))); +} +}); + +/** @this {Function} */ +cljs.core.update_in.cljs$lang$applyTo = (function (seq1990){ +var G__1991 = cljs.core.first(seq1990); +var seq1990__$1 = cljs.core.next(seq1990); +var G__1992 = cljs.core.first(seq1990__$1); +var seq1990__$2 = cljs.core.next(seq1990__$1); +var G__1993 = cljs.core.first(seq1990__$2); +var seq1990__$3 = cljs.core.next(seq1990__$2); +var G__1994 = cljs.core.first(seq1990__$3); +var seq1990__$4 = cljs.core.next(seq1990__$3); +var G__1995 = cljs.core.first(seq1990__$4); +var seq1990__$5 = cljs.core.next(seq1990__$4); +var G__1996 = cljs.core.first(seq1990__$5); +var seq1990__$6 = cljs.core.next(seq1990__$5); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1991,G__1992,G__1993,G__1994,G__1995,G__1996,seq1990__$6); +}); + +cljs.core.update_in.cljs$lang$maxFixedArity = (6); + +/** + * 'Updates' a value in an associative structure, where k is a + * key and f is a function that will take the old value + * and any supplied args and return the new value, and returns a new + * structure. If the key does not exist, nil is passed as the old value. + */ +cljs.core.update = (function cljs$core$update(var_args){ +var G__2040 = arguments.length; +switch (G__2040) { +case 3: +return cljs.core.update.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.update.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.update.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +case 6: +return cljs.core.update.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___2052 = arguments.length; +var i__4519__auto___2053 = (0); +while(true){ +if((i__4519__auto___2053 < len__4518__auto___2052)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___2053])); + +var G__2054 = (i__4519__auto___2053 + (1)); +i__4519__auto___2053 = G__2054; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((6)),(0),null)); +return cljs.core.update.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__4534__auto__); + +} +}); + +cljs.core.update.cljs$core$IFn$_invoke$arity$3 = (function (m,k,f){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2041 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__2041) : f.call(null,G__2041)); +})()); +}); + +cljs.core.update.cljs$core$IFn$_invoke$arity$4 = (function (m,k,f,x){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2042 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2043 = x; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2042,G__2043) : f.call(null,G__2042,G__2043)); +})()); +}); + +cljs.core.update.cljs$core$IFn$_invoke$arity$5 = (function (m,k,f,x,y){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2044 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2045 = x; +var G__2046 = y; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2044,G__2045,G__2046) : f.call(null,G__2044,G__2045,G__2046)); +})()); +}); + +cljs.core.update.cljs$core$IFn$_invoke$arity$6 = (function (m,k,f,x,y,z){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2047 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2048 = x; +var G__2049 = y; +var G__2050 = z; +return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__2047,G__2048,G__2049,G__2050) : f.call(null,G__2047,G__2048,G__2049,G__2050)); +})()); +}); + +cljs.core.update.cljs$core$IFn$_invoke$arity$variadic = (function (m,k,f,x,y,z,more){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),x,y,z,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([more], 0))); +}); + +/** @this {Function} */ +cljs.core.update.cljs$lang$applyTo = (function (seq2033){ +var G__2034 = cljs.core.first(seq2033); +var seq2033__$1 = cljs.core.next(seq2033); +var G__2035 = cljs.core.first(seq2033__$1); +var seq2033__$2 = cljs.core.next(seq2033__$1); +var G__2036 = cljs.core.first(seq2033__$2); +var seq2033__$3 = cljs.core.next(seq2033__$2); +var G__2037 = cljs.core.first(seq2033__$3); +var seq2033__$4 = cljs.core.next(seq2033__$3); +var G__2038 = cljs.core.first(seq2033__$4); +var seq2033__$5 = cljs.core.next(seq2033__$4); +var G__2039 = cljs.core.first(seq2033__$5); +var seq2033__$6 = cljs.core.next(seq2033__$5); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2034,G__2035,G__2036,G__2037,G__2038,G__2039,seq2033__$6); +}); + +cljs.core.update.cljs$lang$maxFixedArity = (6); + + +/** +* @constructor +*/ +cljs.core.VectorNode = (function (edit,arr){ +this.edit = edit; +this.arr = arr; +}); + +cljs.core.VectorNode.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$edit,cljs.core.cst$sym$arr], null); +}); + +cljs.core.VectorNode.cljs$lang$type = true; + +cljs.core.VectorNode.cljs$lang$ctorStr = "cljs.core/VectorNode"; + +cljs.core.VectorNode.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/VectorNode"); +}); + +/** + * Positional factory function for cljs.core/VectorNode. + */ +cljs.core.__GT_VectorNode = (function cljs$core$__GT_VectorNode(edit,arr){ +return (new cljs.core.VectorNode(edit,arr)); +}); + +cljs.core.pv_fresh_node = (function cljs$core$pv_fresh_node(edit){ +return (new cljs.core.VectorNode(edit,[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null])); +}); +cljs.core.pv_aget = (function cljs$core$pv_aget(node,idx){ +return (node.arr[idx]); +}); +cljs.core.pv_aset = (function cljs$core$pv_aset(node,idx,val){ +return (node.arr[idx] = val); +}); +cljs.core.pv_clone_node = (function cljs$core$pv_clone_node(node){ +return (new cljs.core.VectorNode(node.edit,cljs.core.aclone(node.arr))); +}); +cljs.core.tail_off = (function cljs$core$tail_off(pv){ +var cnt = pv.cnt; +if((cnt < (32))){ +return (0); +} else { +return (((cnt - (1)) >>> (5)) << (5)); +} +}); +cljs.core.new_path = (function cljs$core$new_path(edit,level,node){ +var ll = level; +var ret = node; +while(true){ +if((ll === (0))){ +return ret; +} else { +var embed = ret; +var r = cljs.core.pv_fresh_node(edit); +var _ = cljs.core.pv_aset(r,(0),embed); +var G__2055 = (ll - (5)); +var G__2056 = r; +ll = G__2055; +ret = G__2056; +continue; +} +break; +} +}); +cljs.core.push_tail = (function cljs$core$push_tail(pv,level,parent,tailnode){ +var ret = cljs.core.pv_clone_node(parent); +var subidx = (((pv.cnt - (1)) >>> level) & (31)); +if(((5) === level)){ +cljs.core.pv_aset(ret,subidx,tailnode); + +return ret; +} else { +var child = cljs.core.pv_aget(parent,subidx); +if(!((child == null))){ +var node_to_insert = (function (){var G__2057 = pv; +var G__2058 = (level - (5)); +var G__2059 = child; +var G__2060 = tailnode; +return (cljs.core.push_tail.cljs$core$IFn$_invoke$arity$4 ? cljs.core.push_tail.cljs$core$IFn$_invoke$arity$4(G__2057,G__2058,G__2059,G__2060) : cljs.core.push_tail.call(null,G__2057,G__2058,G__2059,G__2060)); +})(); +cljs.core.pv_aset(ret,subidx,node_to_insert); + +return ret; +} else { +var node_to_insert = cljs.core.new_path(null,(level - (5)),tailnode); +cljs.core.pv_aset(ret,subidx,node_to_insert); + +return ret; +} +} +}); +cljs.core.vector_index_out_of_bounds = (function cljs$core$vector_index_out_of_bounds(i,cnt){ +throw (new Error(["No item ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(i)," in vector of length ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cnt)].join(''))); +}); +cljs.core.first_array_for_longvec = (function cljs$core$first_array_for_longvec(pv){ +var node = pv.root; +var level = pv.shift; +while(true){ +if((level > (0))){ +var G__2061 = cljs.core.pv_aget(node,(0)); +var G__2062 = (level - (5)); +node = G__2061; +level = G__2062; +continue; +} else { +return node.arr; +} +break; +} +}); +cljs.core.unchecked_array_for = (function cljs$core$unchecked_array_for(pv,i){ +if((i >= cljs.core.tail_off(pv))){ +return pv.tail; +} else { +var node = pv.root; +var level = pv.shift; +while(true){ +if((level > (0))){ +var G__2063 = cljs.core.pv_aget(node,((i >>> level) & (31))); +var G__2064 = (level - (5)); +node = G__2063; +level = G__2064; +continue; +} else { +return node.arr; +} +break; +} +} +}); +cljs.core.array_for = (function cljs$core$array_for(pv,i){ +if(((((0) <= i)) && ((i < pv.cnt)))){ +return cljs.core.unchecked_array_for(pv,i); +} else { +return cljs.core.vector_index_out_of_bounds(i,pv.cnt); +} +}); +cljs.core.do_assoc = (function cljs$core$do_assoc(pv,level,node,i,val){ +var ret = cljs.core.pv_clone_node(node); +if((level === (0))){ +cljs.core.pv_aset(ret,(i & (31)),val); + +return ret; +} else { +var subidx = ((i >>> level) & (31)); +cljs.core.pv_aset(ret,subidx,(function (){var G__2065 = pv; +var G__2066 = (level - (5)); +var G__2067 = cljs.core.pv_aget(node,subidx); +var G__2068 = i; +var G__2069 = val; +return (cljs.core.do_assoc.cljs$core$IFn$_invoke$arity$5 ? cljs.core.do_assoc.cljs$core$IFn$_invoke$arity$5(G__2065,G__2066,G__2067,G__2068,G__2069) : cljs.core.do_assoc.call(null,G__2065,G__2066,G__2067,G__2068,G__2069)); +})()); + +return ret; +} +}); +cljs.core.pop_tail = (function cljs$core$pop_tail(pv,level,node){ +var subidx = (((pv.cnt - (2)) >>> level) & (31)); +if((level > (5))){ +var new_child = (function (){var G__2070 = pv; +var G__2071 = (level - (5)); +var G__2072 = cljs.core.pv_aget(node,subidx); +return (cljs.core.pop_tail.cljs$core$IFn$_invoke$arity$3 ? cljs.core.pop_tail.cljs$core$IFn$_invoke$arity$3(G__2070,G__2071,G__2072) : cljs.core.pop_tail.call(null,G__2070,G__2071,G__2072)); +})(); +if((((new_child == null)) && ((subidx === (0))))){ +return null; +} else { +var ret = cljs.core.pv_clone_node(node); +cljs.core.pv_aset(ret,subidx,new_child); + +return ret; +} +} else { +if((subidx === (0))){ +return null; +} else { +var ret = cljs.core.pv_clone_node(node); +cljs.core.pv_aset(ret,subidx,null); + +return ret; + +} +} +}); + +/** +* @constructor +*/ +cljs.core.RangedIterator = (function (i,base,arr,v,start,end){ +this.i = i; +this.base = base; +this.arr = arr; +this.v = v; +this.start = start; +this.end = end; +}); +cljs.core.RangedIterator.prototype.hasNext = (function (){ +var self__ = this; +var this$ = this; +return (self__.i < self__.end); +}); + +cljs.core.RangedIterator.prototype.next = (function (){ +var self__ = this; +var this$ = this; +if(((self__.i - self__.base) === (32))){ +self__.arr = cljs.core.unchecked_array_for(self__.v,self__.i); + +self__.base = (self__.base + (32)); +} else { +} + +var ret = (self__.arr[(self__.i & (31))]); +self__.i = (self__.i + (1)); + +return ret; +}); + +cljs.core.RangedIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$base,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$arr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$v,cljs.core.cst$sym$start,cljs.core.cst$sym$end], null); +}); + +cljs.core.RangedIterator.cljs$lang$type = true; + +cljs.core.RangedIterator.cljs$lang$ctorStr = "cljs.core/RangedIterator"; + +cljs.core.RangedIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/RangedIterator"); +}); + +/** + * Positional factory function for cljs.core/RangedIterator. + */ +cljs.core.__GT_RangedIterator = (function cljs$core$__GT_RangedIterator(i,base,arr,v,start,end){ +return (new cljs.core.RangedIterator(i,base,arr,v,start,end)); +}); + +cljs.core.ranged_iterator = (function cljs$core$ranged_iterator(v,start,end){ +var i = start; +return (new cljs.core.RangedIterator(i,(i - (i % (32))),(((start < cljs.core.count(v)))?cljs.core.unchecked_array_for(v,i):null),v,start,end)); +}); +cljs.core.pv_reduce = (function cljs$core$pv_reduce(var_args){ +var G__2074 = arguments.length; +switch (G__2074) { +case 4: +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4 = (function (pv,f,start,end){ +if((start < end)){ +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5(pv,f,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(pv,start),(start + (1)),end); +} else { +return (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +} +}); + +cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5 = (function (pv,f,init,start,end){ +var acc = init; +var i = start; +var arr = cljs.core.unchecked_array_for(pv,start); +while(true){ +if((i < end)){ +var j = (i & (31)); +var arr__$1 = (((j === (0)))?cljs.core.unchecked_array_for(pv,i):arr); +var nacc = (function (){var G__2075 = acc; +var G__2076 = (arr__$1[j]); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2075,G__2076) : f.call(null,G__2075,G__2076)); +})(); +if(cljs.core.reduced_QMARK_(nacc)){ +return cljs.core.deref(nacc); +} else { +var G__2078 = nacc; +var G__2079 = (i + (1)); +var G__2080 = arr__$1; +acc = G__2078; +i = G__2079; +arr = G__2080; +continue; +} +} else { +return acc; +} +break; +} +}); + +cljs.core.pv_reduce.cljs$lang$maxFixedArity = 5; + + + + + + + + +/** + * Marker protocol + * @interface + */ +cljs.core.APersistentVector = function(){}; + + +/** +* @constructor + * @implements {cljs.core.APersistentVector} + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IVector} + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IKVReduce} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEditableCollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IStack} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.ILookup} + * @implements {cljs.core.IReduce} +*/ +cljs.core.PersistentVector = (function (meta,cnt,shift,root,tail,__hash){ +this.meta = meta; +this.cnt = cnt; +this.shift = shift; +this.root = root; +this.tail = tail; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 167666463; +this.cljs$lang$protocol_mask$partition1$ = 139268; +}); +cljs.core.PersistentVector.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentVector.prototype.cljs$core$IFind$_find$arity$2 = (function (coll,n){ +var self__ = this; +var coll__$1 = this; +if(((((0) <= n)) && ((n < self__.cnt)))){ +return (new cljs.core.MapEntry(n,(cljs.core.unchecked_array_for(coll__$1,n)[(n & (31))]),null)); +} else { +return null; +} +}); + +cljs.core.PersistentVector.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentVector.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentVector.prototype.indexOf = (function() { +var G__2087 = null; +var G__2087__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2087__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2087 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2087__1.call(this,x); +case 2: +return G__2087__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2087.cljs$core$IFn$_invoke$arity$1 = G__2087__1; +G__2087.cljs$core$IFn$_invoke$arity$2 = G__2087__2; +return G__2087; +})() +; + +cljs.core.PersistentVector.prototype.lastIndexOf = (function() { +var G__2088 = null; +var G__2088__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2088__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2088 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2088__1.call(this,x); +case 2: +return G__2088__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2088.cljs$core$IFn$_invoke$arity$1 = G__2088__1; +G__2088.cljs$core$IFn$_invoke$arity$2 = G__2088__2; +return G__2088; +})() +; + +cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +if(typeof k === 'number'){ +return coll__$1.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +} else { +return not_found; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = (function (v,f,init){ +var self__ = this; +var v__$1 = this; +var i = (0); +var init__$1 = init; +while(true){ +if((i < self__.cnt)){ +var arr = cljs.core.unchecked_array_for(v__$1,i); +var len = arr.length; +var init__$2 = (function (){var j = (0); +var init__$2 = init__$1; +while(true){ +if((j < len)){ +var init__$3 = (function (){var G__2082 = init__$2; +var G__2083 = (j + i); +var G__2084 = (arr[j]); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2082,G__2083,G__2084) : f.call(null,G__2082,G__2083,G__2084)); +})(); +if(cljs.core.reduced_QMARK_(init__$3)){ +return init__$3; +} else { +var G__2089 = (j + (1)); +var G__2090 = init__$3; +j = G__2089; +init__$2 = G__2090; +continue; +} +} else { +return init__$2; +} +break; +} +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return cljs.core.deref(init__$2); +} else { +var G__2091 = (i + len); +var G__2092 = init__$2; +i = G__2091; +init__$1 = G__2092; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$APersistentVector$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (coll,n){ +var self__ = this; +var coll__$1 = this; +return (cljs.core.array_for(coll__$1,n)[(n & (31))]); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (coll,n,not_found){ +var self__ = this; +var coll__$1 = this; +if(((((0) <= n)) && ((n < self__.cnt)))){ +return (cljs.core.unchecked_array_for(coll__$1,n)[(n & (31))]); +} else { +return not_found; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IVector$_assoc_n$arity$3 = (function (coll,n,val){ +var self__ = this; +var coll__$1 = this; +if(((((0) <= n)) && ((n < self__.cnt)))){ +if((cljs.core.tail_off(coll__$1) <= n)){ +var new_tail = cljs.core.aclone(self__.tail); +(new_tail[(n & (31))] = val); + +return (new cljs.core.PersistentVector(self__.meta,self__.cnt,self__.shift,self__.root,new_tail,null)); +} else { +return (new cljs.core.PersistentVector(self__.meta,self__.cnt,self__.shift,cljs.core.do_assoc(coll__$1,self__.shift,self__.root,n,val),self__.tail,null)); +} +} else { +if((n === self__.cnt)){ +return coll__$1.cljs$core$ICollection$_conj$arity$2(null,val); +} else { +throw (new Error(["Index ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)," out of bounds [0,",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.cnt),"]"].join(''))); + +} +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return cljs.core.ranged_iterator(this$__$1,(0),self__.cnt); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentVector.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.PersistentVector(self__.meta,self__.cnt,self__.shift,self__.root,self__.tail,self__.__hash)); +}); + +cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.cnt; +}); + +cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +return coll__$1.cljs$core$IIndexed$_nth$arity$2(null,(self__.cnt - (1))); +} else { +return null; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IStack$_pop$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt === (0))){ +throw (new Error("Can't pop empty vector")); +} else { +if(((1) === self__.cnt)){ +return cljs.core._with_meta(cljs.core.PersistentVector.EMPTY,self__.meta); +} else { +if(((1) < (self__.cnt - cljs.core.tail_off(coll__$1)))){ +return (new cljs.core.PersistentVector(self__.meta,(self__.cnt - (1)),self__.shift,self__.root,self__.tail.slice((0),(-1)),null)); +} else { +var new_tail = cljs.core.unchecked_array_for(coll__$1,(self__.cnt - (2))); +var nr = cljs.core.pop_tail(coll__$1,self__.shift,self__.root); +var new_root = (((nr == null))?cljs.core.PersistentVector.EMPTY_NODE:nr); +var cnt_1 = (self__.cnt - (1)); +if(((((5) < self__.shift)) && ((cljs.core.pv_aget(new_root,(1)) == null)))){ +return (new cljs.core.PersistentVector(self__.meta,cnt_1,(self__.shift - (5)),cljs.core.pv_aget(new_root,(0)),new_tail,null)); +} else { +return (new cljs.core.PersistentVector(self__.meta,cnt_1,self__.shift,new_root,new_tail,null)); +} + +} +} +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +return (new cljs.core.RSeq(coll__$1,(self__.cnt - (1)),null)); +} else { +return null; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +if((other instanceof cljs.core.PersistentVector)){ +if((self__.cnt === cljs.core.count(other))){ +var me_iter = coll__$1.cljs$core$IIterable$_iterator$arity$1(null); +var you_iter = cljs.core._iterator(other); +while(true){ +if(me_iter.hasNext()){ +var x = me_iter.next(); +var y = you_iter.next(); +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,y)){ +continue; +} else { +return false; +} +} else { +return true; +} +break; +} +} else { +return false; +} +} else { +return cljs.core.equiv_sequential(coll__$1,other); +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.TransientVector(self__.cnt,self__.shift,cljs.core.tv_editable_root(self__.root),cljs.core.tv_editable_tail(self__.tail))); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.PersistentVector.EMPTY,self__.meta); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (v,f){ +var self__ = this; +var v__$1 = this; +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4(v__$1,f,(0),self__.cnt); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (v,f,init){ +var self__ = this; +var v__$1 = this; +var i = (0); +var init__$1 = init; +while(true){ +if((i < self__.cnt)){ +var arr = cljs.core.unchecked_array_for(v__$1,i); +var len = arr.length; +var init__$2 = (function (){var j = (0); +var init__$2 = init__$1; +while(true){ +if((j < len)){ +var init__$3 = (function (){var G__2085 = init__$2; +var G__2086 = (arr[j]); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2085,G__2086) : f.call(null,G__2085,G__2086)); +})(); +if(cljs.core.reduced_QMARK_(init__$3)){ +return init__$3; +} else { +var G__2093 = (j + (1)); +var G__2094 = init__$3; +j = G__2093; +init__$2 = G__2094; +continue; +} +} else { +return init__$2; +} +break; +} +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return cljs.core.deref(init__$2); +} else { +var G__2095 = (i + len); +var G__2096 = init__$2; +i = G__2095; +init__$1 = G__2096; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (coll,k,v){ +var self__ = this; +var coll__$1 = this; +if(typeof k === 'number'){ +return coll__$1.cljs$core$IVector$_assoc_n$arity$3(null,k,v); +} else { +throw (new Error("Vector's key for assoc must be a number.")); +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.integer_QMARK_(k)){ +return ((((0) <= k)) && ((k < self__.cnt))); +} else { +return false; +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt === (0))){ +return null; +} else { +if((self__.cnt <= (32))){ +return (new cljs.core.IndexedSeq(self__.tail,(0),null)); +} else { +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(coll__$1,cljs.core.first_array_for_longvec(coll__$1),(0),(0)); + +} +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentVector(meta__$1,self__.cnt,self__.shift,self__.root,self__.tail,self__.__hash)); +}); + +cljs.core.PersistentVector.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +if(((self__.cnt - cljs.core.tail_off(coll__$1)) < (32))){ +var len = self__.tail.length; +var new_tail = (new Array((len + (1)))); +var n__4395__auto___2097 = len; +var i_2098 = (0); +while(true){ +if((i_2098 < n__4395__auto___2097)){ +(new_tail[i_2098] = (self__.tail[i_2098])); + +var G__2099 = (i_2098 + (1)); +i_2098 = G__2099; +continue; +} else { +} +break; +} + +(new_tail[len] = o); + +return (new cljs.core.PersistentVector(self__.meta,(self__.cnt + (1)),self__.shift,self__.root,new_tail,null)); +} else { +var root_overflow_QMARK_ = ((self__.cnt >>> (5)) > ((1) << self__.shift)); +var new_shift = ((root_overflow_QMARK_)?(self__.shift + (5)):self__.shift); +var new_root = ((root_overflow_QMARK_)?(function (){var n_r = cljs.core.pv_fresh_node(null); +cljs.core.pv_aset(n_r,(0),self__.root); + +cljs.core.pv_aset(n_r,(1),cljs.core.new_path(null,self__.shift,(new cljs.core.VectorNode(null,self__.tail)))); + +return n_r; +})():cljs.core.push_tail(coll__$1,self__.shift,self__.root,(new cljs.core.VectorNode(null,self__.tail)))); +return (new cljs.core.PersistentVector(self__.meta,(self__.cnt + (1)),new_shift,new_root,[o],null)); +} +}); + +cljs.core.PersistentVector.prototype.call = (function() { +var G__2100 = null; +var G__2100__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$IIndexed$_nth$arity$2(null,k); +}); +var G__2100__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); +G__2100 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2100__2.call(this,self__,k); +case 3: +return G__2100__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2100.cljs$core$IFn$_invoke$arity$2 = G__2100__2; +G__2100.cljs$core$IFn$_invoke$arity$3 = G__2100__3; +return G__2100; +})() +; + +cljs.core.PersistentVector.prototype.apply = (function (self__,args2081){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2081))); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$IIndexed$_nth$arity$2(null,k); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.PersistentVector.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$cnt,cljs.core.cst$sym$shift,cljs.core.cst$sym$root,cljs.core.cst$sym$tail,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentVector.cljs$lang$type = true; + +cljs.core.PersistentVector.cljs$lang$ctorStr = "cljs.core/PersistentVector"; + +cljs.core.PersistentVector.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentVector"); +}); + +/** + * Positional factory function for cljs.core/PersistentVector. + */ +cljs.core.__GT_PersistentVector = (function cljs$core$__GT_PersistentVector(meta,cnt,shift,root,tail,__hash){ +return (new cljs.core.PersistentVector(meta,cnt,shift,root,tail,__hash)); +}); + +cljs.core.PersistentVector.EMPTY_NODE = (new cljs.core.VectorNode(null,[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null])); +cljs.core.PersistentVector.EMPTY = (new cljs.core.PersistentVector(null,(0),(5),cljs.core.PersistentVector.EMPTY_NODE,[],cljs.core.empty_ordered_hash)); +cljs.core.PersistentVector.fromArray = (function (xs,no_clone){ +var l = xs.length; +var xs__$1 = ((no_clone)?xs:cljs.core.aclone(xs)); +if((l < (32))){ +return (new cljs.core.PersistentVector(null,l,(5),cljs.core.PersistentVector.EMPTY_NODE,xs__$1,null)); +} else { +var node = xs__$1.slice((0),(32)); +var v = (new cljs.core.PersistentVector(null,(32),(5),cljs.core.PersistentVector.EMPTY_NODE,node,null)); +var i = (32); +var out = v.cljs$core$IEditableCollection$_as_transient$arity$1(null); +while(true){ +if((i < l)){ +var G__2101 = (i + (1)); +var G__2102 = cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(out,(xs__$1[i])); +i = G__2101; +out = G__2102; +continue; +} else { +return cljs.core.persistent_BANG_(out); +} +break; +} +} +}); +var G__2103_2106 = cljs.core.PersistentVector.prototype; +var G__2104_2107 = cljs.core.ITER_SYMBOL; +var G__2105_2108 = ((function (G__2103_2106,G__2104_2107){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2103_2106,G__2104_2107)) +; +goog.object.set(G__2103_2106,G__2104_2107,G__2105_2108); +/** + * Creates a new vector containing the contents of coll. JavaScript arrays + * will be aliased and should not be modified. + */ +cljs.core.vec = (function cljs$core$vec(coll){ +if(cljs.core.array_QMARK_(coll)){ +return cljs.core.PersistentVector.fromArray(coll,true); +} else { +return cljs.core._persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj_BANG_,cljs.core._as_transient(cljs.core.PersistentVector.EMPTY),coll)); +} +}); +/** + * Creates a new vector containing the args. + */ +cljs.core.vector = (function cljs$core$vector(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2110 = arguments.length; +var i__4519__auto___2111 = (0); +while(true){ +if((i__4519__auto___2111 < len__4518__auto___2110)){ +args__4521__auto__.push((arguments[i__4519__auto___2111])); + +var G__2112 = (i__4519__auto___2111 + (1)); +i__4519__auto___2111 = G__2112; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.vector.cljs$core$IFn$_invoke$arity$variadic = (function (args){ +if((((args instanceof cljs.core.IndexedSeq)) && ((args.i === (0))))){ +return cljs.core.PersistentVector.fromArray(args.arr,true); +} else { +return cljs.core.vec(args); +} +}); + +cljs.core.vector.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.vector.cljs$lang$applyTo = (function (seq2109){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2109)); +}); + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ASeq} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IChunkedNext} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IChunkedSeq} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.ChunkedSeq = (function (vec,node,i,off,meta,__hash){ +this.vec = vec; +this.node = node; +this.i = i; +this.off = off; +this.meta = meta; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32375020; +this.cljs$lang$protocol_mask$partition1$ = 1536; +}); +cljs.core.ChunkedSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.ChunkedSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.ChunkedSeq.prototype.indexOf = (function() { +var G__2113 = null; +var G__2113__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2113__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2113 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2113__1.call(this,x); +case 2: +return G__2113__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2113.cljs$core$IFn$_invoke$arity$1 = G__2113__1; +G__2113.cljs$core$IFn$_invoke$arity$2 = G__2113__2; +return G__2113; +})() +; + +cljs.core.ChunkedSeq.prototype.lastIndexOf = (function() { +var G__2114 = null; +var G__2114__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2114__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2114 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2114__1.call(this,x); +case 2: +return G__2114__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2114.cljs$core$IFn$_invoke$arity$1 = G__2114__1; +G__2114.cljs$core$IFn$_invoke$arity$2 = G__2114__2; +return G__2114; +})() +; + +cljs.core.ChunkedSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(((self__.off + (1)) < self__.node.length)){ +var s = cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(self__.vec,self__.node,self__.i,(self__.off + (1))); +if((s == null)){ +return null; +} else { +return s; +} +} else { +return coll__$1.cljs$core$IChunkedNext$_chunked_next$arity$1(null); +} +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.List.EMPTY; +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4(self__.vec,f,(self__.i + self__.off),cljs.core.count(self__.vec)); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5(self__.vec,f,start,(self__.i + self__.off),cljs.core.count(self__.vec)); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (self__.node[self__.off]); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(((self__.off + (1)) < self__.node.length)){ +var s = cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(self__.vec,self__.node,self__.i,(self__.off + (1))); +if((s == null)){ +return cljs.core.List.EMPTY; +} else { +return s; +} +} else { +return coll__$1.cljs$core$IChunkedSeq$_chunked_rest$arity$1(null); +} +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.array_chunk.cljs$core$IFn$_invoke$arity$2(self__.node,self__.off); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var end = (self__.i + self__.node.length); +if((end < cljs.core._count(self__.vec))){ +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(self__.vec,cljs.core.unchecked_array_for(self__.vec,end),end,(0)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,m){ +var self__ = this; +var coll__$1 = this; +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5(self__.vec,self__.node,self__.i,self__.off,m); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var end = (self__.i + self__.node.length); +if((end < cljs.core._count(self__.vec))){ +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4(self__.vec,cljs.core.unchecked_array_for(self__.vec,end),end,(0)); +} else { +return null; +} +}); + +cljs.core.ChunkedSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$vec,cljs.core.cst$sym$node,cljs.core.cst$sym$i,cljs.core.cst$sym$off,cljs.core.cst$sym$meta,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ChunkedSeq.cljs$lang$type = true; + +cljs.core.ChunkedSeq.cljs$lang$ctorStr = "cljs.core/ChunkedSeq"; + +cljs.core.ChunkedSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ChunkedSeq"); +}); + +/** + * Positional factory function for cljs.core/ChunkedSeq. + */ +cljs.core.__GT_ChunkedSeq = (function cljs$core$__GT_ChunkedSeq(vec,node,i,off,meta,__hash){ +return (new cljs.core.ChunkedSeq(vec,node,i,off,meta,__hash)); +}); + +var G__2115_2118 = cljs.core.ChunkedSeq.prototype; +var G__2116_2119 = cljs.core.ITER_SYMBOL; +var G__2117_2120 = ((function (G__2115_2118,G__2116_2119){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2115_2118,G__2116_2119)) +; +goog.object.set(G__2115_2118,G__2116_2119,G__2117_2120); +cljs.core.chunked_seq = (function cljs$core$chunked_seq(var_args){ +var G__2122 = arguments.length; +switch (G__2122) { +case 3: +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 4: +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$3 = (function (vec,i,off){ +return (new cljs.core.ChunkedSeq(vec,cljs.core.array_for(vec,i),i,off,null,null)); +}); + +cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$4 = (function (vec,node,i,off){ +return (new cljs.core.ChunkedSeq(vec,node,i,off,null,null)); +}); + +cljs.core.chunked_seq.cljs$core$IFn$_invoke$arity$5 = (function (vec,node,i,off,meta){ +return (new cljs.core.ChunkedSeq(vec,node,i,off,meta,null)); +}); + +cljs.core.chunked_seq.cljs$lang$maxFixedArity = 5; + + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IVector} + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IKVReduce} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IStack} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.ILookup} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Subvec = (function (meta,v,start,end,__hash){ +this.meta = meta; +this.v = v; +this.start = start; +this.end = end; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 167666463; +this.cljs$lang$protocol_mask$partition1$ = 139264; +}); +cljs.core.Subvec.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Subvec.prototype.cljs$core$IFind$_find$arity$2 = (function (coll,n){ +var self__ = this; +var coll__$1 = this; +if((n < (0))){ +return null; +} else { +var idx = (self__.start + n); +if((idx < self__.end)){ +return (new cljs.core.MapEntry(n,cljs.core._lookup.cljs$core$IFn$_invoke$arity$2(self__.v,idx),null)); +} else { +return null; +} +} +}); + +cljs.core.Subvec.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.Subvec.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Subvec.prototype.indexOf = (function() { +var G__2131 = null; +var G__2131__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2131__2 = (function (x,start__$1){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1); +}); +G__2131 = function(x,start__$1){ +switch(arguments.length){ +case 1: +return G__2131__1.call(this,x); +case 2: +return G__2131__2.call(this,x,start__$1); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2131.cljs$core$IFn$_invoke$arity$1 = G__2131__1; +G__2131.cljs$core$IFn$_invoke$arity$2 = G__2131__2; +return G__2131; +})() +; + +cljs.core.Subvec.prototype.lastIndexOf = (function() { +var G__2132 = null; +var G__2132__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2132__2 = (function (x,start__$1){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1); +}); +G__2132 = function(x,start__$1){ +switch(arguments.length){ +case 1: +return G__2132__1.call(this,x); +case 2: +return G__2132__2.call(this,x,start__$1); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2132.cljs$core$IFn$_invoke$arity$1 = G__2132__1; +G__2132.cljs$core$IFn$_invoke$arity$2 = G__2132__2; +return G__2132; +})() +; + +cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +if(typeof k === 'number'){ +return coll__$1.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +} else { +return not_found; +} +}); + +cljs.core.Subvec.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = (function (coll,f,init){ +var self__ = this; +var coll__$1 = this; +var i = self__.start; +var j = (0); +var init__$1 = init; +while(true){ +if((i < self__.end)){ +var init__$2 = (function (){var G__2125 = init__$1; +var G__2126 = j; +var G__2127 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.v,i); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2125,G__2126,G__2127) : f.call(null,G__2125,G__2126,G__2127)); +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return cljs.core.deref(init__$2); +} else { +var G__2133 = (i + (1)); +var G__2134 = (j + (1)); +var G__2135 = init__$2; +i = G__2133; +j = G__2134; +init__$1 = G__2135; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (coll,n){ +var self__ = this; +var coll__$1 = this; +if((((n < (0))) || ((self__.end <= (self__.start + n))))){ +return cljs.core.vector_index_out_of_bounds(n,(self__.end - self__.start)); +} else { +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.v,(self__.start + n)); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (coll,n,not_found){ +var self__ = this; +var coll__$1 = this; +if((((n < (0))) || ((self__.end <= (self__.start + n))))){ +return not_found; +} else { +return cljs.core._nth.cljs$core$IFn$_invoke$arity$3(self__.v,(self__.start + n),not_found); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IVector$_assoc_n$arity$3 = (function (coll,n,val){ +var self__ = this; +var coll__$1 = this; +var v_pos = (self__.start + n); +if((((n < (0))) || (((self__.end + (1)) <= v_pos)))){ +throw (new Error(["Index ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)," out of bounds [0,",cljs.core.str.cljs$core$IFn$_invoke$arity$1(coll__$1.cljs$core$ICounted$_count$arity$1(null)),"]"].join(''))); +} else { +return cljs.core.build_subvec(self__.meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.v,v_pos,val),self__.start,(function (){var x__4024__auto__ = self__.end; +var y__4025__auto__ = (v_pos + (1)); +return ((x__4024__auto__ > y__4025__auto__) ? x__4024__auto__ : y__4025__auto__); +})(),null); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(((!((self__.v == null)))?((((false) || ((cljs.core.PROTOCOL_SENTINEL === self__.v.cljs$core$APersistentVector$))))?true:false):false)){ +return cljs.core.ranged_iterator(self__.v,self__.start,self__.end); +} else { +return cljs.core.seq_iter(coll__$1); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.Subvec.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.Subvec(self__.meta,self__.v,self__.start,self__.end,self__.__hash)); +}); + +cljs.core.Subvec.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (self__.end - self__.start); +}); + +cljs.core.Subvec.prototype.cljs$core$IStack$_peek$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.v,(self__.end - (1))); +}); + +cljs.core.Subvec.prototype.cljs$core$IStack$_pop$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.start === self__.end)){ +throw (new Error("Can't pop empty vector")); +} else { +return cljs.core.build_subvec(self__.meta,self__.v,self__.start,(self__.end - (1)),null); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(!((self__.start === self__.end))){ +return (new cljs.core.RSeq(coll__$1,((self__.end - self__.start) - (1)),null)); +} else { +return null; +} +}); + +cljs.core.Subvec.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.Subvec.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.PersistentVector.EMPTY,self__.meta); +}); + +cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +if(((!((self__.v == null)))?((((false) || ((cljs.core.PROTOCOL_SENTINEL === self__.v.cljs$core$APersistentVector$))))?true:false):false)){ +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$4(self__.v,f,self__.start,self__.end); +} else { +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(coll__$1,f); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,init){ +var self__ = this; +var coll__$1 = this; +if(((!((self__.v == null)))?((((false) || ((cljs.core.PROTOCOL_SENTINEL === self__.v.cljs$core$APersistentVector$))))?true:false):false)){ +return cljs.core.pv_reduce.cljs$core$IFn$_invoke$arity$5(self__.v,f,init,self__.start,self__.end); +} else { +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(coll__$1,f,init); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (coll,key,val){ +var self__ = this; +var coll__$1 = this; +if(typeof key === 'number'){ +return coll__$1.cljs$core$IVector$_assoc_n$arity$3(null,key,val); +} else { +throw (new Error("Subvec's key for assoc must be a number.")); +} +}); + +cljs.core.Subvec.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var subvec_seq = ((function (coll__$1){ +return (function cljs$core$subvec_seq(i){ +if((i === self__.end)){ +return null; +} else { +return cljs.core.cons(cljs.core._nth.cljs$core$IFn$_invoke$arity$2(self__.v,i),(new cljs.core.LazySeq(null,((function (coll__$1){ +return (function (){ +return cljs$core$subvec_seq((i + (1))); +});})(coll__$1)) +,null,null))); +} +});})(coll__$1)) +; +return subvec_seq(self__.start); +}); + +cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return cljs.core.build_subvec(meta__$1,self__.v,self__.start,self__.end,self__.__hash); +}); + +cljs.core.Subvec.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.build_subvec(self__.meta,cljs.core._assoc_n(self__.v,self__.end,o),self__.start,(self__.end + (1)),null); +}); + +cljs.core.Subvec.prototype.call = (function() { +var G__2136 = null; +var G__2136__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$IIndexed$_nth$arity$2(null,k); +}); +var G__2136__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); +G__2136 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2136__2.call(this,self__,k); +case 3: +return G__2136__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2136.cljs$core$IFn$_invoke$arity$2 = G__2136__2; +G__2136.cljs$core$IFn$_invoke$arity$3 = G__2136__3; +return G__2136; +})() +; + +cljs.core.Subvec.prototype.apply = (function (self__,args2124){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2124))); +}); + +cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$IIndexed$_nth$arity$2(null,k); +}); + +cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.Subvec.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$v,cljs.core.cst$sym$start,cljs.core.cst$sym$end,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Subvec.cljs$lang$type = true; + +cljs.core.Subvec.cljs$lang$ctorStr = "cljs.core/Subvec"; + +cljs.core.Subvec.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Subvec"); +}); + +/** + * Positional factory function for cljs.core/Subvec. + */ +cljs.core.__GT_Subvec = (function cljs$core$__GT_Subvec(meta,v,start,end,__hash){ +return (new cljs.core.Subvec(meta,v,start,end,__hash)); +}); + +var G__2137_2140 = cljs.core.Subvec.prototype; +var G__2138_2141 = cljs.core.ITER_SYMBOL; +var G__2139_2142 = ((function (G__2137_2140,G__2138_2141){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2137_2140,G__2138_2141)) +; +goog.object.set(G__2137_2140,G__2138_2141,G__2139_2142); +cljs.core.build_subvec = (function cljs$core$build_subvec(meta,v,start,end,__hash){ +while(true){ +if((v instanceof cljs.core.Subvec)){ +var G__2143 = meta; +var G__2144 = v.v; +var G__2145 = (v.start + start); +var G__2146 = (v.start + end); +var G__2147 = __hash; +meta = G__2143; +v = G__2144; +start = G__2145; +end = G__2146; +__hash = G__2147; +continue; +} else { +if(cljs.core.vector_QMARK_(v)){ +} else { +throw (new Error("v must satisfy IVector")); +} + +var c_2148 = cljs.core.count(v); +if((((start < (0))) || ((end < (0))) || ((start > c_2148)) || ((end > c_2148)))){ +throw (new Error("Index out of bounds")); +} else { +} + +return (new cljs.core.Subvec(meta,v,start,end,__hash)); +} +break; +} +}); +/** + * Returns a persistent vector of the items in vector from + * start (inclusive) to end (exclusive). If end is not supplied, + * defaults to (count vector). This operation is O(1) and very fast, as + * the resulting vector shares structure with the original and no + * trimming is done. + */ +cljs.core.subvec = (function cljs$core$subvec(var_args){ +var G__2150 = arguments.length; +switch (G__2150) { +case 2: +return cljs.core.subvec.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.subvec.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.subvec.cljs$core$IFn$_invoke$arity$2 = (function (v,start){ +return cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(v,start,cljs.core.count(v)); +}); + +cljs.core.subvec.cljs$core$IFn$_invoke$arity$3 = (function (v,start,end){ +if(((!((start == null))) && (!((end == null))))){ +} else { +throw (new Error("Assert failed: (and (not (nil? start)) (not (nil? end)))")); +} + +return cljs.core.build_subvec(null,v,(start | (0)),(end | (0)),null); +}); + +cljs.core.subvec.cljs$lang$maxFixedArity = 3; + +cljs.core.tv_ensure_editable = (function cljs$core$tv_ensure_editable(edit,node){ +if((edit === node.edit)){ +return node; +} else { +return (new cljs.core.VectorNode(edit,cljs.core.aclone(node.arr))); +} +}); +cljs.core.tv_editable_root = (function cljs$core$tv_editable_root(node){ +return (new cljs.core.VectorNode({},cljs.core.aclone(node.arr))); +}); +cljs.core.tv_editable_tail = (function cljs$core$tv_editable_tail(tl){ +var ret = [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]; +cljs.core.array_copy(tl,(0),ret,(0),tl.length); + +return ret; +}); +cljs.core.tv_push_tail = (function cljs$core$tv_push_tail(tv,level,parent,tail_node){ +var ret = cljs.core.tv_ensure_editable(tv.root.edit,parent); +var subidx = (((tv.cnt - (1)) >>> level) & (31)); +cljs.core.pv_aset(ret,subidx,(((level === (5)))?tail_node:(function (){var child = cljs.core.pv_aget(ret,subidx); +if(!((child == null))){ +var G__2154 = tv; +var G__2155 = (level - (5)); +var G__2156 = child; +var G__2157 = tail_node; +return (cljs.core.tv_push_tail.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tv_push_tail.cljs$core$IFn$_invoke$arity$4(G__2154,G__2155,G__2156,G__2157) : cljs.core.tv_push_tail.call(null,G__2154,G__2155,G__2156,G__2157)); +} else { +return cljs.core.new_path(tv.root.edit,(level - (5)),tail_node); +} +})())); + +return ret; +}); +cljs.core.tv_pop_tail = (function cljs$core$tv_pop_tail(tv,level,node){ +var node__$1 = cljs.core.tv_ensure_editable(tv.root.edit,node); +var subidx = (((tv.cnt - (2)) >>> level) & (31)); +if((level > (5))){ +var new_child = (function (){var G__2158 = tv; +var G__2159 = (level - (5)); +var G__2160 = cljs.core.pv_aget(node__$1,subidx); +return (cljs.core.tv_pop_tail.cljs$core$IFn$_invoke$arity$3 ? cljs.core.tv_pop_tail.cljs$core$IFn$_invoke$arity$3(G__2158,G__2159,G__2160) : cljs.core.tv_pop_tail.call(null,G__2158,G__2159,G__2160)); +})(); +if((((new_child == null)) && ((subidx === (0))))){ +return null; +} else { +cljs.core.pv_aset(node__$1,subidx,new_child); + +return node__$1; +} +} else { +if((subidx === (0))){ +return null; +} else { +cljs.core.pv_aset(node__$1,subidx,null); + +return node__$1; + +} +} +}); +cljs.core.unchecked_editable_array_for = (function cljs$core$unchecked_editable_array_for(tv,i){ +if((i >= cljs.core.tail_off(tv))){ +return tv.tail; +} else { +var root = tv.root; +var node = root; +var level = tv.shift; +while(true){ +if((level > (0))){ +var G__2161 = cljs.core.tv_ensure_editable(root.edit,cljs.core.pv_aget(node,((i >>> level) & (31)))); +var G__2162 = (level - (5)); +node = G__2161; +level = G__2162; +continue; +} else { +return node.arr; +} +break; +} +} +}); + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ITransientCollection} + * @implements {cljs.core.ITransientVector} + * @implements {cljs.core.ITransientAssociative} + * @implements {cljs.core.ILookup} +*/ +cljs.core.TransientVector = (function (cnt,shift,root,tail){ +this.cnt = cnt; +this.shift = shift; +this.root = root; +this.tail = tail; +this.cljs$lang$protocol_mask$partition1$ = 88; +this.cljs$lang$protocol_mask$partition0$ = 275; +}); +cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = (function (tcoll,o){ +var self__ = this; +var tcoll__$1 = this; +if(self__.root.edit){ +if(((self__.cnt - cljs.core.tail_off(tcoll__$1)) < (32))){ +(self__.tail[(self__.cnt & (31))] = o); + +self__.cnt = (self__.cnt + (1)); + +return tcoll__$1; +} else { +var tail_node = (new cljs.core.VectorNode(self__.root.edit,self__.tail)); +var new_tail = [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]; +(new_tail[(0)] = o); + +self__.tail = new_tail; + +if(((self__.cnt >>> (5)) > ((1) << self__.shift))){ +var new_root_array = [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]; +var new_shift = (self__.shift + (5)); +(new_root_array[(0)] = self__.root); + +(new_root_array[(1)] = cljs.core.new_path(self__.root.edit,self__.shift,tail_node)); + +self__.root = (new cljs.core.VectorNode(self__.root.edit,new_root_array)); + +self__.shift = new_shift; + +self__.cnt = (self__.cnt + (1)); + +return tcoll__$1; +} else { +var new_root = cljs.core.tv_push_tail(tcoll__$1,self__.shift,self__.root,tail_node); +self__.root = new_root; + +self__.cnt = (self__.cnt + (1)); + +return tcoll__$1; +} +} +} else { +throw (new Error("conj! after persistent!")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +if(self__.root.edit){ +self__.root.edit = null; + +var len = (self__.cnt - cljs.core.tail_off(tcoll__$1)); +var trimmed_tail = (new Array(len)); +cljs.core.array_copy(self__.tail,(0),trimmed_tail,(0),len); + +return (new cljs.core.PersistentVector(null,self__.cnt,self__.shift,self__.root,trimmed_tail,null)); +} else { +throw (new Error("persistent! called twice")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = (function (tcoll,key,val){ +var self__ = this; +var tcoll__$1 = this; +if(typeof key === 'number'){ +return tcoll__$1.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(null,key,val); +} else { +throw (new Error("TransientVector's key for assoc! must be a number.")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 = (function (tcoll,n,val){ +var self__ = this; +var tcoll__$1 = this; +if(self__.root.edit){ +if(((((0) <= n)) && ((n < self__.cnt)))){ +if((cljs.core.tail_off(tcoll__$1) <= n)){ +(self__.tail[(n & (31))] = val); + +return tcoll__$1; +} else { +var new_root = (function (){var fexpr__2164 = ((function (tcoll__$1){ +return (function cljs$core$go(level,node){ +var node__$1 = cljs.core.tv_ensure_editable(self__.root.edit,node); +if((level === (0))){ +cljs.core.pv_aset(node__$1,(n & (31)),val); + +return node__$1; +} else { +var subidx = ((n >>> level) & (31)); +cljs.core.pv_aset(node__$1,subidx,cljs$core$go((level - (5)),cljs.core.pv_aget(node__$1,subidx))); + +return node__$1; +} +});})(tcoll__$1)) +; +return fexpr__2164(self__.shift,self__.root); +})(); +self__.root = new_root; + +return tcoll__$1; +} +} else { +if((n === self__.cnt)){ +return tcoll__$1.cljs$core$ITransientCollection$_conj_BANG_$arity$2(null,val); +} else { +throw (new Error(["Index ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)," out of bounds for TransientVector of length",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.cnt)].join(''))); + +} +} +} else { +throw (new Error("assoc! after persistent!")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_pop_BANG_$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +if(self__.root.edit){ +if((self__.cnt === (0))){ +throw (new Error("Can't pop empty vector")); +} else { +if(((1) === self__.cnt)){ +self__.cnt = (0); + +return tcoll__$1; +} else { +if((((self__.cnt - (1)) & (31)) > (0))){ +self__.cnt = (self__.cnt - (1)); + +return tcoll__$1; +} else { +var new_tail = cljs.core.unchecked_editable_array_for(tcoll__$1,(self__.cnt - (2))); +var new_root = (function (){var nr = cljs.core.tv_pop_tail(tcoll__$1,self__.shift,self__.root); +if(!((nr == null))){ +return nr; +} else { +return (new cljs.core.VectorNode(self__.root.edit,[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null])); +} +})(); +if(((((5) < self__.shift)) && ((cljs.core.pv_aget(new_root,(1)) == null)))){ +var new_root__$1 = cljs.core.tv_ensure_editable(self__.root.edit,cljs.core.pv_aget(new_root,(0))); +self__.root = new_root__$1; + +self__.shift = (self__.shift - (5)); + +self__.cnt = (self__.cnt - (1)); + +self__.tail = new_tail; + +return tcoll__$1; +} else { +self__.root = new_root; + +self__.cnt = (self__.cnt - (1)); + +self__.tail = new_tail; + +return tcoll__$1; +} + +} +} +} +} else { +throw (new Error("pop! after persistent!")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(self__.root.edit){ +return self__.cnt; +} else { +throw (new Error("count after persistent!")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (coll,n){ +var self__ = this; +var coll__$1 = this; +if(self__.root.edit){ +return (cljs.core.array_for(coll__$1,n)[(n & (31))]); +} else { +throw (new Error("nth after persistent!")); +} +}); + +cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (coll,n,not_found){ +var self__ = this; +var coll__$1 = this; +if(((((0) <= n)) && ((n < self__.cnt)))){ +return coll__$1.cljs$core$IIndexed$_nth$arity$2(null,n); +} else { +return not_found; +} +}); + +cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +if(typeof k === 'number'){ +return coll__$1.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +} else { +return not_found; +} +}); + +cljs.core.TransientVector.prototype.call = (function() { +var G__2165 = null; +var G__2165__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2165__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2165 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2165__2.call(this,self__,k); +case 3: +return G__2165__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2165.cljs$core$IFn$_invoke$arity$2 = G__2165__2; +G__2165.cljs$core$IFn$_invoke$arity$3 = G__2165__3; +return G__2165; +})() +; + +cljs.core.TransientVector.prototype.apply = (function (self__,args2163){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2163))); +}); + +cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.TransientVector.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$cnt,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$shift,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$root,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$tail,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.TransientVector.cljs$lang$type = true; + +cljs.core.TransientVector.cljs$lang$ctorStr = "cljs.core/TransientVector"; + +cljs.core.TransientVector.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/TransientVector"); +}); + +/** + * Positional factory function for cljs.core/TransientVector. + */ +cljs.core.__GT_TransientVector = (function cljs$core$__GT_TransientVector(cnt,shift,root,tail){ +return (new cljs.core.TransientVector(cnt,shift,root,tail)); +}); + + +/** +* @constructor +*/ +cljs.core.PersistentQueueIter = (function (fseq,riter){ +this.fseq = fseq; +this.riter = riter; +}); +cljs.core.PersistentQueueIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +var or__3936__auto__ = ((!((self__.fseq == null))) && (cljs.core.seq(self__.fseq))); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +var and__3925__auto__ = !((self__.riter == null)); +if(and__3925__auto__){ +return self__.riter.hasNext(); +} else { +return and__3925__auto__; +} +} +}); + +cljs.core.PersistentQueueIter.prototype.next = (function (){ +var self__ = this; +var _ = this; +if(!((self__.fseq == null))){ +var ret = cljs.core.first(self__.fseq); +self__.fseq = cljs.core.next(self__.fseq); + +return ret; +} else { +if(((!((self__.riter == null))) && (self__.riter.hasNext()))){ +return self__.riter.next(); +} else { +throw (new Error("No such element")); + +} +} +}); + +cljs.core.PersistentQueueIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.PersistentQueueIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$fseq,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$riter], null); +}); + +cljs.core.PersistentQueueIter.cljs$lang$type = true; + +cljs.core.PersistentQueueIter.cljs$lang$ctorStr = "cljs.core/PersistentQueueIter"; + +cljs.core.PersistentQueueIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentQueueIter"); +}); + +/** + * Positional factory function for cljs.core/PersistentQueueIter. + */ +cljs.core.__GT_PersistentQueueIter = (function cljs$core$__GT_PersistentQueueIter(fseq,riter){ +return (new cljs.core.PersistentQueueIter(fseq,riter)); +}); + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.PersistentQueueSeq = (function (meta,front,rear,__hash){ +this.meta = meta; +this.front = front; +this.rear = rear; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 31850700; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.PersistentQueueSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentQueueSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentQueueSeq.prototype.indexOf = (function() { +var G__2166 = null; +var G__2166__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2166__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2166 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2166__1.call(this,x); +case 2: +return G__2166__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2166.cljs$core$IFn$_invoke$arity$1 = G__2166__1; +G__2166.cljs$core$IFn$_invoke$arity$2 = G__2166__2; +return G__2166; +})() +; + +cljs.core.PersistentQueueSeq.prototype.lastIndexOf = (function() { +var G__2167 = null; +var G__2167__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2167__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2167 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2167__1.call(this,x); +case 2: +return G__2167__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2167.cljs$core$IFn$_invoke$arity$1 = G__2167__1; +G__2167.cljs$core$IFn$_invoke$arity$2 = G__2167__2; +return G__2167; +})() +; + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var temp__5455__auto__ = cljs.core.next(self__.front); +if(temp__5455__auto__){ +var f1 = temp__5455__auto__; +return (new cljs.core.PersistentQueueSeq(self__.meta,f1,self__.rear,null)); +} else { +if(!((self__.rear == null))){ +return (new cljs.core.PersistentQueueSeq(self__.meta,self__.rear,null,null)); +} else { +return null; +} +} +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.first(self__.front); +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var temp__5455__auto__ = cljs.core.next(self__.front); +if(temp__5455__auto__){ +var f1 = temp__5455__auto__; +return (new cljs.core.PersistentQueueSeq(self__.meta,f1,self__.rear,null)); +} else { +if((self__.rear == null)){ +return coll__$1.cljs$core$IEmptyableCollection$_empty$arity$1(null); +} else { +return (new cljs.core.PersistentQueueSeq(self__.meta,self__.rear,null,null)); +} +} +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentQueueSeq(meta__$1,self__.front,self__.rear,self__.__hash)); +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.PersistentQueueSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$front,cljs.core.cst$sym$rear,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentQueueSeq.cljs$lang$type = true; + +cljs.core.PersistentQueueSeq.cljs$lang$ctorStr = "cljs.core/PersistentQueueSeq"; + +cljs.core.PersistentQueueSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentQueueSeq"); +}); + +/** + * Positional factory function for cljs.core/PersistentQueueSeq. + */ +cljs.core.__GT_PersistentQueueSeq = (function cljs$core$__GT_PersistentQueueSeq(meta,front,rear,__hash){ +return (new cljs.core.PersistentQueueSeq(meta,front,rear,__hash)); +}); + +var G__2168_2171 = cljs.core.PersistentQueueSeq.prototype; +var G__2169_2172 = cljs.core.ITER_SYMBOL; +var G__2170_2173 = ((function (G__2168_2171,G__2169_2172){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2168_2171,G__2169_2172)) +; +goog.object.set(G__2168_2171,G__2169_2172,G__2170_2173); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IStack} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} +*/ +cljs.core.PersistentQueue = (function (meta,count,front,rear,__hash){ +this.meta = meta; +this.count = count; +this.front = front; +this.rear = rear; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition1$ = 139264; +this.cljs$lang$protocol_mask$partition0$ = 31858766; +}); +cljs.core.PersistentQueue.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentQueue.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentQueue.prototype.indexOf = (function() { +var G__2174 = null; +var G__2174__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2174__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2174 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2174__1.call(this,x); +case 2: +return G__2174__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2174.cljs$core$IFn$_invoke$arity$1 = G__2174__1; +G__2174.cljs$core$IFn$_invoke$arity$2 = G__2174__2; +return G__2174; +})() +; + +cljs.core.PersistentQueue.prototype.lastIndexOf = (function() { +var G__2175 = null; +var G__2175__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(self__.count.cljs$core$IFn$_invoke$arity$1 ? self__.count.cljs$core$IFn$_invoke$arity$1(coll) : self__.count.call(null,coll))); +}); +var G__2175__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2175 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2175__1.call(this,x); +case 2: +return G__2175__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2175.cljs$core$IFn$_invoke$arity$1 = G__2175__1; +G__2175.cljs$core$IFn$_invoke$arity$2 = G__2175__2; +return G__2175; +})() +; + +cljs.core.PersistentQueue.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentQueueIter(self__.front,cljs.core._iterator(self__.rear))); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentQueue.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentQueue(self__.meta,self__.count,self__.front,self__.rear,self__.__hash)); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.count; +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IStack$_peek$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.first(self__.front); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IStack$_pop$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.truth_(self__.front)){ +var temp__5455__auto__ = cljs.core.next(self__.front); +if(temp__5455__auto__){ +var f1 = temp__5455__auto__; +return (new cljs.core.PersistentQueue(self__.meta,(self__.count - (1)),f1,self__.rear,null)); +} else { +return (new cljs.core.PersistentQueue(self__.meta,(self__.count - (1)),cljs.core.seq(self__.rear),cljs.core.PersistentVector.EMPTY,null)); +} +} else { +return coll__$1; +} +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.PersistentQueue.EMPTY,self__.meta); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.first(self__.front); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.rest(cljs.core.seq(coll__$1)); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var rear__$1 = cljs.core.seq(self__.rear); +if(cljs.core.truth_((function (){var or__3936__auto__ = self__.front; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return rear__$1; +} +})())){ +return (new cljs.core.PersistentQueueSeq(null,self__.front,cljs.core.seq(rear__$1),null)); +} else { +return null; +} +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentQueue(meta__$1,self__.count,self__.front,self__.rear,self__.__hash)); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.truth_(self__.front)){ +return (new cljs.core.PersistentQueue(self__.meta,(self__.count + (1)),self__.front,cljs.core.conj.cljs$core$IFn$_invoke$arity$2((function (){var or__3936__auto__ = self__.rear; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.PersistentVector.EMPTY; +} +})(),o),null)); +} else { +return (new cljs.core.PersistentQueue(self__.meta,(self__.count + (1)),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(self__.front,o),cljs.core.PersistentVector.EMPTY,null)); +} +}); + +cljs.core.PersistentQueue.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$count,cljs.core.cst$sym$front,cljs.core.cst$sym$rear,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentQueue.cljs$lang$type = true; + +cljs.core.PersistentQueue.cljs$lang$ctorStr = "cljs.core/PersistentQueue"; + +cljs.core.PersistentQueue.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentQueue"); +}); + +/** + * Positional factory function for cljs.core/PersistentQueue. + */ +cljs.core.__GT_PersistentQueue = (function cljs$core$__GT_PersistentQueue(meta,count,front,rear,__hash){ +return (new cljs.core.PersistentQueue(meta,count,front,rear,__hash)); +}); + +cljs.core.PersistentQueue.EMPTY = (new cljs.core.PersistentQueue(null,(0),null,cljs.core.PersistentVector.EMPTY,cljs.core.empty_ordered_hash)); +var G__2176_2179 = cljs.core.PersistentQueue.prototype; +var G__2177_2180 = cljs.core.ITER_SYMBOL; +var G__2178_2181 = ((function (G__2176_2179,G__2177_2180){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2176_2179,G__2177_2180)) +; +goog.object.set(G__2176_2179,G__2177_2180,G__2178_2181); + +/** +* @constructor + * @implements {cljs.core.IEquiv} +*/ +cljs.core.NeverEquiv = (function (){ +this.cljs$lang$protocol_mask$partition0$ = 2097152; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.NeverEquiv.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.NeverEquiv.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (o,other){ +var self__ = this; +var o__$1 = this; +return false; +}); + +cljs.core.NeverEquiv.getBasis = (function (){ +return cljs.core.PersistentVector.EMPTY; +}); + +cljs.core.NeverEquiv.cljs$lang$type = true; + +cljs.core.NeverEquiv.cljs$lang$ctorStr = "cljs.core/NeverEquiv"; + +cljs.core.NeverEquiv.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/NeverEquiv"); +}); + +/** + * Positional factory function for cljs.core/NeverEquiv. + */ +cljs.core.__GT_NeverEquiv = (function cljs$core$__GT_NeverEquiv(){ +return (new cljs.core.NeverEquiv()); +}); + +cljs.core.never_equiv = (new cljs.core.NeverEquiv()); +/** + * Test map equivalence. Returns true if x equals y, otherwise returns false. + */ +cljs.core.equiv_map = (function cljs$core$equiv_map(x,y){ +return cljs.core.boolean$(((((cljs.core.map_QMARK_(y)) && (!(cljs.core.record_QMARK_(y)))))?(((cljs.core.count(x) === cljs.core.count(y)))?((((!((x == null)))?(((((x.cljs$lang$protocol_mask$partition0$ & (1048576))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IKVReduce$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IKVReduce,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IKVReduce,x)))?cljs.core.reduce_kv((function (_,k,v){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(y,k,cljs.core.never_equiv),v)){ +return true; +} else { +return cljs.core.reduced(false); +} +}),true,x):cljs.core.every_QMARK_((function (xkv){ +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(y,cljs.core.first(xkv),cljs.core.never_equiv),cljs.core.second(xkv)); +}),x)):null):null)); +}); +cljs.core.scan_array = (function cljs$core$scan_array(incr,k,array){ +var len = array.length; +var i = (0); +while(true){ +if((i < len)){ +if((k === (array[i]))){ +return i; +} else { +var G__2183 = (i + incr); +i = G__2183; +continue; +} +} else { +return null; +} +break; +} +}); +cljs.core.obj_map_compare_keys = (function cljs$core$obj_map_compare_keys(a,b){ +var a__$1 = cljs.core.hash(a); +var b__$1 = cljs.core.hash(b); +if((a__$1 < b__$1)){ +return (-1); +} else { +if((a__$1 > b__$1)){ +return (1); +} else { +return (0); + +} +} +}); +cljs.core.obj_map__GT_hash_map = (function cljs$core$obj_map__GT_hash_map(m,k,v){ +var ks = m.keys; +var len = ks.length; +var so = m.strobj; +var mm = cljs.core.meta(m); +var i = (0); +var out = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY); +while(true){ +if((i < len)){ +var k__$1 = (ks[i]); +var G__2184 = (i + (1)); +var G__2185 = cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,k__$1,goog.object.get(so,k__$1)); +i = G__2184; +out = G__2185; +continue; +} else { +return cljs.core._with_meta(cljs.core.persistent_BANG_(cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,k,v)),mm); +} +break; +} +}); +cljs.core.obj_clone = (function cljs$core$obj_clone(obj,ks){ +var new_obj = {}; +var l = ks.length; +var i_2191 = (0); +while(true){ +if((i_2191 < l)){ +var k_2192 = (ks[i_2191]); +var G__2188_2193 = new_obj; +var G__2189_2194 = k_2192; +var G__2190_2195 = goog.object.get(obj,k_2192); +goog.object.set(G__2188_2193,G__2189_2194,G__2190_2195); + +var G__2196 = (i_2191 + (1)); +i_2191 = G__2196; +continue; +} else { +} +break; +} + +return new_obj; +}); + +/** +* @constructor + * @implements {cljs.core.IKVReduce} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEditableCollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.IMap} + * @implements {cljs.core.ILookup} +*/ +cljs.core.ObjMap = (function (meta,keys,strobj,update_count,__hash){ +this.meta = meta; +this.keys = keys; +this.strobj = strobj; +this.update_count = update_count; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 16123663; +this.cljs$lang$protocol_mask$partition1$ = 4; +}); +cljs.core.ObjMap.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ObjMap.prototype.cljs$core$IFind$_find$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if(((goog.isString(k)) && (!((cljs.core.scan_array((1),k,self__.keys) == null))))){ +return (new cljs.core.MapEntry(k,(self__.strobj[k]),null)); +} else { +return null; +} +}); + +cljs.core.ObjMap.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.ObjMap.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +if(((goog.isString(k)) && (!((cljs.core.scan_array((1),k,self__.keys) == null))))){ +return (self__.strobj[k]); +} else { +return not_found; +} +}); + +cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = (function (coll,f,init){ +var self__ = this; +var coll__$1 = this; +var len = self__.keys.length; +var keys__$1 = self__.keys.sort(cljs.core.obj_map_compare_keys); +var init__$1 = init; +while(true){ +if(cljs.core.seq(keys__$1)){ +var k = cljs.core.first(keys__$1); +var init__$2 = (function (){var G__2199 = init__$1; +var G__2200 = k; +var G__2201 = (self__.strobj[k]); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2199,G__2200,G__2201) : f.call(null,G__2199,G__2200,G__2201)); +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return cljs.core.deref(init__$2); +} else { +var G__2202 = cljs.core.rest(keys__$1); +var G__2203 = init__$2; +keys__$1 = G__2202; +init__$1 = G__2203; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +cljs.core.ObjMap.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.ObjMap.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.keys.length; +}); + +cljs.core.ObjMap.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_unordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.ObjMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_map(coll__$1,other); +}); + +cljs.core.ObjMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.transient$(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentHashMap.EMPTY,coll__$1)); +}); + +cljs.core.ObjMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.ObjMap.EMPTY,self__.meta); +}); + +cljs.core.ObjMap.prototype.cljs$core$IMap$_dissoc$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if(((goog.isString(k)) && (!((cljs.core.scan_array((1),k,self__.keys) == null))))){ +var new_keys = cljs.core.aclone(self__.keys); +var new_strobj = cljs.core.obj_clone(self__.strobj,self__.keys); +new_keys.splice(cljs.core.scan_array((1),k,new_keys),(1)); + +delete new_strobj[k]; + +return (new cljs.core.ObjMap(self__.meta,new_keys,new_strobj,(self__.update_count + (1)),null)); +} else { +return coll__$1; +} +}); + +cljs.core.ObjMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (coll,k,v){ +var self__ = this; +var coll__$1 = this; +if(goog.isString(k)){ +if((((self__.update_count > cljs.core.ObjMap.HASHMAP_THRESHOLD)) || ((self__.keys.length >= cljs.core.ObjMap.HASHMAP_THRESHOLD)))){ +return cljs.core.obj_map__GT_hash_map(coll__$1,k,v); +} else { +if(!((cljs.core.scan_array((1),k,self__.keys) == null))){ +var new_strobj = cljs.core.obj_clone(self__.strobj,self__.keys); +goog.object.set(new_strobj,k,v); + +return (new cljs.core.ObjMap(self__.meta,self__.keys,new_strobj,(self__.update_count + (1)),null)); +} else { +var new_strobj = cljs.core.obj_clone(self__.strobj,self__.keys); +var new_keys = cljs.core.aclone(self__.keys); +goog.object.set(new_strobj,k,v); + +new_keys.push(k); + +return (new cljs.core.ObjMap(self__.meta,new_keys,new_strobj,(self__.update_count + (1)),null)); +} +} +} else { +return cljs.core.obj_map__GT_hash_map(coll__$1,k,v); +} +}); + +cljs.core.ObjMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if(((goog.isString(k)) && (!((cljs.core.scan_array((1),k,self__.keys) == null))))){ +return true; +} else { +return false; +} +}); + +cljs.core.ObjMap.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.keys.length > (0))){ +return cljs.core.map.cljs$core$IFn$_invoke$arity$2(((function (coll__$1){ +return (function (p1__2197_SHARP_){ +return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[p1__2197_SHARP_,(self__.strobj[p1__2197_SHARP_])],null)); +});})(coll__$1)) +,self__.keys.sort(cljs.core.obj_map_compare_keys)); +} else { +return null; +} +}); + +cljs.core.ObjMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.ObjMap(meta__$1,self__.keys,self__.strobj,self__.update_count,self__.__hash)); +}); + +cljs.core.ObjMap.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,entry){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.vector_QMARK_(entry)){ +return coll__$1.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(1))); +} else { +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,coll__$1,entry); +} +}); + +cljs.core.ObjMap.prototype.call = (function() { +var G__2204 = null; +var G__2204__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2204__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2204 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2204__2.call(this,self__,k); +case 3: +return G__2204__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2204.cljs$core$IFn$_invoke$arity$2 = G__2204__2; +G__2204.cljs$core$IFn$_invoke$arity$3 = G__2204__3; +return G__2204; +})() +; + +cljs.core.ObjMap.prototype.apply = (function (self__,args2198){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2198))); +}); + +cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.ObjMap.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$keys,cljs.core.cst$sym$strobj,cljs.core.cst$sym$update_DASH_count,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ObjMap.cljs$lang$type = true; + +cljs.core.ObjMap.cljs$lang$ctorStr = "cljs.core/ObjMap"; + +cljs.core.ObjMap.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ObjMap"); +}); + +/** + * Positional factory function for cljs.core/ObjMap. + */ +cljs.core.__GT_ObjMap = (function cljs$core$__GT_ObjMap(meta,keys,strobj,update_count,__hash){ +return (new cljs.core.ObjMap(meta,keys,strobj,update_count,__hash)); +}); + +cljs.core.ObjMap.EMPTY = (new cljs.core.ObjMap(null,[],{},(0),cljs.core.empty_unordered_hash)); +cljs.core.ObjMap.HASHMAP_THRESHOLD = (8); +cljs.core.ObjMap.fromObject = (function (ks,obj){ +return (new cljs.core.ObjMap(null,ks,obj,(0),null)); +}); + +/** +* @constructor +*/ +cljs.core.RecordIter = (function (i,record,base_count,fields,ext_map_iter){ +this.i = i; +this.record = record; +this.base_count = base_count; +this.fields = fields; +this.ext_map_iter = ext_map_iter; +}); +cljs.core.RecordIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +var or__3936__auto__ = (self__.i < self__.base_count); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return self__.ext_map_iter.hasNext(); +} +}); + +cljs.core.RecordIter.prototype.next = (function (){ +var self__ = this; +var _ = this; +if((self__.i < self__.base_count)){ +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$2(self__.fields,self__.i); +self__.i = (self__.i + (1)); + +return (new cljs.core.MapEntry(k,cljs.core._lookup.cljs$core$IFn$_invoke$arity$2(self__.record,k),null)); +} else { +return self__.ext_map_iter.next(); +} +}); + +cljs.core.RecordIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.RecordIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$record,cljs.core.cst$sym$base_DASH_count,cljs.core.cst$sym$fields,cljs.core.cst$sym$ext_DASH_map_DASH_iter], null); +}); + +cljs.core.RecordIter.cljs$lang$type = true; + +cljs.core.RecordIter.cljs$lang$ctorStr = "cljs.core/RecordIter"; + +cljs.core.RecordIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/RecordIter"); +}); + +/** + * Positional factory function for cljs.core/RecordIter. + */ +cljs.core.__GT_RecordIter = (function cljs$core$__GT_RecordIter(i,record,base_count,fields,ext_map_iter){ +return (new cljs.core.RecordIter(i,record,base_count,fields,ext_map_iter)); +}); + + +/** +* @constructor +*/ +cljs.core.ES6EntriesIterator = (function (s){ +this.s = s; +}); +cljs.core.ES6EntriesIterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +if(!((self__.s == null))){ +var vec__2207 = cljs.core.first(self__.s); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2207,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2207,(1),null); +self__.s = cljs.core.next(self__.s); + +return ({"value": [k,v], "done": false}); +} else { +return ({"value": null, "done": true}); +} +}); + +cljs.core.ES6EntriesIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$s,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ES6EntriesIterator.cljs$lang$type = true; + +cljs.core.ES6EntriesIterator.cljs$lang$ctorStr = "cljs.core/ES6EntriesIterator"; + +cljs.core.ES6EntriesIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ES6EntriesIterator"); +}); + +/** + * Positional factory function for cljs.core/ES6EntriesIterator. + */ +cljs.core.__GT_ES6EntriesIterator = (function cljs$core$__GT_ES6EntriesIterator(s){ +return (new cljs.core.ES6EntriesIterator(s)); +}); + +cljs.core.es6_entries_iterator = (function cljs$core$es6_entries_iterator(coll){ +return (new cljs.core.ES6EntriesIterator(cljs.core.seq(coll))); +}); + +/** +* @constructor +*/ +cljs.core.ES6SetEntriesIterator = (function (s){ +this.s = s; +}); +cljs.core.ES6SetEntriesIterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +if(!((self__.s == null))){ +var x = cljs.core.first(self__.s); +self__.s = cljs.core.next(self__.s); + +return ({"value": [x,x], "done": false}); +} else { +return ({"value": null, "done": true}); +} +}); + +cljs.core.ES6SetEntriesIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$s,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ES6SetEntriesIterator.cljs$lang$type = true; + +cljs.core.ES6SetEntriesIterator.cljs$lang$ctorStr = "cljs.core/ES6SetEntriesIterator"; + +cljs.core.ES6SetEntriesIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ES6SetEntriesIterator"); +}); + +/** + * Positional factory function for cljs.core/ES6SetEntriesIterator. + */ +cljs.core.__GT_ES6SetEntriesIterator = (function cljs$core$__GT_ES6SetEntriesIterator(s){ +return (new cljs.core.ES6SetEntriesIterator(s)); +}); + +cljs.core.es6_set_entries_iterator = (function cljs$core$es6_set_entries_iterator(coll){ +return (new cljs.core.ES6SetEntriesIterator(cljs.core.seq(coll))); +}); +cljs.core.array_index_of_nil_QMARK_ = (function cljs$core$array_index_of_nil_QMARK_(arr){ +var len = arr.length; +var i = (0); +while(true){ +if((len <= i)){ +return (-1); +} else { +if(((arr[i]) == null)){ +return i; +} else { +var G__2210 = (i + (2)); +i = G__2210; +continue; + +} +} +break; +} +}); +cljs.core.array_index_of_keyword_QMARK_ = (function cljs$core$array_index_of_keyword_QMARK_(arr,k){ +var len = arr.length; +var kstr = k.fqn; +var i = (0); +while(true){ +if((len <= i)){ +return (-1); +} else { +if(((((arr[i]) instanceof cljs.core.Keyword)) && ((kstr === (arr[i]).fqn)))){ +return i; +} else { +var G__2211 = (i + (2)); +i = G__2211; +continue; + +} +} +break; +} +}); +cljs.core.array_index_of_symbol_QMARK_ = (function cljs$core$array_index_of_symbol_QMARK_(arr,k){ +var len = arr.length; +var kstr = k.str; +var i = (0); +while(true){ +if((len <= i)){ +return (-1); +} else { +if(((((arr[i]) instanceof cljs.core.Symbol)) && ((kstr === (arr[i]).str)))){ +return i; +} else { +var G__2212 = (i + (2)); +i = G__2212; +continue; + +} +} +break; +} +}); +cljs.core.array_index_of_identical_QMARK_ = (function cljs$core$array_index_of_identical_QMARK_(arr,k){ +var len = arr.length; +var i = (0); +while(true){ +if((len <= i)){ +return (-1); +} else { +if((k === (arr[i]))){ +return i; +} else { +var G__2213 = (i + (2)); +i = G__2213; +continue; + +} +} +break; +} +}); +cljs.core.array_index_of_equiv_QMARK_ = (function cljs$core$array_index_of_equiv_QMARK_(arr,k){ +var len = arr.length; +var i = (0); +while(true){ +if((len <= i)){ +return (-1); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(k,(arr[i]))){ +return i; +} else { +var G__2214 = (i + (2)); +i = G__2214; +continue; + +} +} +break; +} +}); +cljs.core.array_index_of = (function cljs$core$array_index_of(arr,k){ +if((k instanceof cljs.core.Keyword)){ +return cljs.core.array_index_of_keyword_QMARK_(arr,k); +} else { +if(((goog.isString(k)) || (typeof k === 'number'))){ +return cljs.core.array_index_of_identical_QMARK_(arr,k); +} else { +if((k instanceof cljs.core.Symbol)){ +return cljs.core.array_index_of_symbol_QMARK_(arr,k); +} else { +if((k == null)){ +return cljs.core.array_index_of_nil_QMARK_(arr); +} else { +return cljs.core.array_index_of_equiv_QMARK_(arr,k); + +} +} +} +} +}); +cljs.core.array_map_index_of = (function cljs$core$array_map_index_of(m,k){ +return cljs.core.array_index_of(m.arr,k); +}); +cljs.core.array_extend_kv = (function cljs$core$array_extend_kv(arr,k,v){ +var l = arr.length; +var narr = (new Array((l + (2)))); +var i_2215 = (0); +while(true){ +if((i_2215 < l)){ +(narr[i_2215] = (arr[i_2215])); + +var G__2216 = (i_2215 + (1)); +i_2215 = G__2216; +continue; +} else { +} +break; +} + +(narr[l] = k); + +(narr[(l + (1))] = v); + +return narr; +}); +cljs.core.array_map_extend_kv = (function cljs$core$array_map_extend_kv(m,k,v){ +return cljs.core.array_extend_kv(m.arr,k,v); +}); + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IVector} + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IStack} + * @implements {cljs.core.IMapEntry} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.ILookup} + * @implements {cljs.core.IReduce} +*/ +cljs.core.MapEntry = (function (key,val,__hash){ +this.key = key; +this.val = val; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 166619935; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.MapEntry.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.MapEntry.prototype.cljs$core$IFind$_find$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +var G__2218 = k; +switch (G__2218) { +case (0): +return (new cljs.core.MapEntry((0),self__.key,null)); + +break; +case (1): +return (new cljs.core.MapEntry((1),self__.val,null)); + +break; +default: +return null; + +} +}); + +cljs.core.MapEntry.prototype.indexOf = (function() { +var G__2220 = null; +var G__2220__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2220__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2220 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2220__1.call(this,x); +case 2: +return G__2220__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2220.cljs$core$IFn$_invoke$arity$1 = G__2220__1; +G__2220.cljs$core$IFn$_invoke$arity$2 = G__2220__2; +return G__2220; +})() +; + +cljs.core.MapEntry.prototype.lastIndexOf = (function() { +var G__2221 = null; +var G__2221__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2221__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2221 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2221__1.call(this,x); +case 2: +return G__2221__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2221.cljs$core$IFn$_invoke$arity$1 = G__2221__1; +G__2221.cljs$core$IFn$_invoke$arity$2 = G__2221__2; +return G__2221; +})() +; + +cljs.core.MapEntry.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +return node__$1.cljs$core$IIndexed$_nth$arity$3(null,k,null); +}); + +cljs.core.MapEntry.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (node,k,not_found){ +var self__ = this; +var node__$1 = this; +return node__$1.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.MapEntry.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (node,n){ +var self__ = this; +var node__$1 = this; +if((n === (0))){ +return self__.key; +} else { +if((n === (1))){ +return self__.val; +} else { +throw (new Error("Index out of bounds")); + +} +} +}); + +cljs.core.MapEntry.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (node,n,not_found){ +var self__ = this; +var node__$1 = this; +if((n === (0))){ +return self__.key; +} else { +if((n === (1))){ +return self__.val; +} else { +return not_found; + +} +} +}); + +cljs.core.MapEntry.prototype.cljs$core$IVector$_assoc_n$arity$3 = (function (node,n,v){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null).cljs$core$IVector$_assoc_n$arity$3(null,n,v); +}); + +cljs.core.MapEntry.prototype.cljs$core$IMeta$_meta$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return null; +}); + +cljs.core.MapEntry.prototype.cljs$core$ICounted$_count$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (2); +}); + +cljs.core.MapEntry.prototype.cljs$core$IMapEntry$_key$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.key; +}); + +cljs.core.MapEntry.prototype.cljs$core$IMapEntry$_val$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.val; +}); + +cljs.core.MapEntry.prototype.cljs$core$IStack$_peek$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.val; +}); + +cljs.core.MapEntry.prototype.cljs$core$IStack$_pop$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null); +}); + +cljs.core.MapEntry.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (new cljs.core.IndexedSeq([self__.val,self__.key],(0),null)); +}); + +cljs.core.MapEntry.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.MapEntry.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.MapEntry.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return null; +}); + +cljs.core.MapEntry.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (node,f){ +var self__ = this; +var node__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(node__$1,f); +}); + +cljs.core.MapEntry.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (node,f,start){ +var self__ = this; +var node__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(node__$1,f,start); +}); + +cljs.core.MapEntry.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (node,k,v){ +var self__ = this; +var node__$1 = this; +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),k,v); +}); + +cljs.core.MapEntry.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +return (((k === (0))) || ((k === (1)))); +}); + +cljs.core.MapEntry.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (new cljs.core.IndexedSeq([self__.key,self__.val],(0),null)); +}); + +cljs.core.MapEntry.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (node,meta){ +var self__ = this; +var node__$1 = this; +return cljs.core.with_meta(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),meta); +}); + +cljs.core.MapEntry.prototype.cljs$core$ICollection$_conj$arity$2 = (function (node,o){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val,o], null); +}); + +cljs.core.MapEntry.prototype.call = (function() { +var G__2222 = null; +var G__2222__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var node = self____$1; +return node.cljs$core$IIndexed$_nth$arity$2(null,k); +}); +var G__2222__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var node = self____$1; +return node.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); +G__2222 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2222__2.call(this,self__,k); +case 3: +return G__2222__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2222.cljs$core$IFn$_invoke$arity$2 = G__2222__2; +G__2222.cljs$core$IFn$_invoke$arity$3 = G__2222__3; +return G__2222; +})() +; + +cljs.core.MapEntry.prototype.apply = (function (self__,args2217){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2217))); +}); + +cljs.core.MapEntry.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var node = this; +return node.cljs$core$IIndexed$_nth$arity$2(null,k); +}); + +cljs.core.MapEntry.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var node = this; +return node.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.MapEntry.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$key,cljs.core.cst$sym$val,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.MapEntry.cljs$lang$type = true; + +cljs.core.MapEntry.cljs$lang$ctorStr = "cljs.core/MapEntry"; + +cljs.core.MapEntry.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/MapEntry"); +}); + +/** + * Positional factory function for cljs.core/MapEntry. + */ +cljs.core.__GT_MapEntry = (function cljs$core$__GT_MapEntry(key,val,__hash){ +return (new cljs.core.MapEntry(key,val,__hash)); +}); + +/** + * Returns true if x satisfies IMapEntry + */ +cljs.core.map_entry_QMARK_ = (function cljs$core$map_entry_QMARK_(x){ +if(!((x == null))){ +if((((x.cljs$lang$protocol_mask$partition0$ & (2048))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IMapEntry$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.PersistentArrayMapSeq = (function (arr,i,_meta){ +this.arr = arr; +this.i = i; +this._meta = _meta; +this.cljs$lang$protocol_mask$partition0$ = 32374990; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.PersistentArrayMapSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentArrayMapSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentArrayMapSeq.prototype.indexOf = (function() { +var G__2224 = null; +var G__2224__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2224__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2224 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2224__1.call(this,x); +case 2: +return G__2224__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2224.cljs$core$IFn$_invoke$arity$1 = G__2224__1; +G__2224.cljs$core$IFn$_invoke$arity$2 = G__2224__2; +return G__2224; +})() +; + +cljs.core.PersistentArrayMapSeq.prototype.lastIndexOf = (function() { +var G__2225 = null; +var G__2225__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2225__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2225 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2225__1.call(this,x); +case 2: +return G__2225__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2225.cljs$core$IFn$_invoke$arity$1 = G__2225__1; +G__2225.cljs$core$IFn$_invoke$arity$2 = G__2225__2; +return G__2225; +})() +; + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__._meta; +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.i < (self__.arr.length - (2)))){ +return (new cljs.core.PersistentArrayMapSeq(self__.arr,(self__.i + (2)),self__._meta)); +} else { +return null; +} +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return ((self__.arr.length - self__.i) / (2)); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.hash_ordered_coll(coll__$1); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__._meta); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.MapEntry((self__.arr[self__.i]),(self__.arr[(self__.i + (1))]),null)); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.i < (self__.arr.length - (2)))){ +return (new cljs.core.PersistentArrayMapSeq(self__.arr,(self__.i + (2)),self__._meta)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,new_meta){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentArrayMapSeq(self__.arr,self__.i,new_meta)); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.PersistentArrayMapSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.cst$sym$i,cljs.core.cst$sym$_meta], null); +}); + +cljs.core.PersistentArrayMapSeq.cljs$lang$type = true; + +cljs.core.PersistentArrayMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentArrayMapSeq"; + +cljs.core.PersistentArrayMapSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentArrayMapSeq"); +}); + +/** + * Positional factory function for cljs.core/PersistentArrayMapSeq. + */ +cljs.core.__GT_PersistentArrayMapSeq = (function cljs$core$__GT_PersistentArrayMapSeq(arr,i,_meta){ +return (new cljs.core.PersistentArrayMapSeq(arr,i,_meta)); +}); + +var G__2226_2229 = cljs.core.PersistentArrayMapSeq.prototype; +var G__2227_2230 = cljs.core.ITER_SYMBOL; +var G__2228_2231 = ((function (G__2226_2229,G__2227_2230){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2226_2229,G__2227_2230)) +; +goog.object.set(G__2226_2229,G__2227_2230,G__2228_2231); +cljs.core.persistent_array_map_seq = (function cljs$core$persistent_array_map_seq(arr,i,_meta){ +if((i <= (arr.length - (2)))){ +return (new cljs.core.PersistentArrayMapSeq(arr,i,_meta)); +} else { +return null; +} +}); + + +/** +* @constructor +*/ +cljs.core.PersistentArrayMapIterator = (function (arr,i,cnt){ +this.arr = arr; +this.i = i; +this.cnt = cnt; +}); +cljs.core.PersistentArrayMapIterator.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return (self__.i < self__.cnt); +}); + +cljs.core.PersistentArrayMapIterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +var ret = (new cljs.core.MapEntry((self__.arr[self__.i]),(self__.arr[(self__.i + (1))]),null)); +self__.i = (self__.i + (2)); + +return ret; +}); + +cljs.core.PersistentArrayMapIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$cnt], null); +}); + +cljs.core.PersistentArrayMapIterator.cljs$lang$type = true; + +cljs.core.PersistentArrayMapIterator.cljs$lang$ctorStr = "cljs.core/PersistentArrayMapIterator"; + +cljs.core.PersistentArrayMapIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentArrayMapIterator"); +}); + +/** + * Positional factory function for cljs.core/PersistentArrayMapIterator. + */ +cljs.core.__GT_PersistentArrayMapIterator = (function cljs$core$__GT_PersistentArrayMapIterator(arr,i,cnt){ +return (new cljs.core.PersistentArrayMapIterator(arr,i,cnt)); +}); + + +/** +* @constructor + * @implements {cljs.core.IKVReduce} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEditableCollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.IMap} + * @implements {cljs.core.ILookup} + * @implements {cljs.core.IReduce} +*/ +cljs.core.PersistentArrayMap = (function (meta,cnt,arr,__hash){ +this.meta = meta; +this.cnt = cnt; +this.arr = arr; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 16647951; +this.cljs$lang$protocol_mask$partition1$ = 139268; +}); +cljs.core.PersistentArrayMap.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentArrayMap.prototype.cljs$core$IFind$_find$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +var idx = cljs.core.array_map_index_of(coll__$1,k); +if((idx === (-1))){ +return null; +} else { +return (new cljs.core.MapEntry((self__.arr[idx]),(self__.arr[(idx + (1))]),null)); +} +}); + +cljs.core.PersistentArrayMap.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentArrayMap.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentArrayMap.prototype.keys = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.keys(coll)); +}); + +cljs.core.PersistentArrayMap.prototype.entries = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_entries_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentArrayMap.prototype.values = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.vals(coll)); +}); + +cljs.core.PersistentArrayMap.prototype.has = (function (k){ +var self__ = this; +var coll = this; +return cljs.core.contains_QMARK_(coll,k); +}); + +cljs.core.PersistentArrayMap.prototype.get = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentArrayMap.prototype.forEach = (function (f){ +var self__ = this; +var coll = this; +var seq__2233 = cljs.core.seq(coll); +var chunk__2234 = null; +var count__2235 = (0); +var i__2236 = (0); +while(true){ +if((i__2236 < count__2235)){ +var vec__2237 = chunk__2234.cljs$core$IIndexed$_nth$arity$2(null,i__2236); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2237,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2237,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2249 = seq__2233; +var G__2250 = chunk__2234; +var G__2251 = count__2235; +var G__2252 = (i__2236 + (1)); +seq__2233 = G__2249; +chunk__2234 = G__2250; +count__2235 = G__2251; +i__2236 = G__2252; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2233); +if(temp__5457__auto__){ +var seq__2233__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2233__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2233__$1); +var G__2253 = cljs.core.chunk_rest(seq__2233__$1); +var G__2254 = c__4338__auto__; +var G__2255 = cljs.core.count(c__4338__auto__); +var G__2256 = (0); +seq__2233 = G__2253; +chunk__2234 = G__2254; +count__2235 = G__2255; +i__2236 = G__2256; +continue; +} else { +var vec__2240 = cljs.core.first(seq__2233__$1); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2240,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2240,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2257 = cljs.core.next(seq__2233__$1); +var G__2258 = null; +var G__2259 = (0); +var G__2260 = (0); +seq__2233 = G__2257; +chunk__2234 = G__2258; +count__2235 = G__2259; +i__2236 = G__2260; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +var idx = cljs.core.array_map_index_of(coll__$1,k); +if((idx === (-1))){ +return not_found; +} else { +return (self__.arr[(idx + (1))]); +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = (function (coll,f,init){ +var self__ = this; +var coll__$1 = this; +var len = self__.arr.length; +var i = (0); +var init__$1 = init; +while(true){ +if((i < len)){ +var init__$2 = (function (){var G__2243 = init__$1; +var G__2244 = (self__.arr[i]); +var G__2245 = (self__.arr[(i + (1))]); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2243,G__2244,G__2245) : f.call(null,G__2243,G__2244,G__2245)); +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return cljs.core.deref(init__$2); +} else { +var G__2261 = (i + (2)); +var G__2262 = init__$2; +i = G__2261; +init__$1 = G__2262; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return (new cljs.core.PersistentArrayMapIterator(self__.arr,(0),(self__.cnt * (2)))); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.PersistentArrayMap(self__.meta,self__.cnt,self__.arr,self__.__hash)); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.cnt; +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_unordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +if(((cljs.core.map_QMARK_(other)) && (!(cljs.core.record_QMARK_(other))))){ +var alen = self__.arr.length; +var other__$1 = other; +if((self__.cnt === other__$1.cljs$core$ICounted$_count$arity$1(null))){ +var i = (0); +while(true){ +if((i < alen)){ +var v = other__$1.cljs$core$ILookup$_lookup$arity$3(null,(self__.arr[i]),cljs.core.lookup_sentinel); +if(!((v === cljs.core.lookup_sentinel))){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((self__.arr[(i + (1))]),v)){ +var G__2263 = (i + (2)); +i = G__2263; +continue; +} else { +return false; +} +} else { +return false; +} +} else { +return true; +} +break; +} +} else { +return false; +} +} else { +return false; +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.TransientArrayMap({},self__.arr.length,cljs.core.aclone(self__.arr))); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.PersistentArrayMap.EMPTY,self__.meta); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$2(coll__$1,f); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.iter_reduce.cljs$core$IFn$_invoke$arity$3(coll__$1,f,start); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IMap$_dissoc$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +var idx = cljs.core.array_map_index_of(coll__$1,k); +if((idx >= (0))){ +var len = self__.arr.length; +var new_len = (len - (2)); +if((new_len === (0))){ +return coll__$1.cljs$core$IEmptyableCollection$_empty$arity$1(null); +} else { +var new_arr = (new Array(new_len)); +var s = (0); +var d = (0); +while(true){ +if((s >= len)){ +return (new cljs.core.PersistentArrayMap(self__.meta,(self__.cnt - (1)),new_arr,null)); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(k,(self__.arr[s]))){ +var G__2264 = (s + (2)); +var G__2265 = d; +s = G__2264; +d = G__2265; +continue; +} else { +(new_arr[d] = (self__.arr[s])); + +(new_arr[(d + (1))] = (self__.arr[(s + (1))])); + +var G__2266 = (s + (2)); +var G__2267 = (d + (2)); +s = G__2266; +d = G__2267; +continue; + +} +} +break; +} +} +} else { +return coll__$1; +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (coll,k,v){ +var self__ = this; +var coll__$1 = this; +var idx = cljs.core.array_map_index_of(coll__$1,k); +if((idx === (-1))){ +if((self__.cnt < cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)){ +var arr__$1 = cljs.core.array_map_extend_kv(coll__$1,k,v); +return (new cljs.core.PersistentArrayMap(self__.meta,(self__.cnt + (1)),arr__$1,null)); +} else { +return cljs.core._with_meta(cljs.core._assoc(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentHashMap.EMPTY,coll__$1),k,v),self__.meta); +} +} else { +if((v === (self__.arr[(idx + (1))]))){ +return coll__$1; +} else { +var arr__$1 = (function (){var G__2248 = cljs.core.aclone(self__.arr); +(G__2248[(idx + (1))] = v); + +return G__2248; +})(); +return (new cljs.core.PersistentArrayMap(self__.meta,self__.cnt,arr__$1,null)); + +} +} +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return !((cljs.core.array_map_index_of(coll__$1,k) === (-1))); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.persistent_array_map_seq(self__.arr,(0),null); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentArrayMap(meta__$1,self__.cnt,self__.arr,self__.__hash)); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,entry){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.vector_QMARK_(entry)){ +return coll__$1.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(1))); +} else { +var ret = coll__$1; +var es = cljs.core.seq(entry); +while(true){ +if((es == null)){ +return ret; +} else { +var e = cljs.core.first(es); +if(cljs.core.vector_QMARK_(e)){ +var G__2268 = ret.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(e,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(e,(1))); +var G__2269 = cljs.core.next(es); +ret = G__2268; +es = G__2269; +continue; +} else { +throw (new Error("conj on a map takes map entries or seqables of map entries")); +} +} +break; +} +} +}); + +cljs.core.PersistentArrayMap.prototype.call = (function() { +var G__2270 = null; +var G__2270__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2270__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2270 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2270__2.call(this,self__,k); +case 3: +return G__2270__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2270.cljs$core$IFn$_invoke$arity$2 = G__2270__2; +G__2270.cljs$core$IFn$_invoke$arity$3 = G__2270__3; +return G__2270; +})() +; + +cljs.core.PersistentArrayMap.prototype.apply = (function (self__,args2232){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2232))); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentArrayMap.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$cnt,cljs.core.cst$sym$arr,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentArrayMap.cljs$lang$type = true; + +cljs.core.PersistentArrayMap.cljs$lang$ctorStr = "cljs.core/PersistentArrayMap"; + +cljs.core.PersistentArrayMap.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentArrayMap"); +}); + +/** + * Positional factory function for cljs.core/PersistentArrayMap. + */ +cljs.core.__GT_PersistentArrayMap = (function cljs$core$__GT_PersistentArrayMap(meta,cnt,arr,__hash){ +return (new cljs.core.PersistentArrayMap(meta,cnt,arr,__hash)); +}); + +cljs.core.PersistentArrayMap.EMPTY = (new cljs.core.PersistentArrayMap(null,(0),[],cljs.core.empty_unordered_hash)); +cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD = (8); +cljs.core.PersistentArrayMap.fromArray = (function (arr,no_clone,no_check){ +var arr__$1 = ((no_clone)?arr:cljs.core.aclone(arr)); +var arr__$2 = ((no_check)?arr__$1:(function (){var ret = []; +var i_2271 = (0); +while(true){ +if((i_2271 < arr__$1.length)){ +var k_2272 = (arr__$1[i_2271]); +var v_2273 = (arr__$1[(i_2271 + (1))]); +var idx_2274 = cljs.core.array_index_of(ret,k_2272); +if((idx_2274 === (-1))){ +ret.push(k_2272); + +ret.push(v_2273); +} else { +} + +var G__2275 = (i_2271 + (2)); +i_2271 = G__2275; +continue; +} else { +} +break; +} + +return ret; +})()); +var cnt = (arr__$2.length / (2)); +return (new cljs.core.PersistentArrayMap(null,cnt,arr__$2,null)); +}); +cljs.core.PersistentArrayMap.createWithCheck = (function (arr){ +var ret = []; +var i_2277 = (0); +while(true){ +if((i_2277 < arr.length)){ +var k_2278 = (arr[i_2277]); +var v_2279 = (arr[(i_2277 + (1))]); +var idx_2280 = cljs.core.array_index_of(ret,k_2278); +if((idx_2280 === (-1))){ +var G__2276_2281 = ret; +G__2276_2281.push(k_2278); + +G__2276_2281.push(v_2279); + +} else { +throw (new Error(["Duplicate key: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(k_2278)].join(''))); +} + +var G__2282 = (i_2277 + (2)); +i_2277 = G__2282; +continue; +} else { +} +break; +} + +var cnt = (arr.length / (2)); +return (new cljs.core.PersistentArrayMap(null,cnt,arr,null)); +}); +cljs.core.PersistentArrayMap.createAsIfByAssoc = (function (arr){ +var ret = []; +var i_2284 = (0); +while(true){ +if((i_2284 < arr.length)){ +var k_2285 = (arr[i_2284]); +var v_2286 = (arr[(i_2284 + (1))]); +var idx_2287 = cljs.core.array_index_of(ret,k_2285); +if((idx_2287 === (-1))){ +var G__2283_2288 = ret; +G__2283_2288.push(k_2285); + +G__2283_2288.push(v_2286); + +} else { +(ret[(idx_2287 + (1))] = v_2286); +} + +var G__2289 = (i_2284 + (2)); +i_2284 = G__2289; +continue; +} else { +} +break; +} + +return (new cljs.core.PersistentArrayMap(null,(ret.length / (2)),ret,null)); +}); +var G__2290_2293 = cljs.core.PersistentArrayMap.prototype; +var G__2291_2294 = cljs.core.ITER_SYMBOL; +var G__2292_2295 = ((function (G__2290_2293,G__2291_2294){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2290_2293,G__2291_2294)) +; +goog.object.set(G__2290_2293,G__2291_2294,G__2292_2295); + +/** +* @constructor + * @implements {cljs.core.IFn} + * @implements {cljs.core.ITransientMap} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ITransientCollection} + * @implements {cljs.core.ITransientAssociative} + * @implements {cljs.core.ILookup} +*/ +cljs.core.TransientArrayMap = (function (editable_QMARK_,len,arr){ +this.editable_QMARK_ = editable_QMARK_; +this.len = len; +this.arr = arr; +this.cljs$lang$protocol_mask$partition0$ = 259; +this.cljs$lang$protocol_mask$partition1$ = 56; +}); +cljs.core.TransientArrayMap.prototype.cljs$core$ICounted$_count$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +if(cljs.core.truth_(self__.editable_QMARK_)){ +return cljs.core.quot(self__.len,(2)); +} else { +throw (new Error("count after persistent!")); +} +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (tcoll,k){ +var self__ = this; +var tcoll__$1 = this; +return tcoll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (tcoll,k,not_found){ +var self__ = this; +var tcoll__$1 = this; +if(cljs.core.truth_(self__.editable_QMARK_)){ +var idx = cljs.core.array_map_index_of(tcoll__$1,k); +if((idx === (-1))){ +return not_found; +} else { +return (self__.arr[(idx + (1))]); +} +} else { +throw (new Error("lookup after persistent!")); +} +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = (function (tcoll,o){ +var self__ = this; +var tcoll__$1 = this; +if(cljs.core.truth_(self__.editable_QMARK_)){ +if(cljs.core.map_entry_QMARK_(o)){ +return tcoll__$1.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(null,cljs.core.key(o),cljs.core.val(o)); +} else { +if(cljs.core.vector_QMARK_(o)){ +return tcoll__$1.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(null,(o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((0)) : o.call(null,(0))),(o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((1)) : o.call(null,(1)))); +} else { +var es = cljs.core.seq(o); +var tcoll__$2 = tcoll__$1; +while(true){ +var temp__5455__auto__ = cljs.core.first(es); +if(cljs.core.truth_(temp__5455__auto__)){ +var e = temp__5455__auto__; +var G__2298 = cljs.core.next(es); +var G__2299 = tcoll__$2.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(null,cljs.core.key(e),cljs.core.val(e)); +es = G__2298; +tcoll__$2 = G__2299; +continue; +} else { +return tcoll__$2; +} +break; +} + +} +} +} else { +throw (new Error("conj! after persistent!")); +} +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +if(cljs.core.truth_(self__.editable_QMARK_)){ +self__.editable_QMARK_ = false; + +return (new cljs.core.PersistentArrayMap(null,cljs.core.quot(self__.len,(2)),self__.arr,null)); +} else { +throw (new Error("persistent! called twice")); +} +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = (function (tcoll,key,val){ +var self__ = this; +var tcoll__$1 = this; +if(cljs.core.truth_(self__.editable_QMARK_)){ +var idx = cljs.core.array_map_index_of(tcoll__$1,key); +if((idx === (-1))){ +if(((self__.len + (2)) <= ((2) * cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD))){ +self__.len = (self__.len + (2)); + +self__.arr.push(key); + +self__.arr.push(val); + +return tcoll__$1; +} else { +return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(cljs.core.array__GT_transient_hash_map(self__.len,self__.arr),key,val); +} +} else { +if((val === (self__.arr[(idx + (1))]))){ +return tcoll__$1; +} else { +(self__.arr[(idx + (1))] = val); + +return tcoll__$1; +} +} +} else { +throw (new Error("assoc! after persistent!")); +} +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = (function (tcoll,key){ +var self__ = this; +var tcoll__$1 = this; +if(cljs.core.truth_(self__.editable_QMARK_)){ +var idx = cljs.core.array_map_index_of(tcoll__$1,key); +if((idx >= (0))){ +(self__.arr[idx] = (self__.arr[(self__.len - (2))])); + +(self__.arr[(idx + (1))] = (self__.arr[(self__.len - (1))])); + +var G__2297_2300 = self__.arr; +G__2297_2300.pop(); + +G__2297_2300.pop(); + + +self__.len = (self__.len - (2)); +} else { +} + +return tcoll__$1; +} else { +throw (new Error("dissoc! after persistent!")); +} +}); + +cljs.core.TransientArrayMap.prototype.call = (function() { +var G__2301 = null; +var G__2301__2 = (function (self__,key){ +var self__ = this; +var self____$1 = this; +var tcoll = self____$1; +return tcoll.cljs$core$ILookup$_lookup$arity$3(null,key,null); +}); +var G__2301__3 = (function (self__,key,not_found){ +var self__ = this; +var self____$1 = this; +var tcoll = self____$1; +return tcoll.cljs$core$ILookup$_lookup$arity$3(null,key,not_found); +}); +G__2301 = function(self__,key,not_found){ +switch(arguments.length){ +case 2: +return G__2301__2.call(this,self__,key); +case 3: +return G__2301__3.call(this,self__,key,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2301.cljs$core$IFn$_invoke$arity$2 = G__2301__2; +G__2301.cljs$core$IFn$_invoke$arity$3 = G__2301__3; +return G__2301; +})() +; + +cljs.core.TransientArrayMap.prototype.apply = (function (self__,args2296){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2296))); +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$IFn$_invoke$arity$1 = (function (key){ +var self__ = this; +var tcoll = this; +return tcoll.cljs$core$ILookup$_lookup$arity$3(null,key,null); +}); + +cljs.core.TransientArrayMap.prototype.cljs$core$IFn$_invoke$arity$2 = (function (key,not_found){ +var self__ = this; +var tcoll = this; +return tcoll.cljs$core$ILookup$_lookup$arity$3(null,key,not_found); +}); + +cljs.core.TransientArrayMap.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$editable_QMARK_,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$len,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$arr], null); +}); + +cljs.core.TransientArrayMap.cljs$lang$type = true; + +cljs.core.TransientArrayMap.cljs$lang$ctorStr = "cljs.core/TransientArrayMap"; + +cljs.core.TransientArrayMap.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/TransientArrayMap"); +}); + +/** + * Positional factory function for cljs.core/TransientArrayMap. + */ +cljs.core.__GT_TransientArrayMap = (function cljs$core$__GT_TransientArrayMap(editable_QMARK_,len,arr){ +return (new cljs.core.TransientArrayMap(editable_QMARK_,len,arr)); +}); + +cljs.core.array__GT_transient_hash_map = (function cljs$core$array__GT_transient_hash_map(len,arr){ +var out = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY); +var i = (0); +while(true){ +if((i < len)){ +var G__2302 = cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,(arr[i]),(arr[(i + (1))])); +var G__2303 = (i + (2)); +out = G__2302; +i = G__2303; +continue; +} else { +return out; +} +break; +} +}); + +/** +* @constructor +*/ +cljs.core.Box = (function (val){ +this.val = val; +}); + +cljs.core.Box.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$val,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Box.cljs$lang$type = true; + +cljs.core.Box.cljs$lang$ctorStr = "cljs.core/Box"; + +cljs.core.Box.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Box"); +}); + +/** + * Positional factory function for cljs.core/Box. + */ +cljs.core.__GT_Box = (function cljs$core$__GT_Box(val){ +return (new cljs.core.Box(val)); +}); + + + + + + +cljs.core.key_test = (function cljs$core$key_test(key,other){ +if((key === other)){ +return true; +} else { +if(cljs.core.keyword_identical_QMARK_(key,other)){ +return true; +} else { +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(key,other); + +} +} +}); +cljs.core.mask = (function cljs$core$mask(hash,shift){ +return ((hash >>> shift) & (31)); +}); +cljs.core.clone_and_set = (function cljs$core$clone_and_set(var_args){ +var G__2305 = arguments.length; +switch (G__2305) { +case 3: +return cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 5: +return cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3 = (function (arr,i,a){ +var G__2306 = cljs.core.aclone(arr); +(G__2306[i] = a); + +return G__2306; +}); + +cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$5 = (function (arr,i,a,j,b){ +var G__2307 = cljs.core.aclone(arr); +(G__2307[i] = a); + +(G__2307[j] = b); + +return G__2307; +}); + +cljs.core.clone_and_set.cljs$lang$maxFixedArity = 5; + +cljs.core.remove_pair = (function cljs$core$remove_pair(arr,i){ +var new_arr = (new Array((arr.length - (2)))); +cljs.core.array_copy(arr,(0),new_arr,(0),((2) * i)); + +cljs.core.array_copy(arr,((2) * (i + (1))),new_arr,((2) * i),(new_arr.length - ((2) * i))); + +return new_arr; +}); +cljs.core.bitmap_indexed_node_index = (function cljs$core$bitmap_indexed_node_index(bitmap,bit){ +return cljs.core.bit_count((bitmap & (bit - (1)))); +}); +cljs.core.bitpos = (function cljs$core$bitpos(hash,shift){ +return ((1) << ((hash >>> shift) & 0x01f)); +}); +cljs.core.edit_and_set = (function cljs$core$edit_and_set(var_args){ +var G__2310 = arguments.length; +switch (G__2310) { +case 4: +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 6: +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4 = (function (inode,edit,i,a){ +var editable = inode.ensure_editable(edit); +(editable.arr[i] = a); + +return editable; +}); + +cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6 = (function (inode,edit,i,a,j,b){ +var editable = inode.ensure_editable(edit); +(editable.arr[i] = a); + +(editable.arr[j] = b); + +return editable; +}); + +cljs.core.edit_and_set.cljs$lang$maxFixedArity = 6; + +cljs.core.inode_kv_reduce = (function cljs$core$inode_kv_reduce(arr,f,init){ +var len = arr.length; +var i = (0); +var init__$1 = init; +while(true){ +if((i < len)){ +var init__$2 = (function (){var k = (arr[i]); +if(!((k == null))){ +var G__2312 = init__$1; +var G__2313 = k; +var G__2314 = (arr[(i + (1))]); +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2312,G__2313,G__2314) : f.call(null,G__2312,G__2313,G__2314)); +} else { +var node = (arr[(i + (1))]); +if(!((node == null))){ +return node.kv_reduce(f,init__$1); +} else { +return init__$1; +} +} +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return init__$2; +} else { +var G__2315 = (i + (2)); +var G__2316 = init__$2; +i = G__2315; +init__$1 = G__2316; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +/** +* @constructor +*/ +cljs.core.NodeIterator = (function (arr,i,next_entry,next_iter){ +this.arr = arr; +this.i = i; +this.next_entry = next_entry; +this.next_iter = next_iter; +}); +cljs.core.NodeIterator.prototype.advance = (function (){ +var self__ = this; +var this$ = this; +var len = self__.arr.length; +while(true){ +if((self__.i < len)){ +var key = (self__.arr[self__.i]); +var node_or_val = (self__.arr[(self__.i + (1))]); +var found = ((!((key == null)))?self__.next_entry = (new cljs.core.MapEntry(key,node_or_val,null)):((!((node_or_val == null)))?(function (){var new_iter = cljs.core._iterator(node_or_val); +if(new_iter.hasNext()){ +return self__.next_iter = new_iter; +} else { +return false; +} +})():false +)); +self__.i = (self__.i + (2)); + +if(found){ +return true; +} else { +continue; +} +} else { +return false; +} +break; +} +}); + +cljs.core.NodeIterator.prototype.hasNext = (function (){ +var self__ = this; +var this$ = this; +var or__3936__auto__ = !((self__.next_entry == null)); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = !((self__.next_iter == null)); +if(or__3936__auto____$1){ +return or__3936__auto____$1; +} else { +return this$.advance(); +} +} +}); + +cljs.core.NodeIterator.prototype.next = (function (){ +var self__ = this; +var this$ = this; +if(!((self__.next_entry == null))){ +var ret = self__.next_entry; +self__.next_entry = null; + +return ret; +} else { +if(!((self__.next_iter == null))){ +var ret = self__.next_iter.next(); +if(self__.next_iter.hasNext()){ +} else { +self__.next_iter = null; +} + +return ret; +} else { +if(this$.advance()){ +return this$.next(); +} else { +throw (new Error("No such element")); + +} +} +} +}); + +cljs.core.NodeIterator.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.NodeIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$next_DASH_entry,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$next_DASH_iter,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.NodeIterator.cljs$lang$type = true; + +cljs.core.NodeIterator.cljs$lang$ctorStr = "cljs.core/NodeIterator"; + +cljs.core.NodeIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/NodeIterator"); +}); + +/** + * Positional factory function for cljs.core/NodeIterator. + */ +cljs.core.__GT_NodeIterator = (function cljs$core$__GT_NodeIterator(arr,i,next_entry,next_iter){ +return (new cljs.core.NodeIterator(arr,i,next_entry,next_iter)); +}); + + +/** +* @constructor + * @implements {cljs.core.IIterable} +*/ +cljs.core.BitmapIndexedNode = (function (edit,bitmap,arr){ +this.edit = edit; +this.bitmap = bitmap; +this.arr = arr; +this.cljs$lang$protocol_mask$partition1$ = 131072; +this.cljs$lang$protocol_mask$partition0$ = 0; +}); +cljs.core.BitmapIndexedNode.prototype.ensure_editable = (function (e){ +var self__ = this; +var inode = this; +if((e === self__.edit)){ +return inode; +} else { +var n = cljs.core.bit_count(self__.bitmap); +var new_arr = (new Array((((n < (0)))?(4):((2) * (n + (1)))))); +cljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * n)); + +return (new cljs.core.BitmapIndexedNode(e,self__.bitmap,new_arr)); +} +}); + +cljs.core.BitmapIndexedNode.prototype.inode_without_BANG_ = (function (edit__$1,shift,hash,key,removed_leaf_QMARK_){ +var self__ = this; +var inode = this; +var bit = (1 << ((hash >>> shift) & 0x01f)); +if(((self__.bitmap & bit) === (0))){ +return inode; +} else { +var idx = cljs.core.bitmap_indexed_node_index(self__.bitmap,bit); +var key_or_nil = (self__.arr[((2) * idx)]); +var val_or_node = (self__.arr[(((2) * idx) + (1))]); +if((key_or_nil == null)){ +var n = val_or_node.inode_without_BANG_(edit__$1,(shift + (5)),hash,key,removed_leaf_QMARK_); +if((n === val_or_node)){ +return inode; +} else { +if(!((n == null))){ +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(((2) * idx) + (1)),n); +} else { +if((self__.bitmap === bit)){ +return null; +} else { +return inode.edit_and_remove_pair(edit__$1,bit,idx); + +} +} +} +} else { +if(cljs.core.key_test(key,key_or_nil)){ +removed_leaf_QMARK_.val = true; + +return inode.edit_and_remove_pair(edit__$1,bit,idx); +} else { +return inode; + +} +} +} +}); + +cljs.core.BitmapIndexedNode.prototype.edit_and_remove_pair = (function (e,bit,i){ +var self__ = this; +var inode = this; +if((self__.bitmap === bit)){ +return null; +} else { +var editable = inode.ensure_editable(e); +var earr = editable.arr; +var len = earr.length; +editable.bitmap = (bit ^ editable.bitmap); + +cljs.core.array_copy(earr,((2) * (i + (1))),earr,((2) * i),(len - ((2) * (i + (1))))); + +(earr[(len - (2))] = null); + +(earr[(len - (1))] = null); + +return editable; +} +}); + +cljs.core.BitmapIndexedNode.prototype.inode_seq = (function (){ +var self__ = this; +var inode = this; +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1(self__.arr); +}); + +cljs.core.BitmapIndexedNode.prototype.kv_reduce = (function (f,init){ +var self__ = this; +var inode = this; +return cljs.core.inode_kv_reduce(self__.arr,f,init); +}); + +cljs.core.BitmapIndexedNode.prototype.inode_lookup = (function (shift,hash,key,not_found){ +var self__ = this; +var inode = this; +var bit = (1 << ((hash >>> shift) & 0x01f)); +if(((self__.bitmap & bit) === (0))){ +return not_found; +} else { +var idx = cljs.core.bitmap_indexed_node_index(self__.bitmap,bit); +var key_or_nil = (self__.arr[((2) * idx)]); +var val_or_node = (self__.arr[(((2) * idx) + (1))]); +if((key_or_nil == null)){ +return val_or_node.inode_lookup((shift + (5)),hash,key,not_found); +} else { +if(cljs.core.key_test(key,key_or_nil)){ +return val_or_node; +} else { +return not_found; + +} +} +} +}); + +cljs.core.BitmapIndexedNode.prototype.inode_assoc_BANG_ = (function (edit__$1,shift,hash,key,val,added_leaf_QMARK_){ +var self__ = this; +var inode = this; +var bit = (1 << ((hash >>> shift) & 0x01f)); +var idx = cljs.core.bitmap_indexed_node_index(self__.bitmap,bit); +if(((self__.bitmap & bit) === (0))){ +var n = cljs.core.bit_count(self__.bitmap); +if((((2) * n) < self__.arr.length)){ +var editable = inode.ensure_editable(edit__$1); +var earr = editable.arr; +added_leaf_QMARK_.val = true; + +cljs.core.array_copy_downward(earr,((2) * idx),earr,((2) * (idx + (1))),((2) * (n - idx))); + +(earr[((2) * idx)] = key); + +(earr[(((2) * idx) + (1))] = val); + +editable.bitmap = (editable.bitmap | bit); + +return editable; +} else { +if((n >= (16))){ +var nodes = [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]; +var jdx = ((hash >>> shift) & 0x01f); +(nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_)); + +var i_2317 = (0); +var j_2318 = (0); +while(true){ +if((i_2317 < (32))){ +if((((self__.bitmap >>> i_2317) & (1)) === (0))){ +var G__2319 = (i_2317 + (1)); +var G__2320 = j_2318; +i_2317 = G__2319; +j_2318 = G__2320; +continue; +} else { +(nodes[i_2317] = ((!(((self__.arr[j_2318]) == null)))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + (5)),cljs.core.hash((self__.arr[j_2318])),(self__.arr[j_2318]),(self__.arr[(j_2318 + (1))]),added_leaf_QMARK_):(self__.arr[(j_2318 + (1))]))); + +var G__2321 = (i_2317 + (1)); +var G__2322 = (j_2318 + (2)); +i_2317 = G__2321; +j_2318 = G__2322; +continue; +} +} else { +} +break; +} + +return (new cljs.core.ArrayNode(edit__$1,(n + (1)),nodes)); +} else { +var new_arr = (new Array(((2) * (n + (4))))); +cljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * idx)); + +(new_arr[((2) * idx)] = key); + +(new_arr[(((2) * idx) + (1))] = val); + +cljs.core.array_copy(self__.arr,((2) * idx),new_arr,((2) * (idx + (1))),((2) * (n - idx))); + +added_leaf_QMARK_.val = true; + +var editable = inode.ensure_editable(edit__$1); +editable.arr = new_arr; + +editable.bitmap = (editable.bitmap | bit); + +return editable; + +} +} +} else { +var key_or_nil = (self__.arr[((2) * idx)]); +var val_or_node = (self__.arr[(((2) * idx) + (1))]); +if((key_or_nil == null)){ +var n = val_or_node.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_); +if((n === val_or_node)){ +return inode; +} else { +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(((2) * idx) + (1)),n); +} +} else { +if(cljs.core.key_test(key,key_or_nil)){ +if((val === val_or_node)){ +return inode; +} else { +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(((2) * idx) + (1)),val); +} +} else { +added_leaf_QMARK_.val = true; + +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6(inode,edit__$1,((2) * idx),null,(((2) * idx) + (1)),cljs.core.create_node.cljs$core$IFn$_invoke$arity$7(edit__$1,(shift + (5)),key_or_nil,val_or_node,hash,key,val)); + +} +} +} +}); + +cljs.core.BitmapIndexedNode.prototype.inode_assoc = (function (shift,hash,key,val,added_leaf_QMARK_){ +var self__ = this; +var inode = this; +var bit = (1 << ((hash >>> shift) & 0x01f)); +var idx = cljs.core.bitmap_indexed_node_index(self__.bitmap,bit); +if(((self__.bitmap & bit) === (0))){ +var n = cljs.core.bit_count(self__.bitmap); +if((n >= (16))){ +var nodes = [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]; +var jdx = ((hash >>> shift) & 0x01f); +(nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_)); + +var i_2323 = (0); +var j_2324 = (0); +while(true){ +if((i_2323 < (32))){ +if((((self__.bitmap >>> i_2323) & (1)) === (0))){ +var G__2325 = (i_2323 + (1)); +var G__2326 = j_2324; +i_2323 = G__2325; +j_2324 = G__2326; +continue; +} else { +(nodes[i_2323] = ((!(((self__.arr[j_2324]) == null)))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + (5)),cljs.core.hash((self__.arr[j_2324])),(self__.arr[j_2324]),(self__.arr[(j_2324 + (1))]),added_leaf_QMARK_):(self__.arr[(j_2324 + (1))]))); + +var G__2327 = (i_2323 + (1)); +var G__2328 = (j_2324 + (2)); +i_2323 = G__2327; +j_2324 = G__2328; +continue; +} +} else { +} +break; +} + +return (new cljs.core.ArrayNode(null,(n + (1)),nodes)); +} else { +var new_arr = (new Array(((2) * (n + (1))))); +cljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * idx)); + +(new_arr[((2) * idx)] = key); + +(new_arr[(((2) * idx) + (1))] = val); + +cljs.core.array_copy(self__.arr,((2) * idx),new_arr,((2) * (idx + (1))),((2) * (n - idx))); + +added_leaf_QMARK_.val = true; + +return (new cljs.core.BitmapIndexedNode(null,(self__.bitmap | bit),new_arr)); +} +} else { +var key_or_nil = (self__.arr[((2) * idx)]); +var val_or_node = (self__.arr[(((2) * idx) + (1))]); +if((key_or_nil == null)){ +var n = val_or_node.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_); +if((n === val_or_node)){ +return inode; +} else { +return (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(((2) * idx) + (1)),n))); +} +} else { +if(cljs.core.key_test(key,key_or_nil)){ +if((val === val_or_node)){ +return inode; +} else { +return (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(((2) * idx) + (1)),val))); +} +} else { +added_leaf_QMARK_.val = true; + +return (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$5(self__.arr,((2) * idx),null,(((2) * idx) + (1)),cljs.core.create_node.cljs$core$IFn$_invoke$arity$6((shift + (5)),key_or_nil,val_or_node,hash,key,val)))); + +} +} +} +}); + +cljs.core.BitmapIndexedNode.prototype.inode_find = (function (shift,hash,key,not_found){ +var self__ = this; +var inode = this; +var bit = (1 << ((hash >>> shift) & 0x01f)); +if(((self__.bitmap & bit) === (0))){ +return not_found; +} else { +var idx = cljs.core.bitmap_indexed_node_index(self__.bitmap,bit); +var key_or_nil = (self__.arr[((2) * idx)]); +var val_or_node = (self__.arr[(((2) * idx) + (1))]); +if((key_or_nil == null)){ +return val_or_node.inode_find((shift + (5)),hash,key,not_found); +} else { +if(cljs.core.key_test(key,key_or_nil)){ +return (new cljs.core.MapEntry(key_or_nil,val_or_node,null)); +} else { +return not_found; + +} +} +} +}); + +cljs.core.BitmapIndexedNode.prototype.inode_without = (function (shift,hash,key){ +var self__ = this; +var inode = this; +var bit = (1 << ((hash >>> shift) & 0x01f)); +if(((self__.bitmap & bit) === (0))){ +return inode; +} else { +var idx = cljs.core.bitmap_indexed_node_index(self__.bitmap,bit); +var key_or_nil = (self__.arr[((2) * idx)]); +var val_or_node = (self__.arr[(((2) * idx) + (1))]); +if((key_or_nil == null)){ +var n = val_or_node.inode_without((shift + (5)),hash,key); +if((n === val_or_node)){ +return inode; +} else { +if(!((n == null))){ +return (new cljs.core.BitmapIndexedNode(null,self__.bitmap,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(((2) * idx) + (1)),n))); +} else { +if((self__.bitmap === bit)){ +return null; +} else { +return (new cljs.core.BitmapIndexedNode(null,(self__.bitmap ^ bit),cljs.core.remove_pair(self__.arr,idx))); + +} +} +} +} else { +if(cljs.core.key_test(key,key_or_nil)){ +return (new cljs.core.BitmapIndexedNode(null,(self__.bitmap ^ bit),cljs.core.remove_pair(self__.arr,idx))); +} else { +return inode; + +} +} +} +}); + +cljs.core.BitmapIndexedNode.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.NodeIterator(self__.arr,(0),null,null)); +}); + +cljs.core.BitmapIndexedNode.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$edit,cljs.core.with_meta(cljs.core.cst$sym$bitmap,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$arr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.BitmapIndexedNode.cljs$lang$type = true; + +cljs.core.BitmapIndexedNode.cljs$lang$ctorStr = "cljs.core/BitmapIndexedNode"; + +cljs.core.BitmapIndexedNode.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/BitmapIndexedNode"); +}); + +/** + * Positional factory function for cljs.core/BitmapIndexedNode. + */ +cljs.core.__GT_BitmapIndexedNode = (function cljs$core$__GT_BitmapIndexedNode(edit,bitmap,arr){ +return (new cljs.core.BitmapIndexedNode(edit,bitmap,arr)); +}); + +cljs.core.BitmapIndexedNode.EMPTY = (new cljs.core.BitmapIndexedNode(null,(0),[])); +cljs.core.pack_array_node = (function cljs$core$pack_array_node(array_node,edit,idx){ +var arr = array_node.arr; +var len = arr.length; +var new_arr = (new Array(((2) * (array_node.cnt - (1))))); +var i = (0); +var j = (1); +var bitmap = (0); +while(true){ +if((i < len)){ +if(((!((i === idx))) && (!(((arr[i]) == null))))){ +(new_arr[j] = (arr[i])); + +var G__2329 = (i + (1)); +var G__2330 = (j + (2)); +var G__2331 = (bitmap | ((1) << i)); +i = G__2329; +j = G__2330; +bitmap = G__2331; +continue; +} else { +var G__2332 = (i + (1)); +var G__2333 = j; +var G__2334 = bitmap; +i = G__2332; +j = G__2333; +bitmap = G__2334; +continue; +} +} else { +return (new cljs.core.BitmapIndexedNode(edit,bitmap,new_arr)); +} +break; +} +}); + +/** +* @constructor +*/ +cljs.core.ArrayNodeIterator = (function (arr,i,next_iter){ +this.arr = arr; +this.i = i; +this.next_iter = next_iter; +}); +cljs.core.ArrayNodeIterator.prototype.hasNext = (function (){ +var self__ = this; +var this$ = this; +var len = self__.arr.length; +while(true){ +if(!(((!((self__.next_iter == null))) && (self__.next_iter.hasNext())))){ +if((self__.i < len)){ +var node = (self__.arr[self__.i]); +self__.i = (self__.i + (1)); + +if(!((node == null))){ +self__.next_iter = cljs.core._iterator(node); +} else { +} + +continue; +} else { +return false; +} +} else { +return true; +} +break; +} +}); + +cljs.core.ArrayNodeIterator.prototype.next = (function (){ +var self__ = this; +var this$ = this; +if(this$.hasNext()){ +return self__.next_iter.next(); +} else { +throw (new Error("No such element")); +} +}); + +cljs.core.ArrayNodeIterator.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.ArrayNodeIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$arr,cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$next_DASH_iter,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ArrayNodeIterator.cljs$lang$type = true; + +cljs.core.ArrayNodeIterator.cljs$lang$ctorStr = "cljs.core/ArrayNodeIterator"; + +cljs.core.ArrayNodeIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ArrayNodeIterator"); +}); + +/** + * Positional factory function for cljs.core/ArrayNodeIterator. + */ +cljs.core.__GT_ArrayNodeIterator = (function cljs$core$__GT_ArrayNodeIterator(arr,i,next_iter){ +return (new cljs.core.ArrayNodeIterator(arr,i,next_iter)); +}); + + +/** +* @constructor + * @implements {cljs.core.IIterable} +*/ +cljs.core.ArrayNode = (function (edit,cnt,arr){ +this.edit = edit; +this.cnt = cnt; +this.arr = arr; +this.cljs$lang$protocol_mask$partition1$ = 131072; +this.cljs$lang$protocol_mask$partition0$ = 0; +}); +cljs.core.ArrayNode.prototype.ensure_editable = (function (e){ +var self__ = this; +var inode = this; +if((e === self__.edit)){ +return inode; +} else { +return (new cljs.core.ArrayNode(e,self__.cnt,cljs.core.aclone(self__.arr))); +} +}); + +cljs.core.ArrayNode.prototype.inode_without_BANG_ = (function (edit__$1,shift,hash,key,removed_leaf_QMARK_){ +var self__ = this; +var inode = this; +var idx = ((hash >>> shift) & 0x01f); +var node = (self__.arr[idx]); +if((node == null)){ +return inode; +} else { +var n = node.inode_without_BANG_(edit__$1,(shift + (5)),hash,key,removed_leaf_QMARK_); +if((n === node)){ +return inode; +} else { +if((n == null)){ +if((self__.cnt <= (8))){ +return cljs.core.pack_array_node(inode,edit__$1,idx); +} else { +var editable = cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,n); +editable.cnt = (editable.cnt - (1)); + +return editable; +} +} else { +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,n); + +} +} +} +}); + +cljs.core.ArrayNode.prototype.inode_seq = (function (){ +var self__ = this; +var inode = this; +return cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1(self__.arr); +}); + +cljs.core.ArrayNode.prototype.kv_reduce = (function (f,init){ +var self__ = this; +var inode = this; +var len = self__.arr.length; +var i = (0); +var init__$1 = init; +while(true){ +if((i < len)){ +var node = (self__.arr[i]); +if(!((node == null))){ +var init__$2 = node.kv_reduce(f,init__$1); +if(cljs.core.reduced_QMARK_(init__$2)){ +return init__$2; +} else { +var G__2335 = (i + (1)); +var G__2336 = init__$2; +i = G__2335; +init__$1 = G__2336; +continue; +} +} else { +var G__2337 = (i + (1)); +var G__2338 = init__$1; +i = G__2337; +init__$1 = G__2338; +continue; +} +} else { +return init__$1; +} +break; +} +}); + +cljs.core.ArrayNode.prototype.inode_lookup = (function (shift,hash,key,not_found){ +var self__ = this; +var inode = this; +var idx = ((hash >>> shift) & 0x01f); +var node = (self__.arr[idx]); +if(!((node == null))){ +return node.inode_lookup((shift + (5)),hash,key,not_found); +} else { +return not_found; +} +}); + +cljs.core.ArrayNode.prototype.inode_assoc_BANG_ = (function (edit__$1,shift,hash,key,val,added_leaf_QMARK_){ +var self__ = this; +var inode = this; +var idx = ((hash >>> shift) & 0x01f); +var node = (self__.arr[idx]); +if((node == null)){ +var editable = cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_)); +editable.cnt = (editable.cnt + (1)); + +return editable; +} else { +var n = node.inode_assoc_BANG_(edit__$1,(shift + (5)),hash,key,val,added_leaf_QMARK_); +if((n === node)){ +return inode; +} else { +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,idx,n); +} +} +}); + +cljs.core.ArrayNode.prototype.inode_assoc = (function (shift,hash,key,val,added_leaf_QMARK_){ +var self__ = this; +var inode = this; +var idx = ((hash >>> shift) & 0x01f); +var node = (self__.arr[idx]); +if((node == null)){ +return (new cljs.core.ArrayNode(null,(self__.cnt + (1)),cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_)))); +} else { +var n = node.inode_assoc((shift + (5)),hash,key,val,added_leaf_QMARK_); +if((n === node)){ +return inode; +} else { +return (new cljs.core.ArrayNode(null,self__.cnt,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,n))); +} +} +}); + +cljs.core.ArrayNode.prototype.inode_find = (function (shift,hash,key,not_found){ +var self__ = this; +var inode = this; +var idx = ((hash >>> shift) & 0x01f); +var node = (self__.arr[idx]); +if(!((node == null))){ +return node.inode_find((shift + (5)),hash,key,not_found); +} else { +return not_found; +} +}); + +cljs.core.ArrayNode.prototype.inode_without = (function (shift,hash,key){ +var self__ = this; +var inode = this; +var idx = ((hash >>> shift) & 0x01f); +var node = (self__.arr[idx]); +if(!((node == null))){ +var n = node.inode_without((shift + (5)),hash,key); +if((n === node)){ +return inode; +} else { +if((n == null)){ +if((self__.cnt <= (8))){ +return cljs.core.pack_array_node(inode,null,idx); +} else { +return (new cljs.core.ArrayNode(null,(self__.cnt - (1)),cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,n))); +} +} else { +return (new cljs.core.ArrayNode(null,self__.cnt,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,idx,n))); + +} +} +} else { +return inode; +} +}); + +cljs.core.ArrayNode.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.ArrayNodeIterator(self__.arr,(0),null)); +}); + +cljs.core.ArrayNode.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$edit,cljs.core.with_meta(cljs.core.cst$sym$cnt,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$arr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ArrayNode.cljs$lang$type = true; + +cljs.core.ArrayNode.cljs$lang$ctorStr = "cljs.core/ArrayNode"; + +cljs.core.ArrayNode.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ArrayNode"); +}); + +/** + * Positional factory function for cljs.core/ArrayNode. + */ +cljs.core.__GT_ArrayNode = (function cljs$core$__GT_ArrayNode(edit,cnt,arr){ +return (new cljs.core.ArrayNode(edit,cnt,arr)); +}); + +cljs.core.hash_collision_node_find_index = (function cljs$core$hash_collision_node_find_index(arr,cnt,key){ +var lim = ((2) * cnt); +var i = (0); +while(true){ +if((i < lim)){ +if(cljs.core.key_test(key,(arr[i]))){ +return i; +} else { +var G__2339 = (i + (2)); +i = G__2339; +continue; +} +} else { +return (-1); +} +break; +} +}); + +/** +* @constructor + * @implements {cljs.core.IIterable} +*/ +cljs.core.HashCollisionNode = (function (edit,collision_hash,cnt,arr){ +this.edit = edit; +this.collision_hash = collision_hash; +this.cnt = cnt; +this.arr = arr; +this.cljs$lang$protocol_mask$partition1$ = 131072; +this.cljs$lang$protocol_mask$partition0$ = 0; +}); +cljs.core.HashCollisionNode.prototype.ensure_editable = (function (e){ +var self__ = this; +var inode = this; +if((e === self__.edit)){ +return inode; +} else { +var new_arr = (new Array(((2) * (self__.cnt + (1))))); +cljs.core.array_copy(self__.arr,(0),new_arr,(0),((2) * self__.cnt)); + +return (new cljs.core.HashCollisionNode(e,self__.collision_hash,self__.cnt,new_arr)); +} +}); + +cljs.core.HashCollisionNode.prototype.inode_without_BANG_ = (function (edit__$1,shift,hash,key,removed_leaf_QMARK_){ +var self__ = this; +var inode = this; +var idx = cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key); +if((idx === (-1))){ +return inode; +} else { +removed_leaf_QMARK_.val = true; + +if((self__.cnt === (1))){ +return null; +} else { +var editable = inode.ensure_editable(edit__$1); +var earr = editable.arr; +(earr[idx] = (earr[(((2) * self__.cnt) - (2))])); + +(earr[(idx + (1))] = (earr[(((2) * self__.cnt) - (1))])); + +(earr[(((2) * self__.cnt) - (1))] = null); + +(earr[(((2) * self__.cnt) - (2))] = null); + +editable.cnt = (editable.cnt - (1)); + +return editable; +} +} +}); + +cljs.core.HashCollisionNode.prototype.inode_seq = (function (){ +var self__ = this; +var inode = this; +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1(self__.arr); +}); + +cljs.core.HashCollisionNode.prototype.kv_reduce = (function (f,init){ +var self__ = this; +var inode = this; +return cljs.core.inode_kv_reduce(self__.arr,f,init); +}); + +cljs.core.HashCollisionNode.prototype.inode_lookup = (function (shift,hash,key,not_found){ +var self__ = this; +var inode = this; +var idx = cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key); +if((idx < (0))){ +return not_found; +} else { +if(cljs.core.key_test(key,(self__.arr[idx]))){ +return (self__.arr[(idx + (1))]); +} else { +return not_found; + +} +} +}); + +cljs.core.HashCollisionNode.prototype.inode_assoc_BANG_ = (function (edit__$1,shift,hash,key,val,added_leaf_QMARK_){ +var self__ = this; +var inode = this; +if((hash === self__.collision_hash)){ +var idx = cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key); +if((idx === (-1))){ +if((self__.arr.length > ((2) * self__.cnt))){ +var editable = cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$6(inode,edit__$1,((2) * self__.cnt),key,(((2) * self__.cnt) + (1)),val); +added_leaf_QMARK_.val = true; + +editable.cnt = (editable.cnt + (1)); + +return editable; +} else { +var len = self__.arr.length; +var new_arr = (new Array((len + (2)))); +cljs.core.array_copy(self__.arr,(0),new_arr,(0),len); + +(new_arr[len] = key); + +(new_arr[(len + (1))] = val); + +added_leaf_QMARK_.val = true; + +return inode.ensure_editable_array(edit__$1,(self__.cnt + (1)),new_arr); +} +} else { +if(((self__.arr[(idx + (1))]) === val)){ +return inode; +} else { +return cljs.core.edit_and_set.cljs$core$IFn$_invoke$arity$4(inode,edit__$1,(idx + (1)),val); +} +} +} else { +return (new cljs.core.BitmapIndexedNode(edit__$1,(1 << ((self__.collision_hash >>> shift) & 0x01f)),[null,inode,null,null])).inode_assoc_BANG_(edit__$1,shift,hash,key,val,added_leaf_QMARK_); +} +}); + +cljs.core.HashCollisionNode.prototype.inode_assoc = (function (shift,hash,key,val,added_leaf_QMARK_){ +var self__ = this; +var inode = this; +if((hash === self__.collision_hash)){ +var idx = cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key); +if((idx === (-1))){ +var len = ((2) * self__.cnt); +var new_arr = (new Array((len + (2)))); +cljs.core.array_copy(self__.arr,(0),new_arr,(0),len); + +(new_arr[len] = key); + +(new_arr[(len + (1))] = val); + +added_leaf_QMARK_.val = true; + +return (new cljs.core.HashCollisionNode(null,self__.collision_hash,(self__.cnt + (1)),new_arr)); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2((self__.arr[(idx + (1))]),val)){ +return inode; +} else { +return (new cljs.core.HashCollisionNode(null,self__.collision_hash,self__.cnt,cljs.core.clone_and_set.cljs$core$IFn$_invoke$arity$3(self__.arr,(idx + (1)),val))); +} +} +} else { +return (new cljs.core.BitmapIndexedNode(null,(1 << ((self__.collision_hash >>> shift) & 0x01f)),[null,inode])).inode_assoc(shift,hash,key,val,added_leaf_QMARK_); +} +}); + +cljs.core.HashCollisionNode.prototype.ensure_editable_array = (function (e,count,array){ +var self__ = this; +var inode = this; +if((e === self__.edit)){ +self__.arr = array; + +self__.cnt = count; + +return inode; +} else { +return (new cljs.core.HashCollisionNode(self__.edit,self__.collision_hash,count,array)); +} +}); + +cljs.core.HashCollisionNode.prototype.inode_find = (function (shift,hash,key,not_found){ +var self__ = this; +var inode = this; +var idx = cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key); +if((idx < (0))){ +return not_found; +} else { +if(cljs.core.key_test(key,(self__.arr[idx]))){ +return (new cljs.core.MapEntry((self__.arr[idx]),(self__.arr[(idx + (1))]),null)); +} else { +return not_found; + +} +} +}); + +cljs.core.HashCollisionNode.prototype.inode_without = (function (shift,hash,key){ +var self__ = this; +var inode = this; +var idx = cljs.core.hash_collision_node_find_index(self__.arr,self__.cnt,key); +if((idx === (-1))){ +return inode; +} else { +if((self__.cnt === (1))){ +return null; +} else { +return (new cljs.core.HashCollisionNode(null,self__.collision_hash,(self__.cnt - (1)),cljs.core.remove_pair(self__.arr,cljs.core.quot(idx,(2))))); + +} +} +}); + +cljs.core.HashCollisionNode.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.NodeIterator(self__.arr,(0),null,null)); +}); + +cljs.core.HashCollisionNode.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$edit,cljs.core.with_meta(cljs.core.cst$sym$collision_DASH_hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$cnt,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$arr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.HashCollisionNode.cljs$lang$type = true; + +cljs.core.HashCollisionNode.cljs$lang$ctorStr = "cljs.core/HashCollisionNode"; + +cljs.core.HashCollisionNode.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/HashCollisionNode"); +}); + +/** + * Positional factory function for cljs.core/HashCollisionNode. + */ +cljs.core.__GT_HashCollisionNode = (function cljs$core$__GT_HashCollisionNode(edit,collision_hash,cnt,arr){ +return (new cljs.core.HashCollisionNode(edit,collision_hash,cnt,arr)); +}); + +cljs.core.create_node = (function cljs$core$create_node(var_args){ +var G__2341 = arguments.length; +switch (G__2341) { +case 6: +return cljs.core.create_node.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +case 7: +return cljs.core.create_node.cljs$core$IFn$_invoke$arity$7((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),(arguments[(6)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.create_node.cljs$core$IFn$_invoke$arity$6 = (function (shift,key1,val1,key2hash,key2,val2){ +var key1hash = cljs.core.hash(key1); +if((key1hash === key2hash)){ +return (new cljs.core.HashCollisionNode(null,key1hash,(2),[key1,val1,key2,val2])); +} else { +var added_leaf_QMARK_ = (new cljs.core.Box(false)); +return cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift,key1hash,key1,val1,added_leaf_QMARK_).inode_assoc(shift,key2hash,key2,val2,added_leaf_QMARK_); +} +}); + +cljs.core.create_node.cljs$core$IFn$_invoke$arity$7 = (function (edit,shift,key1,val1,key2hash,key2,val2){ +var key1hash = cljs.core.hash(key1); +if((key1hash === key2hash)){ +return (new cljs.core.HashCollisionNode(null,key1hash,(2),[key1,val1,key2,val2])); +} else { +var added_leaf_QMARK_ = (new cljs.core.Box(false)); +return cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit,shift,key1hash,key1,val1,added_leaf_QMARK_).inode_assoc_BANG_(edit,shift,key2hash,key2,val2,added_leaf_QMARK_); +} +}); + +cljs.core.create_node.cljs$lang$maxFixedArity = 7; + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.NodeSeq = (function (meta,nodes,i,s,__hash){ +this.meta = meta; +this.nodes = nodes; +this.i = i; +this.s = s; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32374988; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.NodeSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.NodeSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.NodeSeq.prototype.indexOf = (function() { +var G__2343 = null; +var G__2343__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2343__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2343 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2343__1.call(this,x); +case 2: +return G__2343__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2343.cljs$core$IFn$_invoke$arity$1 = G__2343__1; +G__2343.cljs$core$IFn$_invoke$arity$2 = G__2343__2; +return G__2343; +})() +; + +cljs.core.NodeSeq.prototype.lastIndexOf = (function() { +var G__2344 = null; +var G__2344__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2344__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2344 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2344__1.call(this,x); +case 2: +return G__2344__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2344.cljs$core$IFn$_invoke$arity$1 = G__2344__1; +G__2344.cljs$core$IFn$_invoke$arity$2 = G__2344__2; +return G__2344; +})() +; + +cljs.core.NodeSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.NodeSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.s == null)){ +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(self__.nodes,(self__.i + (2)),null); +} else { +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(self__.nodes,self__.i,cljs.core.next(self__.s)); +} +}); + +cljs.core.NodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.NodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.NodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.NodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.s == null)){ +return (new cljs.core.MapEntry((self__.nodes[self__.i]),(self__.nodes[(self__.i + (1))]),null)); +} else { +return cljs.core.first(self__.s); +} +}); + +cljs.core.NodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var ret = (((self__.s == null))?cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(self__.nodes,(self__.i + (2)),null):cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(self__.nodes,self__.i,cljs.core.next(self__.s))); +if(!((ret == null))){ +return ret; +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.NodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return this$__$1; +}); + +cljs.core.NodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.NodeSeq(meta__$1,self__.nodes,self__.i,self__.s,self__.__hash)); +}); + +cljs.core.NodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.NodeSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$nodes,cljs.core.cst$sym$i,cljs.core.cst$sym$s,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.NodeSeq.cljs$lang$type = true; + +cljs.core.NodeSeq.cljs$lang$ctorStr = "cljs.core/NodeSeq"; + +cljs.core.NodeSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/NodeSeq"); +}); + +/** + * Positional factory function for cljs.core/NodeSeq. + */ +cljs.core.__GT_NodeSeq = (function cljs$core$__GT_NodeSeq(meta,nodes,i,s,__hash){ +return (new cljs.core.NodeSeq(meta,nodes,i,s,__hash)); +}); + +var G__2345_2348 = cljs.core.NodeSeq.prototype; +var G__2346_2349 = cljs.core.ITER_SYMBOL; +var G__2347_2350 = ((function (G__2345_2348,G__2346_2349){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2345_2348,G__2346_2349)) +; +goog.object.set(G__2345_2348,G__2346_2349,G__2347_2350); +cljs.core.create_inode_seq = (function cljs$core$create_inode_seq(var_args){ +var G__2352 = arguments.length; +switch (G__2352) { +case 1: +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 3: +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$1 = (function (nodes){ +return cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3(nodes,(0),null); +}); + +cljs.core.create_inode_seq.cljs$core$IFn$_invoke$arity$3 = (function (nodes,i,s){ +if((s == null)){ +var len = nodes.length; +var j = i; +while(true){ +if((j < len)){ +if(!(((nodes[j]) == null))){ +return (new cljs.core.NodeSeq(null,nodes,j,null,null)); +} else { +var temp__5455__auto__ = (nodes[(j + (1))]); +if(cljs.core.truth_(temp__5455__auto__)){ +var node = temp__5455__auto__; +var temp__5455__auto____$1 = node.inode_seq(); +if(cljs.core.truth_(temp__5455__auto____$1)){ +var node_seq = temp__5455__auto____$1; +return (new cljs.core.NodeSeq(null,nodes,(j + (2)),node_seq,null)); +} else { +var G__2354 = (j + (2)); +j = G__2354; +continue; +} +} else { +var G__2355 = (j + (2)); +j = G__2355; +continue; +} +} +} else { +return null; +} +break; +} +} else { +return (new cljs.core.NodeSeq(null,nodes,i,s,null)); +} +}); + +cljs.core.create_inode_seq.cljs$lang$maxFixedArity = 3; + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.ArrayNodeSeq = (function (meta,nodes,i,s,__hash){ +this.meta = meta; +this.nodes = nodes; +this.i = i; +this.s = s; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32374988; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.ArrayNodeSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.ArrayNodeSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.ArrayNodeSeq.prototype.indexOf = (function() { +var G__2356 = null; +var G__2356__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2356__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2356 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2356__1.call(this,x); +case 2: +return G__2356__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2356.cljs$core$IFn$_invoke$arity$1 = G__2356__1; +G__2356.cljs$core$IFn$_invoke$arity$2 = G__2356__2; +return G__2356; +})() +; + +cljs.core.ArrayNodeSeq.prototype.lastIndexOf = (function() { +var G__2357 = null; +var G__2357__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2357__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2357 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2357__1.call(this,x); +case 2: +return G__2357__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2357.cljs$core$IFn$_invoke$arity$1 = G__2357__1; +G__2357.cljs$core$IFn$_invoke$arity$2 = G__2357__2; +return G__2357; +})() +; + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$4(null,self__.nodes,self__.i,cljs.core.next(self__.s)); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.first(self__.s); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var ret = cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$4(null,self__.nodes,self__.i,cljs.core.next(self__.s)); +if(!((ret == null))){ +return ret; +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return this$__$1; +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.ArrayNodeSeq(meta__$1,self__.nodes,self__.i,self__.s,self__.__hash)); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.ArrayNodeSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$nodes,cljs.core.cst$sym$i,cljs.core.cst$sym$s,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ArrayNodeSeq.cljs$lang$type = true; + +cljs.core.ArrayNodeSeq.cljs$lang$ctorStr = "cljs.core/ArrayNodeSeq"; + +cljs.core.ArrayNodeSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ArrayNodeSeq"); +}); + +/** + * Positional factory function for cljs.core/ArrayNodeSeq. + */ +cljs.core.__GT_ArrayNodeSeq = (function cljs$core$__GT_ArrayNodeSeq(meta,nodes,i,s,__hash){ +return (new cljs.core.ArrayNodeSeq(meta,nodes,i,s,__hash)); +}); + +var G__2358_2361 = cljs.core.ArrayNodeSeq.prototype; +var G__2359_2362 = cljs.core.ITER_SYMBOL; +var G__2360_2363 = ((function (G__2358_2361,G__2359_2362){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2358_2361,G__2359_2362)) +; +goog.object.set(G__2358_2361,G__2359_2362,G__2360_2363); +cljs.core.create_array_node_seq = (function cljs$core$create_array_node_seq(var_args){ +var G__2365 = arguments.length; +switch (G__2365) { +case 1: +return cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 4: +return cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$1 = (function (nodes){ +return cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$4(null,nodes,(0),null); +}); + +cljs.core.create_array_node_seq.cljs$core$IFn$_invoke$arity$4 = (function (meta,nodes,i,s){ +if((s == null)){ +var len = nodes.length; +var j = i; +while(true){ +if((j < len)){ +var temp__5455__auto__ = (nodes[j]); +if(cljs.core.truth_(temp__5455__auto__)){ +var nj = temp__5455__auto__; +var temp__5455__auto____$1 = nj.inode_seq(); +if(cljs.core.truth_(temp__5455__auto____$1)){ +var ns = temp__5455__auto____$1; +return (new cljs.core.ArrayNodeSeq(meta,nodes,(j + (1)),ns,null)); +} else { +var G__2367 = (j + (1)); +j = G__2367; +continue; +} +} else { +var G__2368 = (j + (1)); +j = G__2368; +continue; +} +} else { +return null; +} +break; +} +} else { +return (new cljs.core.ArrayNodeSeq(meta,nodes,i,s,null)); +} +}); + +cljs.core.create_array_node_seq.cljs$lang$maxFixedArity = 4; + + +/** +* @constructor +*/ +cljs.core.HashMapIter = (function (nil_val,root_iter,seen){ +this.nil_val = nil_val; +this.root_iter = root_iter; +this.seen = seen; +}); +cljs.core.HashMapIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return ((!(self__.seen)) || (self__.root_iter.hasNext())); +}); + +cljs.core.HashMapIter.prototype.next = (function (){ +var self__ = this; +var _ = this; +if(!(self__.seen)){ +self__.seen = true; + +return (new cljs.core.MapEntry(null,self__.nil_val,null)); +} else { +return self__.root_iter.next(); +} +}); + +cljs.core.HashMapIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.HashMapIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$nil_DASH_val,cljs.core.cst$sym$root_DASH_iter,cljs.core.with_meta(cljs.core.cst$sym$seen,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.HashMapIter.cljs$lang$type = true; + +cljs.core.HashMapIter.cljs$lang$ctorStr = "cljs.core/HashMapIter"; + +cljs.core.HashMapIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/HashMapIter"); +}); + +/** + * Positional factory function for cljs.core/HashMapIter. + */ +cljs.core.__GT_HashMapIter = (function cljs$core$__GT_HashMapIter(nil_val,root_iter,seen){ +return (new cljs.core.HashMapIter(nil_val,root_iter,seen)); +}); + + +/** +* @constructor + * @implements {cljs.core.IKVReduce} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEditableCollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.IMap} + * @implements {cljs.core.ILookup} +*/ +cljs.core.PersistentHashMap = (function (meta,cnt,root,has_nil_QMARK_,nil_val,__hash){ +this.meta = meta; +this.cnt = cnt; +this.root = root; +this.has_nil_QMARK_ = has_nil_QMARK_; +this.nil_val = nil_val; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 16123663; +this.cljs$lang$protocol_mask$partition1$ = 139268; +}); +cljs.core.PersistentHashMap.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentHashMap.prototype.cljs$core$IFind$_find$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if((k == null)){ +if(self__.has_nil_QMARK_){ +return (new cljs.core.MapEntry(null,self__.nil_val,null)); +} else { +return null; +} +} else { +if((self__.root == null)){ +return null; +} else { +return self__.root.inode_find((0),cljs.core.hash(k),k,null); + +} +} +}); + +cljs.core.PersistentHashMap.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentHashMap.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentHashMap.prototype.keys = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.keys(coll)); +}); + +cljs.core.PersistentHashMap.prototype.entries = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_entries_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentHashMap.prototype.values = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.vals(coll)); +}); + +cljs.core.PersistentHashMap.prototype.has = (function (k){ +var self__ = this; +var coll = this; +return cljs.core.contains_QMARK_(coll,k); +}); + +cljs.core.PersistentHashMap.prototype.get = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentHashMap.prototype.forEach = (function (f){ +var self__ = this; +var coll = this; +var seq__2370 = cljs.core.seq(coll); +var chunk__2371 = null; +var count__2372 = (0); +var i__2373 = (0); +while(true){ +if((i__2373 < count__2372)){ +var vec__2374 = chunk__2371.cljs$core$IIndexed$_nth$arity$2(null,i__2373); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2374,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2374,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2382 = seq__2370; +var G__2383 = chunk__2371; +var G__2384 = count__2372; +var G__2385 = (i__2373 + (1)); +seq__2370 = G__2382; +chunk__2371 = G__2383; +count__2372 = G__2384; +i__2373 = G__2385; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2370); +if(temp__5457__auto__){ +var seq__2370__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2370__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2370__$1); +var G__2386 = cljs.core.chunk_rest(seq__2370__$1); +var G__2387 = c__4338__auto__; +var G__2388 = cljs.core.count(c__4338__auto__); +var G__2389 = (0); +seq__2370 = G__2386; +chunk__2371 = G__2387; +count__2372 = G__2388; +i__2373 = G__2389; +continue; +} else { +var vec__2377 = cljs.core.first(seq__2370__$1); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2377,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2377,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2390 = cljs.core.next(seq__2370__$1); +var G__2391 = null; +var G__2392 = (0); +var G__2393 = (0); +seq__2370 = G__2390; +chunk__2371 = G__2391; +count__2372 = G__2392; +i__2373 = G__2393; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +if((k == null)){ +if(self__.has_nil_QMARK_){ +return self__.nil_val; +} else { +return not_found; +} +} else { +if((self__.root == null)){ +return not_found; +} else { +return self__.root.inode_lookup((0),cljs.core.hash(k),k,not_found); + +} +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = (function (coll,f,init){ +var self__ = this; +var coll__$1 = this; +var init__$1 = ((self__.has_nil_QMARK_)?(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(init,null,self__.nil_val) : f.call(null,init,null,self__.nil_val)):init); +if(cljs.core.reduced_QMARK_(init__$1)){ +return cljs.core.deref(init__$1); +} else { +if(!((self__.root == null))){ +return cljs.core.unreduced(self__.root.kv_reduce(f,init__$1)); +} else { +return init__$1; + +} +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var root_iter = ((self__.root)?cljs.core._iterator(self__.root):cljs.core.nil_iter()); +if(self__.has_nil_QMARK_){ +return (new cljs.core.HashMapIter(self__.nil_val,root_iter,false)); +} else { +return root_iter; +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.PersistentHashMap(self__.meta,self__.cnt,self__.root,self__.has_nil_QMARK_,self__.nil_val,self__.__hash)); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.cnt; +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_unordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_map(coll__$1,other); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.TransientHashMap({},self__.root,self__.cnt,self__.has_nil_QMARK_,self__.nil_val)); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.PersistentHashMap.EMPTY,self__.meta); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IMap$_dissoc$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if((k == null)){ +if(self__.has_nil_QMARK_){ +return (new cljs.core.PersistentHashMap(self__.meta,(self__.cnt - (1)),self__.root,false,null,null)); +} else { +return coll__$1; +} +} else { +if((self__.root == null)){ +return coll__$1; +} else { +var new_root = self__.root.inode_without((0),cljs.core.hash(k),k); +if((new_root === self__.root)){ +return coll__$1; +} else { +return (new cljs.core.PersistentHashMap(self__.meta,(self__.cnt - (1)),new_root,self__.has_nil_QMARK_,self__.nil_val,null)); +} + +} +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (coll,k,v){ +var self__ = this; +var coll__$1 = this; +if((k == null)){ +if(((self__.has_nil_QMARK_) && ((v === self__.nil_val)))){ +return coll__$1; +} else { +return (new cljs.core.PersistentHashMap(self__.meta,((self__.has_nil_QMARK_)?self__.cnt:(self__.cnt + (1))),self__.root,true,v,null)); +} +} else { +var added_leaf_QMARK_ = (new cljs.core.Box(false)); +var new_root = (((self__.root == null))?cljs.core.BitmapIndexedNode.EMPTY:self__.root).inode_assoc((0),cljs.core.hash(k),k,v,added_leaf_QMARK_); +if((new_root === self__.root)){ +return coll__$1; +} else { +return (new cljs.core.PersistentHashMap(self__.meta,((added_leaf_QMARK_.val)?(self__.cnt + (1)):self__.cnt),new_root,self__.has_nil_QMARK_,self__.nil_val,null)); +} +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +if((k == null)){ +return self__.has_nil_QMARK_; +} else { +if((self__.root == null)){ +return false; +} else { +return !((self__.root.inode_lookup((0),cljs.core.hash(k),k,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)); + +} +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +var s = ((!((self__.root == null)))?self__.root.inode_seq():null); +if(self__.has_nil_QMARK_){ +return cljs.core.cons((new cljs.core.MapEntry(null,self__.nil_val,null)),s); +} else { +return s; +} +} else { +return null; +} +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentHashMap(meta__$1,self__.cnt,self__.root,self__.has_nil_QMARK_,self__.nil_val,self__.__hash)); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,entry){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.vector_QMARK_(entry)){ +return coll__$1.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(1))); +} else { +var ret = coll__$1; +var es = cljs.core.seq(entry); +while(true){ +if((es == null)){ +return ret; +} else { +var e = cljs.core.first(es); +if(cljs.core.vector_QMARK_(e)){ +var G__2394 = ret.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(e,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(e,(1))); +var G__2395 = cljs.core.next(es); +ret = G__2394; +es = G__2395; +continue; +} else { +throw (new Error("conj on a map takes map entries or seqables of map entries")); +} +} +break; +} +} +}); + +cljs.core.PersistentHashMap.prototype.call = (function() { +var G__2396 = null; +var G__2396__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2396__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2396 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2396__2.call(this,self__,k); +case 3: +return G__2396__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2396.cljs$core$IFn$_invoke$arity$2 = G__2396__2; +G__2396.cljs$core$IFn$_invoke$arity$3 = G__2396__3; +return G__2396; +})() +; + +cljs.core.PersistentHashMap.prototype.apply = (function (self__,args2369){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2369))); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentHashMap.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$cnt,cljs.core.cst$sym$root,cljs.core.with_meta(cljs.core.cst$sym$has_DASH_nil_QMARK_,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$boolean], null)),cljs.core.cst$sym$nil_DASH_val,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentHashMap.cljs$lang$type = true; + +cljs.core.PersistentHashMap.cljs$lang$ctorStr = "cljs.core/PersistentHashMap"; + +cljs.core.PersistentHashMap.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentHashMap"); +}); + +/** + * Positional factory function for cljs.core/PersistentHashMap. + */ +cljs.core.__GT_PersistentHashMap = (function cljs$core$__GT_PersistentHashMap(meta,cnt,root,has_nil_QMARK_,nil_val,__hash){ +return (new cljs.core.PersistentHashMap(meta,cnt,root,has_nil_QMARK_,nil_val,__hash)); +}); + +cljs.core.PersistentHashMap.EMPTY = (new cljs.core.PersistentHashMap(null,(0),null,false,null,cljs.core.empty_unordered_hash)); +cljs.core.PersistentHashMap.fromArray = (function (arr,no_clone){ +var arr__$1 = ((no_clone)?arr:cljs.core.aclone(arr)); +var len = arr__$1.length; +var i = (0); +var ret = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY); +while(true){ +if((i < len)){ +var G__2397 = (i + (2)); +var G__2398 = cljs.core._assoc_BANG_(ret,(arr__$1[i]),(arr__$1[(i + (1))])); +i = G__2397; +ret = G__2398; +continue; +} else { +return cljs.core._persistent_BANG_(ret); +} +break; +} +}); +cljs.core.PersistentHashMap.fromArrays = (function (ks,vs){ +var len = ks.length; +var i = (0); +var out = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY); +while(true){ +if((i < len)){ +var G__2399 = (i + (1)); +var G__2400 = out.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(null,(ks[i]),(vs[i])); +i = G__2399; +out = G__2400; +continue; +} else { +return cljs.core.persistent_BANG_(out); +} +break; +} +}); +cljs.core.PersistentHashMap.createWithCheck = (function (arr){ +var len = arr.length; +var ret = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY); +var i_2401 = (0); +while(true){ +if((i_2401 < len)){ +cljs.core._assoc_BANG_(ret,(arr[i_2401]),(arr[(i_2401 + (1))])); + +if(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core._count(ret),((i_2401 / (2)) + (1)))){ +throw (new Error(["Duplicate key: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1((arr[i_2401]))].join(''))); +} else { +var G__2402 = (i_2401 + (2)); +i_2401 = G__2402; +continue; +} +} else { +} +break; +} + +return cljs.core._persistent_BANG_(ret); +}); +var G__2403_2406 = cljs.core.PersistentHashMap.prototype; +var G__2404_2407 = cljs.core.ITER_SYMBOL; +var G__2405_2408 = ((function (G__2403_2406,G__2404_2407){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2403_2406,G__2404_2407)) +; +goog.object.set(G__2403_2406,G__2404_2407,G__2405_2408); + +/** +* @constructor + * @implements {cljs.core.IFn} + * @implements {cljs.core.ITransientMap} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ITransientCollection} + * @implements {cljs.core.ITransientAssociative} + * @implements {cljs.core.ILookup} +*/ +cljs.core.TransientHashMap = (function (edit,root,count,has_nil_QMARK_,nil_val){ +this.edit = edit; +this.root = root; +this.count = count; +this.has_nil_QMARK_ = has_nil_QMARK_; +this.nil_val = nil_val; +this.cljs$lang$protocol_mask$partition0$ = 259; +this.cljs$lang$protocol_mask$partition1$ = 56; +}); +cljs.core.TransientHashMap.prototype.conj_BANG_ = (function (o){ +var self__ = this; +var tcoll = this; +if(self__.edit){ +if(cljs.core.map_entry_QMARK_(o)){ +return tcoll.assoc_BANG_(cljs.core.key(o),cljs.core.val(o)); +} else { +if(cljs.core.vector_QMARK_(o)){ +return tcoll.assoc_BANG_((o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((0)) : o.call(null,(0))),(o.cljs$core$IFn$_invoke$arity$1 ? o.cljs$core$IFn$_invoke$arity$1((1)) : o.call(null,(1)))); +} else { +var es = cljs.core.seq(o); +var tcoll__$1 = tcoll; +while(true){ +var temp__5455__auto__ = cljs.core.first(es); +if(cljs.core.truth_(temp__5455__auto__)){ +var e = temp__5455__auto__; +var G__2410 = cljs.core.next(es); +var G__2411 = tcoll__$1.assoc_BANG_(cljs.core.key(e),cljs.core.val(e)); +es = G__2410; +tcoll__$1 = G__2411; +continue; +} else { +return tcoll__$1; +} +break; +} + +} +} +} else { +throw (new Error("conj! after persistent")); +} +}); + +cljs.core.TransientHashMap.prototype.assoc_BANG_ = (function (k,v){ +var self__ = this; +var tcoll = this; +if(self__.edit){ +if((k == null)){ +if((self__.nil_val === v)){ +} else { +self__.nil_val = v; +} + +if(self__.has_nil_QMARK_){ +} else { +self__.count = (self__.count + (1)); + +self__.has_nil_QMARK_ = true; +} + +return tcoll; +} else { +var added_leaf_QMARK_ = (new cljs.core.Box(false)); +var node = (((self__.root == null))?cljs.core.BitmapIndexedNode.EMPTY:self__.root).inode_assoc_BANG_(self__.edit,(0),cljs.core.hash(k),k,v,added_leaf_QMARK_); +if((node === self__.root)){ +} else { +self__.root = node; +} + +if(added_leaf_QMARK_.val){ +self__.count = (self__.count + (1)); +} else { +} + +return tcoll; +} +} else { +throw (new Error("assoc! after persistent!")); +} +}); + +cljs.core.TransientHashMap.prototype.without_BANG_ = (function (k){ +var self__ = this; +var tcoll = this; +if(self__.edit){ +if((k == null)){ +if(self__.has_nil_QMARK_){ +self__.has_nil_QMARK_ = false; + +self__.nil_val = null; + +self__.count = (self__.count - (1)); + +return tcoll; +} else { +return tcoll; +} +} else { +if((self__.root == null)){ +return tcoll; +} else { +var removed_leaf_QMARK_ = (new cljs.core.Box(false)); +var node = self__.root.inode_without_BANG_(self__.edit,(0),cljs.core.hash(k),k,removed_leaf_QMARK_); +if((node === self__.root)){ +} else { +self__.root = node; +} + +if(removed_leaf_QMARK_.val){ +self__.count = (self__.count - (1)); +} else { +} + +return tcoll; +} +} +} else { +throw (new Error("dissoc! after persistent!")); +} +}); + +cljs.core.TransientHashMap.prototype.persistent_BANG_ = (function (){ +var self__ = this; +var tcoll = this; +if(self__.edit){ +self__.edit = null; + +return (new cljs.core.PersistentHashMap(null,self__.count,self__.root,self__.has_nil_QMARK_,self__.nil_val,null)); +} else { +throw (new Error("persistent! called twice")); +} +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if(self__.edit){ +return self__.count; +} else { +throw (new Error("count after persistent!")); +} +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (tcoll,k){ +var self__ = this; +var tcoll__$1 = this; +if((k == null)){ +if(self__.has_nil_QMARK_){ +return self__.nil_val; +} else { +return null; +} +} else { +if((self__.root == null)){ +return null; +} else { +return self__.root.inode_lookup((0),cljs.core.hash(k),k); +} +} +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (tcoll,k,not_found){ +var self__ = this; +var tcoll__$1 = this; +if((k == null)){ +if(self__.has_nil_QMARK_){ +return self__.nil_val; +} else { +return not_found; +} +} else { +if((self__.root == null)){ +return not_found; +} else { +return self__.root.inode_lookup((0),cljs.core.hash(k),k,not_found); +} +} +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = (function (tcoll,val){ +var self__ = this; +var tcoll__$1 = this; +return tcoll__$1.conj_BANG_(val); +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +return tcoll__$1.persistent_BANG_(); +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = (function (tcoll,key,val){ +var self__ = this; +var tcoll__$1 = this; +return tcoll__$1.assoc_BANG_(key,val); +}); + +cljs.core.TransientHashMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = (function (tcoll,key){ +var self__ = this; +var tcoll__$1 = this; +return tcoll__$1.without_BANG_(key); +}); + +cljs.core.TransientHashMap.prototype.call = (function() { +var G__2412 = null; +var G__2412__2 = (function (self__,key){ +var self__ = this; +var self____$1 = this; +var tcoll = self____$1; +return tcoll.cljs$core$ILookup$_lookup$arity$2(null,key); +}); +var G__2412__3 = (function (self__,key,not_found){ +var self__ = this; +var self____$1 = this; +var tcoll = self____$1; +return tcoll.cljs$core$ILookup$_lookup$arity$3(null,key,not_found); +}); +G__2412 = function(self__,key,not_found){ +switch(arguments.length){ +case 2: +return G__2412__2.call(this,self__,key); +case 3: +return G__2412__3.call(this,self__,key,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2412.cljs$core$IFn$_invoke$arity$2 = G__2412__2; +G__2412.cljs$core$IFn$_invoke$arity$3 = G__2412__3; +return G__2412; +})() +; + +cljs.core.TransientHashMap.prototype.apply = (function (self__,args2409){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2409))); +}); + +cljs.core.TransientHashMap.prototype.cljs$core$IFn$_invoke$arity$1 = (function (key){ +var self__ = this; +var tcoll = this; +return tcoll.cljs$core$ILookup$_lookup$arity$2(null,key); +}); + +cljs.core.TransientHashMap.prototype.cljs$core$IFn$_invoke$arity$2 = (function (key,not_found){ +var self__ = this; +var tcoll = this; +return tcoll.cljs$core$ILookup$_lookup$arity$3(null,key,not_found); +}); + +cljs.core.TransientHashMap.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$edit,new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$tag,cljs.core.cst$sym$boolean,cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$root,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$count,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$has_DASH_nil_QMARK_,new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$tag,cljs.core.cst$sym$boolean,cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$nil_DASH_val,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.TransientHashMap.cljs$lang$type = true; + +cljs.core.TransientHashMap.cljs$lang$ctorStr = "cljs.core/TransientHashMap"; + +cljs.core.TransientHashMap.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/TransientHashMap"); +}); + +/** + * Positional factory function for cljs.core/TransientHashMap. + */ +cljs.core.__GT_TransientHashMap = (function cljs$core$__GT_TransientHashMap(edit,root,count,has_nil_QMARK_,nil_val){ +return (new cljs.core.TransientHashMap(edit,root,count,has_nil_QMARK_,nil_val)); +}); + +cljs.core.tree_map_seq_push = (function cljs$core$tree_map_seq_push(node,stack,ascending_QMARK_){ +var t = node; +var stack__$1 = stack; +while(true){ +if(!((t == null))){ +var G__2413 = ((ascending_QMARK_)?t.left:t.right); +var G__2414 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack__$1,t); +t = G__2413; +stack__$1 = G__2414; +continue; +} else { +return stack__$1; +} +break; +} +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.PersistentTreeMapSeq = (function (meta,stack,ascending_QMARK_,cnt,__hash){ +this.meta = meta; +this.stack = stack; +this.ascending_QMARK_ = ascending_QMARK_; +this.cnt = cnt; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32374990; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.PersistentTreeMapSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentTreeMapSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentTreeMapSeq.prototype.indexOf = (function() { +var G__2415 = null; +var G__2415__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2415__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2415 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2415__1.call(this,x); +case 2: +return G__2415__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2415.cljs$core$IFn$_invoke$arity$1 = G__2415__1; +G__2415.cljs$core$IFn$_invoke$arity$2 = G__2415__2; +return G__2415; +})() +; + +cljs.core.PersistentTreeMapSeq.prototype.lastIndexOf = (function() { +var G__2416 = null; +var G__2416__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2416__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2416 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2416__1.call(this,x); +case 2: +return G__2416__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2416.cljs$core$IFn$_invoke$arity$1 = G__2416__1; +G__2416.cljs$core$IFn$_invoke$arity$2 = G__2416__2; +return G__2416; +})() +; + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$INext$_next$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +var t = cljs.core.first(self__.stack); +var next_stack = cljs.core.tree_map_seq_push(((self__.ascending_QMARK_)?t.right:t.left),cljs.core.next(self__.stack),self__.ascending_QMARK_); +if((next_stack == null)){ +return null; +} else { +return (new cljs.core.PersistentTreeMapSeq(null,next_stack,self__.ascending_QMARK_,(self__.cnt - (1)),null)); +} +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt < (0))){ +return (cljs.core.count(cljs.core.next(coll__$1)) + (1)); +} else { +return self__.cnt; +} +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return cljs.core.peek(self__.stack); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +var t = cljs.core.first(self__.stack); +var next_stack = cljs.core.tree_map_seq_push(((self__.ascending_QMARK_)?t.right:t.left),cljs.core.next(self__.stack),self__.ascending_QMARK_); +if(!((next_stack == null))){ +return (new cljs.core.PersistentTreeMapSeq(null,next_stack,self__.ascending_QMARK_,(self__.cnt - (1)),null)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return this$__$1; +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeMapSeq(meta__$1,self__.stack,self__.ascending_QMARK_,self__.cnt,self__.__hash)); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.PersistentTreeMapSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$stack,cljs.core.with_meta(cljs.core.cst$sym$ascending_QMARK_,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$boolean], null)),cljs.core.cst$sym$cnt,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentTreeMapSeq.cljs$lang$type = true; + +cljs.core.PersistentTreeMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentTreeMapSeq"; + +cljs.core.PersistentTreeMapSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentTreeMapSeq"); +}); + +/** + * Positional factory function for cljs.core/PersistentTreeMapSeq. + */ +cljs.core.__GT_PersistentTreeMapSeq = (function cljs$core$__GT_PersistentTreeMapSeq(meta,stack,ascending_QMARK_,cnt,__hash){ +return (new cljs.core.PersistentTreeMapSeq(meta,stack,ascending_QMARK_,cnt,__hash)); +}); + +var G__2417_2420 = cljs.core.PersistentTreeMapSeq.prototype; +var G__2418_2421 = cljs.core.ITER_SYMBOL; +var G__2419_2422 = ((function (G__2417_2420,G__2418_2421){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2417_2420,G__2418_2421)) +; +goog.object.set(G__2417_2420,G__2418_2421,G__2419_2422); +cljs.core.create_tree_map_seq = (function cljs$core$create_tree_map_seq(tree,ascending_QMARK_,cnt){ +return (new cljs.core.PersistentTreeMapSeq(null,cljs.core.tree_map_seq_push(tree,null,ascending_QMARK_),ascending_QMARK_,cnt,null)); +}); + +cljs.core.balance_left = (function cljs$core$balance_left(key,val,ins,right){ +if((ins instanceof cljs.core.RedNode)){ +if((ins.left instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(ins.key,ins.val,ins.left.blacken(),(new cljs.core.BlackNode(key,val,ins.right,right,null)),null)); +} else { +if((ins.right instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(ins.right.key,ins.right.val,(new cljs.core.BlackNode(ins.key,ins.val,ins.left,ins.right.left,null)),(new cljs.core.BlackNode(key,val,ins.right.right,right,null)),null)); +} else { +return (new cljs.core.BlackNode(key,val,ins,right,null)); + +} +} +} else { +return (new cljs.core.BlackNode(key,val,ins,right,null)); +} +}); +cljs.core.balance_right = (function cljs$core$balance_right(key,val,left,ins){ +if((ins instanceof cljs.core.RedNode)){ +if((ins.right instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(ins.key,ins.val,(new cljs.core.BlackNode(key,val,left,ins.left,null)),ins.right.blacken(),null)); +} else { +if((ins.left instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(ins.left.key,ins.left.val,(new cljs.core.BlackNode(key,val,left,ins.left.left,null)),(new cljs.core.BlackNode(ins.key,ins.val,ins.left.right,ins.right,null)),null)); +} else { +return (new cljs.core.BlackNode(key,val,left,ins,null)); + +} +} +} else { +return (new cljs.core.BlackNode(key,val,left,ins,null)); +} +}); +cljs.core.balance_left_del = (function cljs$core$balance_left_del(key,val,del,right){ +if((del instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(key,val,del.blacken(),right,null)); +} else { +if((right instanceof cljs.core.BlackNode)){ +return cljs.core.balance_right(key,val,del,right.redden()); +} else { +if((((right instanceof cljs.core.RedNode)) && ((right.left instanceof cljs.core.BlackNode)))){ +return (new cljs.core.RedNode(right.left.key,right.left.val,(new cljs.core.BlackNode(key,val,del,right.left.left,null)),cljs.core.balance_right(right.key,right.val,right.left.right,right.right.redden()),null)); +} else { +throw (new Error("red-black tree invariant violation")); + +} +} +} +}); +cljs.core.balance_right_del = (function cljs$core$balance_right_del(key,val,left,del){ +if((del instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(key,val,left,del.blacken(),null)); +} else { +if((left instanceof cljs.core.BlackNode)){ +return cljs.core.balance_left(key,val,left.redden(),del); +} else { +if((((left instanceof cljs.core.RedNode)) && ((left.right instanceof cljs.core.BlackNode)))){ +return (new cljs.core.RedNode(left.right.key,left.right.val,cljs.core.balance_left(left.key,left.val,left.left.redden(),left.right.left),(new cljs.core.BlackNode(key,val,left.right.right,del,null)),null)); +} else { +throw (new Error("red-black tree invariant violation")); + +} +} +} +}); +cljs.core.tree_map_kv_reduce = (function cljs$core$tree_map_kv_reduce(node,f,init){ +var init__$1 = ((!((node.left == null)))?(function (){var G__2423 = node.left; +var G__2424 = f; +var G__2425 = init; +return (cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3 ? cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3(G__2423,G__2424,G__2425) : cljs.core.tree_map_kv_reduce.call(null,G__2423,G__2424,G__2425)); +})():init); +if(cljs.core.reduced_QMARK_(init__$1)){ +return init__$1; +} else { +var init__$2 = (function (){var G__2426 = init__$1; +var G__2427 = node.key; +var G__2428 = node.val; +return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__2426,G__2427,G__2428) : f.call(null,G__2426,G__2427,G__2428)); +})(); +if(cljs.core.reduced_QMARK_(init__$2)){ +return init__$2; +} else { +if(!((node.right == null))){ +var G__2429 = node.right; +var G__2430 = f; +var G__2431 = init__$2; +return (cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3 ? cljs.core.tree_map_kv_reduce.cljs$core$IFn$_invoke$arity$3(G__2429,G__2430,G__2431) : cljs.core.tree_map_kv_reduce.call(null,G__2429,G__2430,G__2431)); +} else { +return init__$2; +} +} +} +}); + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IVector} + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IStack} + * @implements {cljs.core.IMapEntry} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.ILookup} + * @implements {cljs.core.IReduce} +*/ +cljs.core.BlackNode = (function (key,val,left,right,__hash){ +this.key = key; +this.val = val; +this.left = left; +this.right = right; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 166619935; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.BlackNode.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.BlackNode.prototype.cljs$core$IFind$_find$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +var G__2433 = k; +switch (G__2433) { +case (0): +return (new cljs.core.MapEntry((0),self__.key,null)); + +break; +case (1): +return (new cljs.core.MapEntry((1),self__.val,null)); + +break; +default: +return null; + +} +}); + +cljs.core.BlackNode.prototype.lastIndexOf = (function() { +var G__2435 = null; +var G__2435__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2435__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2435 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2435__1.call(this,x); +case 2: +return G__2435__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2435.cljs$core$IFn$_invoke$arity$1 = G__2435__1; +G__2435.cljs$core$IFn$_invoke$arity$2 = G__2435__2; +return G__2435; +})() +; + +cljs.core.BlackNode.prototype.indexOf = (function() { +var G__2436 = null; +var G__2436__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2436__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2436 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2436__1.call(this,x); +case 2: +return G__2436__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2436.cljs$core$IFn$_invoke$arity$1 = G__2436__1; +G__2436.cljs$core$IFn$_invoke$arity$2 = G__2436__2; +return G__2436; +})() +; + +cljs.core.BlackNode.prototype.add_right = (function (ins){ +var self__ = this; +var node = this; +return ins.balance_right(node); +}); + +cljs.core.BlackNode.prototype.redden = (function (){ +var self__ = this; +var node = this; +return (new cljs.core.RedNode(self__.key,self__.val,self__.left,self__.right,null)); +}); + +cljs.core.BlackNode.prototype.blacken = (function (){ +var self__ = this; +var node = this; +return node; +}); + +cljs.core.BlackNode.prototype.add_left = (function (ins){ +var self__ = this; +var node = this; +return ins.balance_left(node); +}); + +cljs.core.BlackNode.prototype.replace = (function (key__$1,val__$1,left__$1,right__$1){ +var self__ = this; +var node = this; +return (new cljs.core.BlackNode(key__$1,val__$1,left__$1,right__$1,null)); +}); + +cljs.core.BlackNode.prototype.balance_left = (function (parent){ +var self__ = this; +var node = this; +return (new cljs.core.BlackNode(parent.key,parent.val,node,parent.right,null)); +}); + +cljs.core.BlackNode.prototype.balance_right = (function (parent){ +var self__ = this; +var node = this; +return (new cljs.core.BlackNode(parent.key,parent.val,parent.left,node,null)); +}); + +cljs.core.BlackNode.prototype.remove_left = (function (del){ +var self__ = this; +var node = this; +return cljs.core.balance_left_del(self__.key,self__.val,del,self__.right); +}); + +cljs.core.BlackNode.prototype.kv_reduce = (function (f,init){ +var self__ = this; +var node = this; +return cljs.core.tree_map_kv_reduce(node,f,init); +}); + +cljs.core.BlackNode.prototype.remove_right = (function (del){ +var self__ = this; +var node = this; +return cljs.core.balance_right_del(self__.key,self__.val,self__.left,del); +}); + +cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +return node__$1.cljs$core$IIndexed$_nth$arity$3(null,k,null); +}); + +cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (node,k,not_found){ +var self__ = this; +var node__$1 = this; +return node__$1.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (node,n){ +var self__ = this; +var node__$1 = this; +if((n === (0))){ +return self__.key; +} else { +if((n === (1))){ +return self__.val; +} else { +throw (new Error("Index out of bounds")); + +} +} +}); + +cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (node,n,not_found){ +var self__ = this; +var node__$1 = this; +if((n === (0))){ +return self__.key; +} else { +if((n === (1))){ +return self__.val; +} else { +return not_found; + +} +} +}); + +cljs.core.BlackNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = (function (node,n,v){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null).cljs$core$IVector$_assoc_n$arity$3(null,n,v); +}); + +cljs.core.BlackNode.prototype.cljs$core$IMeta$_meta$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return null; +}); + +cljs.core.BlackNode.prototype.cljs$core$ICounted$_count$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (2); +}); + +cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_key$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.key; +}); + +cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_val$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.val; +}); + +cljs.core.BlackNode.prototype.cljs$core$IStack$_peek$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.val; +}); + +cljs.core.BlackNode.prototype.cljs$core$IStack$_pop$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null); +}); + +cljs.core.BlackNode.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (new cljs.core.IndexedSeq([self__.val,self__.key],(0),null)); +}); + +cljs.core.BlackNode.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.BlackNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.BlackNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return null; +}); + +cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (node,f){ +var self__ = this; +var node__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(node__$1,f); +}); + +cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (node,f,start){ +var self__ = this; +var node__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(node__$1,f,start); +}); + +cljs.core.BlackNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (node,k,v){ +var self__ = this; +var node__$1 = this; +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),k,v); +}); + +cljs.core.BlackNode.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +return (((k === (0))) || ((k === (1)))); +}); + +cljs.core.BlackNode.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (new cljs.core.IndexedSeq([self__.key,self__.val],(0),null)); +}); + +cljs.core.BlackNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (node,meta){ +var self__ = this; +var node__$1 = this; +return cljs.core._with_meta(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),meta); +}); + +cljs.core.BlackNode.prototype.cljs$core$ICollection$_conj$arity$2 = (function (node,o){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val,o], null); +}); + +cljs.core.BlackNode.prototype.call = (function() { +var G__2437 = null; +var G__2437__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var node = self____$1; +return node.cljs$core$IIndexed$_nth$arity$2(null,k); +}); +var G__2437__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var node = self____$1; +return node.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); +G__2437 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2437__2.call(this,self__,k); +case 3: +return G__2437__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2437.cljs$core$IFn$_invoke$arity$2 = G__2437__2; +G__2437.cljs$core$IFn$_invoke$arity$3 = G__2437__3; +return G__2437; +})() +; + +cljs.core.BlackNode.prototype.apply = (function (self__,args2432){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2432))); +}); + +cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var node = this; +return node.cljs$core$IIndexed$_nth$arity$2(null,k); +}); + +cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var node = this; +return node.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.BlackNode.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$key,cljs.core.cst$sym$val,cljs.core.cst$sym$left,cljs.core.cst$sym$right,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.BlackNode.cljs$lang$type = true; + +cljs.core.BlackNode.cljs$lang$ctorStr = "cljs.core/BlackNode"; + +cljs.core.BlackNode.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/BlackNode"); +}); + +/** + * Positional factory function for cljs.core/BlackNode. + */ +cljs.core.__GT_BlackNode = (function cljs$core$__GT_BlackNode(key,val,left,right,__hash){ +return (new cljs.core.BlackNode(key,val,left,right,__hash)); +}); + +var G__2438_2441 = cljs.core.BlackNode.prototype; +var G__2439_2442 = cljs.core.ITER_SYMBOL; +var G__2440_2443 = ((function (G__2438_2441,G__2439_2442){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2438_2441,G__2439_2442)) +; +goog.object.set(G__2438_2441,G__2439_2442,G__2440_2443); + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IVector} + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.IStack} + * @implements {cljs.core.IMapEntry} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.ILookup} + * @implements {cljs.core.IReduce} +*/ +cljs.core.RedNode = (function (key,val,left,right,__hash){ +this.key = key; +this.val = val; +this.left = left; +this.right = right; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 166619935; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.RedNode.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.RedNode.prototype.cljs$core$IFind$_find$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +var G__2445 = k; +switch (G__2445) { +case (0): +return (new cljs.core.MapEntry((0),self__.key,null)); + +break; +case (1): +return (new cljs.core.MapEntry((1),self__.val,null)); + +break; +default: +return null; + +} +}); + +cljs.core.RedNode.prototype.lastIndexOf = (function() { +var G__2447 = null; +var G__2447__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2447__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2447 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2447__1.call(this,x); +case 2: +return G__2447__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2447.cljs$core$IFn$_invoke$arity$1 = G__2447__1; +G__2447.cljs$core$IFn$_invoke$arity$2 = G__2447__2; +return G__2447; +})() +; + +cljs.core.RedNode.prototype.indexOf = (function() { +var G__2448 = null; +var G__2448__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2448__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2448 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2448__1.call(this,x); +case 2: +return G__2448__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2448.cljs$core$IFn$_invoke$arity$1 = G__2448__1; +G__2448.cljs$core$IFn$_invoke$arity$2 = G__2448__2; +return G__2448; +})() +; + +cljs.core.RedNode.prototype.add_right = (function (ins){ +var self__ = this; +var node = this; +return (new cljs.core.RedNode(self__.key,self__.val,self__.left,ins,null)); +}); + +cljs.core.RedNode.prototype.redden = (function (){ +var self__ = this; +var node = this; +throw (new Error("red-black tree invariant violation")); +}); + +cljs.core.RedNode.prototype.blacken = (function (){ +var self__ = this; +var node = this; +return (new cljs.core.BlackNode(self__.key,self__.val,self__.left,self__.right,null)); +}); + +cljs.core.RedNode.prototype.add_left = (function (ins){ +var self__ = this; +var node = this; +return (new cljs.core.RedNode(self__.key,self__.val,ins,self__.right,null)); +}); + +cljs.core.RedNode.prototype.replace = (function (key__$1,val__$1,left__$1,right__$1){ +var self__ = this; +var node = this; +return (new cljs.core.RedNode(key__$1,val__$1,left__$1,right__$1,null)); +}); + +cljs.core.RedNode.prototype.balance_left = (function (parent){ +var self__ = this; +var node = this; +if((self__.left instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(self__.key,self__.val,self__.left.blacken(),(new cljs.core.BlackNode(parent.key,parent.val,self__.right,parent.right,null)),null)); +} else { +if((self__.right instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(self__.right.key,self__.right.val,(new cljs.core.BlackNode(self__.key,self__.val,self__.left,self__.right.left,null)),(new cljs.core.BlackNode(parent.key,parent.val,self__.right.right,parent.right,null)),null)); +} else { +return (new cljs.core.BlackNode(parent.key,parent.val,node,parent.right,null)); + +} +} +}); + +cljs.core.RedNode.prototype.balance_right = (function (parent){ +var self__ = this; +var node = this; +if((self__.right instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(self__.key,self__.val,(new cljs.core.BlackNode(parent.key,parent.val,parent.left,self__.left,null)),self__.right.blacken(),null)); +} else { +if((self__.left instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(self__.left.key,self__.left.val,(new cljs.core.BlackNode(parent.key,parent.val,parent.left,self__.left.left,null)),(new cljs.core.BlackNode(self__.key,self__.val,self__.left.right,self__.right,null)),null)); +} else { +return (new cljs.core.BlackNode(parent.key,parent.val,parent.left,node,null)); + +} +} +}); + +cljs.core.RedNode.prototype.remove_left = (function (del){ +var self__ = this; +var node = this; +return (new cljs.core.RedNode(self__.key,self__.val,del,self__.right,null)); +}); + +cljs.core.RedNode.prototype.kv_reduce = (function (f,init){ +var self__ = this; +var node = this; +return cljs.core.tree_map_kv_reduce(node,f,init); +}); + +cljs.core.RedNode.prototype.remove_right = (function (del){ +var self__ = this; +var node = this; +return (new cljs.core.RedNode(self__.key,self__.val,self__.left,del,null)); +}); + +cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +return node__$1.cljs$core$IIndexed$_nth$arity$3(null,k,null); +}); + +cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (node,k,not_found){ +var self__ = this; +var node__$1 = this; +return node__$1.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (node,n){ +var self__ = this; +var node__$1 = this; +if((n === (0))){ +return self__.key; +} else { +if((n === (1))){ +return self__.val; +} else { +throw (new Error("Index out of bounds")); + +} +} +}); + +cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (node,n,not_found){ +var self__ = this; +var node__$1 = this; +if((n === (0))){ +return self__.key; +} else { +if((n === (1))){ +return self__.val; +} else { +return not_found; + +} +} +}); + +cljs.core.RedNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = (function (node,n,v){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null).cljs$core$IVector$_assoc_n$arity$3(null,n,v); +}); + +cljs.core.RedNode.prototype.cljs$core$IMeta$_meta$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return null; +}); + +cljs.core.RedNode.prototype.cljs$core$ICounted$_count$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (2); +}); + +cljs.core.RedNode.prototype.cljs$core$IMapEntry$_key$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.key; +}); + +cljs.core.RedNode.prototype.cljs$core$IMapEntry$_val$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.val; +}); + +cljs.core.RedNode.prototype.cljs$core$IStack$_peek$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return self__.val; +}); + +cljs.core.RedNode.prototype.cljs$core$IStack$_pop$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null); +}); + +cljs.core.RedNode.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (new cljs.core.IndexedSeq([self__.val,self__.key],(0),null)); +}); + +cljs.core.RedNode.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.RedNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.RedNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return null; +}); + +cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (node,f){ +var self__ = this; +var node__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(node__$1,f); +}); + +cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (node,f,start){ +var self__ = this; +var node__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$3(node__$1,f,start); +}); + +cljs.core.RedNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (node,k,v){ +var self__ = this; +var node__$1 = this; +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),k,v); +}); + +cljs.core.RedNode.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (node,k){ +var self__ = this; +var node__$1 = this; +return (((k === (0))) || ((k === (1)))); +}); + +cljs.core.RedNode.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (node){ +var self__ = this; +var node__$1 = this; +return (new cljs.core.IndexedSeq([self__.key,self__.val],(0),null)); +}); + +cljs.core.RedNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (node,meta){ +var self__ = this; +var node__$1 = this; +return cljs.core._with_meta(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val], null),meta); +}); + +cljs.core.RedNode.prototype.cljs$core$ICollection$_conj$arity$2 = (function (node,o){ +var self__ = this; +var node__$1 = this; +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key,self__.val,o], null); +}); + +cljs.core.RedNode.prototype.call = (function() { +var G__2449 = null; +var G__2449__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var node = self____$1; +return node.cljs$core$IIndexed$_nth$arity$2(null,k); +}); +var G__2449__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var node = self____$1; +return node.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); +G__2449 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2449__2.call(this,self__,k); +case 3: +return G__2449__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2449.cljs$core$IFn$_invoke$arity$2 = G__2449__2; +G__2449.cljs$core$IFn$_invoke$arity$3 = G__2449__3; +return G__2449; +})() +; + +cljs.core.RedNode.prototype.apply = (function (self__,args2444){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2444))); +}); + +cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var node = this; +return node.cljs$core$IIndexed$_nth$arity$2(null,k); +}); + +cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var node = this; +return node.cljs$core$IIndexed$_nth$arity$3(null,k,not_found); +}); + +cljs.core.RedNode.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$key,cljs.core.cst$sym$val,cljs.core.cst$sym$left,cljs.core.cst$sym$right,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.RedNode.cljs$lang$type = true; + +cljs.core.RedNode.cljs$lang$ctorStr = "cljs.core/RedNode"; + +cljs.core.RedNode.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/RedNode"); +}); + +/** + * Positional factory function for cljs.core/RedNode. + */ +cljs.core.__GT_RedNode = (function cljs$core$__GT_RedNode(key,val,left,right,__hash){ +return (new cljs.core.RedNode(key,val,left,right,__hash)); +}); + +var G__2450_2453 = cljs.core.RedNode.prototype; +var G__2451_2454 = cljs.core.ITER_SYMBOL; +var G__2452_2455 = ((function (G__2450_2453,G__2451_2454){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2450_2453,G__2451_2454)) +; +goog.object.set(G__2450_2453,G__2451_2454,G__2452_2455); +cljs.core.tree_map_add = (function cljs$core$tree_map_add(comp,tree,k,v,found){ +if((tree == null)){ +return (new cljs.core.RedNode(k,v,null,null,null)); +} else { +var c = (function (){var G__2456 = k; +var G__2457 = tree.key; +return (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(G__2456,G__2457) : comp.call(null,G__2456,G__2457)); +})(); +if((c === (0))){ +(found[(0)] = tree); + +return null; +} else { +if((c < (0))){ +var ins = (function (){var G__2458 = comp; +var G__2459 = tree.left; +var G__2460 = k; +var G__2461 = v; +var G__2462 = found; +return (cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5 ? cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5(G__2458,G__2459,G__2460,G__2461,G__2462) : cljs.core.tree_map_add.call(null,G__2458,G__2459,G__2460,G__2461,G__2462)); +})(); +if(!((ins == null))){ +return tree.add_left(ins); +} else { +return null; +} +} else { +var ins = (function (){var G__2463 = comp; +var G__2464 = tree.right; +var G__2465 = k; +var G__2466 = v; +var G__2467 = found; +return (cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5 ? cljs.core.tree_map_add.cljs$core$IFn$_invoke$arity$5(G__2463,G__2464,G__2465,G__2466,G__2467) : cljs.core.tree_map_add.call(null,G__2463,G__2464,G__2465,G__2466,G__2467)); +})(); +if(!((ins == null))){ +return tree.add_right(ins); +} else { +return null; +} + +} +} +} +}); +cljs.core.tree_map_append = (function cljs$core$tree_map_append(left,right){ +if((left == null)){ +return right; +} else { +if((right == null)){ +return left; +} else { +if((left instanceof cljs.core.RedNode)){ +if((right instanceof cljs.core.RedNode)){ +var app = (function (){var G__2468 = left.right; +var G__2469 = right.left; +return (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__2468,G__2469) : cljs.core.tree_map_append.call(null,G__2468,G__2469)); +})(); +if((app instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(app.key,app.val,(new cljs.core.RedNode(left.key,left.val,left.left,app.left,null)),(new cljs.core.RedNode(right.key,right.val,app.right,right.right,null)),null)); +} else { +return (new cljs.core.RedNode(left.key,left.val,left.left,(new cljs.core.RedNode(right.key,right.val,app,right.right,null)),null)); +} +} else { +return (new cljs.core.RedNode(left.key,left.val,left.left,(function (){var G__2470 = left.right; +var G__2471 = right; +return (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__2470,G__2471) : cljs.core.tree_map_append.call(null,G__2470,G__2471)); +})(),null)); +} +} else { +if((right instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(right.key,right.val,(function (){var G__2472 = left; +var G__2473 = right.left; +return (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__2472,G__2473) : cljs.core.tree_map_append.call(null,G__2472,G__2473)); +})(),right.right,null)); +} else { +var app = (function (){var G__2474 = left.right; +var G__2475 = right.left; +return (cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2 ? cljs.core.tree_map_append.cljs$core$IFn$_invoke$arity$2(G__2474,G__2475) : cljs.core.tree_map_append.call(null,G__2474,G__2475)); +})(); +if((app instanceof cljs.core.RedNode)){ +return (new cljs.core.RedNode(app.key,app.val,(new cljs.core.BlackNode(left.key,left.val,left.left,app.left,null)),(new cljs.core.BlackNode(right.key,right.val,app.right,right.right,null)),null)); +} else { +return cljs.core.balance_left_del(left.key,left.val,left.left,(new cljs.core.BlackNode(right.key,right.val,app,right.right,null))); +} + +} +} +} +} +}); +cljs.core.tree_map_remove = (function cljs$core$tree_map_remove(comp,tree,k,found){ +if(!((tree == null))){ +var c = (function (){var G__2476 = k; +var G__2477 = tree.key; +return (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(G__2476,G__2477) : comp.call(null,G__2476,G__2477)); +})(); +if((c === (0))){ +(found[(0)] = tree); + +return cljs.core.tree_map_append(tree.left,tree.right); +} else { +if((c < (0))){ +var del = (function (){var G__2478 = comp; +var G__2479 = tree.left; +var G__2480 = k; +var G__2481 = found; +return (cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4(G__2478,G__2479,G__2480,G__2481) : cljs.core.tree_map_remove.call(null,G__2478,G__2479,G__2480,G__2481)); +})(); +if(((!((del == null))) || (!(((found[(0)]) == null))))){ +if((tree.left instanceof cljs.core.BlackNode)){ +return cljs.core.balance_left_del(tree.key,tree.val,del,tree.right); +} else { +return (new cljs.core.RedNode(tree.key,tree.val,del,tree.right,null)); +} +} else { +return null; +} +} else { +var del = (function (){var G__2482 = comp; +var G__2483 = tree.right; +var G__2484 = k; +var G__2485 = found; +return (cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_remove.cljs$core$IFn$_invoke$arity$4(G__2482,G__2483,G__2484,G__2485) : cljs.core.tree_map_remove.call(null,G__2482,G__2483,G__2484,G__2485)); +})(); +if(((!((del == null))) || (!(((found[(0)]) == null))))){ +if((tree.right instanceof cljs.core.BlackNode)){ +return cljs.core.balance_right_del(tree.key,tree.val,tree.left,del); +} else { +return (new cljs.core.RedNode(tree.key,tree.val,tree.left,del,null)); +} +} else { +return null; +} + +} +} +} else { +return null; +} +}); +cljs.core.tree_map_replace = (function cljs$core$tree_map_replace(comp,tree,k,v){ +var tk = tree.key; +var c = (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(k,tk) : comp.call(null,k,tk)); +if((c === (0))){ +return tree.replace(tk,v,tree.left,tree.right); +} else { +if((c < (0))){ +return tree.replace(tk,tree.val,(function (){var G__2486 = comp; +var G__2487 = tree.left; +var G__2488 = k; +var G__2489 = v; +return (cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4(G__2486,G__2487,G__2488,G__2489) : cljs.core.tree_map_replace.call(null,G__2486,G__2487,G__2488,G__2489)); +})(),tree.right); +} else { +return tree.replace(tk,tree.val,tree.left,(function (){var G__2490 = comp; +var G__2491 = tree.right; +var G__2492 = k; +var G__2493 = v; +return (cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4 ? cljs.core.tree_map_replace.cljs$core$IFn$_invoke$arity$4(G__2490,G__2491,G__2492,G__2493) : cljs.core.tree_map_replace.call(null,G__2490,G__2491,G__2492,G__2493)); +})()); + +} +} +}); + +/** +* @constructor + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IKVReduce} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IFind} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISorted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.IMap} + * @implements {cljs.core.ILookup} +*/ +cljs.core.PersistentTreeMap = (function (comp,tree,cnt,meta,__hash){ +this.comp = comp; +this.tree = tree; +this.cnt = cnt; +this.meta = meta; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 418776847; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}); +cljs.core.PersistentTreeMap.prototype.cljs$core$IFind$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentTreeMap.prototype.cljs$core$IFind$_find$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.entry_at(k); +}); + +cljs.core.PersistentTreeMap.prototype.forEach = (function (f){ +var self__ = this; +var coll = this; +var seq__2495 = cljs.core.seq(coll); +var chunk__2496 = null; +var count__2497 = (0); +var i__2498 = (0); +while(true){ +if((i__2498 < count__2497)){ +var vec__2499 = chunk__2496.cljs$core$IIndexed$_nth$arity$2(null,i__2498); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2499,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2499,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2509 = seq__2495; +var G__2510 = chunk__2496; +var G__2511 = count__2497; +var G__2512 = (i__2498 + (1)); +seq__2495 = G__2509; +chunk__2496 = G__2510; +count__2497 = G__2511; +i__2498 = G__2512; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2495); +if(temp__5457__auto__){ +var seq__2495__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2495__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2495__$1); +var G__2513 = cljs.core.chunk_rest(seq__2495__$1); +var G__2514 = c__4338__auto__; +var G__2515 = cljs.core.count(c__4338__auto__); +var G__2516 = (0); +seq__2495 = G__2513; +chunk__2496 = G__2514; +count__2497 = G__2515; +i__2498 = G__2516; +continue; +} else { +var vec__2502 = cljs.core.first(seq__2495__$1); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2502,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2502,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2517 = cljs.core.next(seq__2495__$1); +var G__2518 = null; +var G__2519 = (0); +var G__2520 = (0); +seq__2495 = G__2517; +chunk__2496 = G__2518; +count__2497 = G__2519; +i__2498 = G__2520; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.PersistentTreeMap.prototype.get = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentTreeMap.prototype.entries = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_entries_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentTreeMap.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentTreeMap.prototype.keys = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.keys(coll)); +}); + +cljs.core.PersistentTreeMap.prototype.values = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.vals(coll)); +}); + +cljs.core.PersistentTreeMap.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentTreeMap.prototype.entry_at = (function (k){ +var self__ = this; +var coll = this; +var t = self__.tree; +while(true){ +if(!((t == null))){ +var c = (function (){var G__2505 = k; +var G__2506 = t.key; +return (self__.comp.cljs$core$IFn$_invoke$arity$2 ? self__.comp.cljs$core$IFn$_invoke$arity$2(G__2505,G__2506) : self__.comp.call(null,G__2505,G__2506)); +})(); +if((c === (0))){ +return t; +} else { +if((c < (0))){ +var G__2521 = t.left; +t = G__2521; +continue; +} else { +var G__2522 = t.right; +t = G__2522; +continue; + +} +} +} else { +return null; +} +break; +} +}); + +cljs.core.PersistentTreeMap.prototype.has = (function (k){ +var self__ = this; +var coll = this; +return cljs.core.contains_QMARK_(coll,k); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,k,null); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,k,not_found){ +var self__ = this; +var coll__$1 = this; +var n = coll__$1.entry_at(k); +if(!((n == null))){ +return n.val; +} else { +return not_found; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = (function (coll,f,init){ +var self__ = this; +var coll__$1 = this; +if(!((self__.tree == null))){ +return cljs.core.unreduced(cljs.core.tree_map_kv_reduce(self__.tree,f,init)); +} else { +return init; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.PersistentTreeMap(self__.comp,self__.tree,self__.cnt,self__.meta,self__.__hash)); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.cnt; +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +return cljs.core.create_tree_map_seq(self__.tree,false,self__.cnt); +} else { +return null; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_unordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_map(coll__$1,other); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeMap(self__.comp,null,(0),self__.meta,(0))); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IMap$_dissoc$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +var found = [null]; +var t = cljs.core.tree_map_remove(self__.comp,self__.tree,k,found); +if((t == null)){ +if((cljs.core.nth.cljs$core$IFn$_invoke$arity$2(found,(0)) == null)){ +return coll__$1; +} else { +return (new cljs.core.PersistentTreeMap(self__.comp,null,(0),self__.meta,null)); +} +} else { +return (new cljs.core.PersistentTreeMap(self__.comp,t.blacken(),(self__.cnt - (1)),self__.meta,null)); +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (coll,k,v){ +var self__ = this; +var coll__$1 = this; +var found = [null]; +var t = cljs.core.tree_map_add(self__.comp,self__.tree,k,v,found); +if((t == null)){ +var found_node = cljs.core.nth.cljs$core$IFn$_invoke$arity$2(found,(0)); +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(v,found_node.val)){ +return coll__$1; +} else { +return (new cljs.core.PersistentTreeMap(self__.comp,cljs.core.tree_map_replace(self__.comp,self__.tree,k,v),self__.cnt,self__.meta,null)); +} +} else { +return (new cljs.core.PersistentTreeMap(self__.comp,t.blacken(),(self__.cnt + (1)),self__.meta,null)); +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = (function (coll,k){ +var self__ = this; +var coll__$1 = this; +return !((coll__$1.entry_at(k) == null)); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +return cljs.core.create_tree_map_seq(self__.tree,true,self__.cnt); +} else { +return null; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeMap(self__.comp,self__.tree,self__.cnt,meta__$1,self__.__hash)); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,entry){ +var self__ = this; +var coll__$1 = this; +if(cljs.core.vector_QMARK_(entry)){ +return coll__$1.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry,(1))); +} else { +var ret = coll__$1; +var es = cljs.core.seq(entry); +while(true){ +if((es == null)){ +return ret; +} else { +var e = cljs.core.first(es); +if(cljs.core.vector_QMARK_(e)){ +var G__2523 = ret.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(e,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(e,(1))); +var G__2524 = cljs.core.next(es); +ret = G__2523; +es = G__2524; +continue; +} else { +throw (new Error("conj on a map takes map entries or seqables of map entries")); +} +} +break; +} +} +}); + +cljs.core.PersistentTreeMap.prototype.call = (function() { +var G__2525 = null; +var G__2525__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2525__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2525 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2525__2.call(this,self__,k); +case 3: +return G__2525__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2525.cljs$core$IFn$_invoke$arity$2 = G__2525__2; +G__2525.cljs$core$IFn$_invoke$arity$3 = G__2525__3; +return G__2525; +})() +; + +cljs.core.PersistentTreeMap.prototype.apply = (function (self__,args2494){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2494))); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq$arity$2 = (function (coll,ascending_QMARK_){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +return cljs.core.create_tree_map_seq(self__.tree,ascending_QMARK_,self__.cnt); +} else { +return null; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq_from$arity$3 = (function (coll,k,ascending_QMARK_){ +var self__ = this; +var coll__$1 = this; +if((self__.cnt > (0))){ +var stack = null; +var t = self__.tree; +while(true){ +if(!((t == null))){ +var c = (function (){var G__2507 = k; +var G__2508 = t.key; +return (self__.comp.cljs$core$IFn$_invoke$arity$2 ? self__.comp.cljs$core$IFn$_invoke$arity$2(G__2507,G__2508) : self__.comp.call(null,G__2507,G__2508)); +})(); +if((c === (0))){ +return (new cljs.core.PersistentTreeMapSeq(null,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack,t),ascending_QMARK_,(-1),null)); +} else { +if(cljs.core.truth_(ascending_QMARK_)){ +if((c < (0))){ +var G__2526 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack,t); +var G__2527 = t.left; +stack = G__2526; +t = G__2527; +continue; +} else { +var G__2528 = stack; +var G__2529 = t.right; +stack = G__2528; +t = G__2529; +continue; +} +} else { +if((c > (0))){ +var G__2530 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(stack,t); +var G__2531 = t.right; +stack = G__2530; +t = G__2531; +continue; +} else { +var G__2532 = stack; +var G__2533 = t.left; +stack = G__2532; +t = G__2533; +continue; +} + +} +} +} else { +if((stack == null)){ +return null; +} else { +return (new cljs.core.PersistentTreeMapSeq(null,stack,ascending_QMARK_,(-1),null)); +} +} +break; +} +} else { +return null; +} +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_entry_key$arity$2 = (function (coll,entry){ +var self__ = this; +var coll__$1 = this; +return cljs.core.key(entry); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_comparator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.comp; +}); + +cljs.core.PersistentTreeMap.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$comp,cljs.core.cst$sym$tree,cljs.core.cst$sym$cnt,cljs.core.cst$sym$meta,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentTreeMap.cljs$lang$type = true; + +cljs.core.PersistentTreeMap.cljs$lang$ctorStr = "cljs.core/PersistentTreeMap"; + +cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentTreeMap"); +}); + +/** + * Positional factory function for cljs.core/PersistentTreeMap. + */ +cljs.core.__GT_PersistentTreeMap = (function cljs$core$__GT_PersistentTreeMap(comp,tree,cnt,meta,__hash){ +return (new cljs.core.PersistentTreeMap(comp,tree,cnt,meta,__hash)); +}); + +cljs.core.PersistentTreeMap.EMPTY = (new cljs.core.PersistentTreeMap(cljs.core.compare,null,(0),null,cljs.core.empty_unordered_hash)); +var G__2534_2537 = cljs.core.PersistentTreeMap.prototype; +var G__2535_2538 = cljs.core.ITER_SYMBOL; +var G__2536_2539 = ((function (G__2534_2537,G__2535_2538){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2534_2537,G__2535_2538)) +; +goog.object.set(G__2534_2537,G__2535_2538,G__2536_2539); +/** + * keyval => key val + * Returns a new hash map with supplied mappings. + */ +cljs.core.hash_map = (function cljs$core$hash_map(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2541 = arguments.length; +var i__4519__auto___2542 = (0); +while(true){ +if((i__4519__auto___2542 < len__4518__auto___2541)){ +args__4521__auto__.push((arguments[i__4519__auto___2542])); + +var G__2543 = (i__4519__auto___2542 + (1)); +i__4519__auto___2542 = G__2543; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.hash_map.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.hash_map.cljs$core$IFn$_invoke$arity$variadic = (function (keyvals){ +var in$ = cljs.core.seq(keyvals); +var out = cljs.core.transient$(cljs.core.PersistentHashMap.EMPTY); +while(true){ +if(in$){ +var G__2544 = cljs.core.nnext(in$); +var G__2545 = cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(out,cljs.core.first(in$),cljs.core.second(in$)); +in$ = G__2544; +out = G__2545; +continue; +} else { +return cljs.core.persistent_BANG_(out); +} +break; +} +}); + +cljs.core.hash_map.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.hash_map.cljs$lang$applyTo = (function (seq2540){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2540)); +}); + +/** + * keyval => key val + * Returns a new array map with supplied mappings. + */ +cljs.core.array_map = (function cljs$core$array_map(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2547 = arguments.length; +var i__4519__auto___2548 = (0); +while(true){ +if((i__4519__auto___2548 < len__4518__auto___2547)){ +args__4521__auto__.push((arguments[i__4519__auto___2548])); + +var G__2549 = (i__4519__auto___2548 + (1)); +i__4519__auto___2548 = G__2549; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.array_map.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.array_map.cljs$core$IFn$_invoke$arity$variadic = (function (keyvals){ +var arr = (((((keyvals instanceof cljs.core.IndexedSeq)) && ((keyvals.i === (0)))))?keyvals.arr:cljs.core.into_array.cljs$core$IFn$_invoke$arity$1(keyvals)); +return cljs.core.PersistentArrayMap.createAsIfByAssoc(arr); +}); + +cljs.core.array_map.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.array_map.cljs$lang$applyTo = (function (seq2546){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2546)); +}); + +/** + * keyval => key val + * Returns a new object map with supplied mappings. + */ +cljs.core.obj_map = (function cljs$core$obj_map(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2556 = arguments.length; +var i__4519__auto___2557 = (0); +while(true){ +if((i__4519__auto___2557 < len__4518__auto___2556)){ +args__4521__auto__.push((arguments[i__4519__auto___2557])); + +var G__2558 = (i__4519__auto___2557 + (1)); +i__4519__auto___2557 = G__2558; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.obj_map.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.obj_map.cljs$core$IFn$_invoke$arity$variadic = (function (keyvals){ +var ks = []; +var obj = {}; +var kvs = cljs.core.seq(keyvals); +while(true){ +if(kvs){ +ks.push(cljs.core.first(kvs)); + +var G__2553_2559 = obj; +var G__2554_2560 = cljs.core.first(kvs); +var G__2555_2561 = cljs.core.second(kvs); +goog.object.set(G__2553_2559,G__2554_2560,G__2555_2561); + +var G__2562 = cljs.core.nnext(kvs); +kvs = G__2562; +continue; +} else { +return cljs.core.ObjMap.fromObject(ks,obj); +} +break; +} +}); + +cljs.core.obj_map.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.obj_map.cljs$lang$applyTo = (function (seq2550){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2550)); +}); + +/** + * keyval => key val + * Returns a new sorted map with supplied mappings. + */ +cljs.core.sorted_map = (function cljs$core$sorted_map(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2564 = arguments.length; +var i__4519__auto___2565 = (0); +while(true){ +if((i__4519__auto___2565 < len__4518__auto___2564)){ +args__4521__auto__.push((arguments[i__4519__auto___2565])); + +var G__2566 = (i__4519__auto___2565 + (1)); +i__4519__auto___2565 = G__2566; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.sorted_map.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.sorted_map.cljs$core$IFn$_invoke$arity$variadic = (function (keyvals){ +var in$ = cljs.core.seq(keyvals); +var out = cljs.core.PersistentTreeMap.EMPTY; +while(true){ +if(in$){ +var G__2567 = cljs.core.nnext(in$); +var G__2568 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(out,cljs.core.first(in$),cljs.core.second(in$)); +in$ = G__2567; +out = G__2568; +continue; +} else { +return out; +} +break; +} +}); + +cljs.core.sorted_map.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.sorted_map.cljs$lang$applyTo = (function (seq2563){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2563)); +}); + +/** + * keyval => key val + * Returns a new sorted map with supplied mappings, using the supplied comparator. + */ +cljs.core.sorted_map_by = (function cljs$core$sorted_map_by(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2571 = arguments.length; +var i__4519__auto___2572 = (0); +while(true){ +if((i__4519__auto___2572 < len__4518__auto___2571)){ +args__4521__auto__.push((arguments[i__4519__auto___2572])); + +var G__2573 = (i__4519__auto___2572 + (1)); +i__4519__auto___2572 = G__2573; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.core.sorted_map_by.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.core.sorted_map_by.cljs$core$IFn$_invoke$arity$variadic = (function (comparator,keyvals){ +var in$ = cljs.core.seq(keyvals); +var out = (new cljs.core.PersistentTreeMap(cljs.core.fn__GT_comparator(comparator),null,(0),null,(0))); +while(true){ +if(in$){ +var G__2574 = cljs.core.nnext(in$); +var G__2575 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(out,cljs.core.first(in$),cljs.core.second(in$)); +in$ = G__2574; +out = G__2575; +continue; +} else { +return out; +} +break; +} +}); + +cljs.core.sorted_map_by.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.core.sorted_map_by.cljs$lang$applyTo = (function (seq2569){ +var G__2570 = cljs.core.first(seq2569); +var seq2569__$1 = cljs.core.next(seq2569); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2570,seq2569__$1); +}); + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.KeySeq = (function (mseq,_meta){ +this.mseq = mseq; +this._meta = _meta; +this.cljs$lang$protocol_mask$partition0$ = 32374988; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.KeySeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.KeySeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.KeySeq.prototype.indexOf = (function() { +var G__2578 = null; +var G__2578__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2578__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2578 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2578__1.call(this,x); +case 2: +return G__2578__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2578.cljs$core$IFn$_invoke$arity$1 = G__2578__1; +G__2578.cljs$core$IFn$_invoke$arity$2 = G__2578__2; +return G__2578; +})() +; + +cljs.core.KeySeq.prototype.lastIndexOf = (function() { +var G__2579 = null; +var G__2579__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2579__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2579 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2579__1.call(this,x); +case 2: +return G__2579__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2579.cljs$core$IFn$_invoke$arity$1 = G__2579__1; +G__2579.cljs$core$IFn$_invoke$arity$2 = G__2579__2; +return G__2579; +})() +; + +cljs.core.KeySeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__._meta; +}); + +cljs.core.KeySeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var nseq = ((((!((self__.mseq == null)))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ & (128))) || ((cljs.core.PROTOCOL_SENTINEL === self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null):cljs.core.next(self__.mseq)); +if((nseq == null)){ +return null; +} else { +return (new cljs.core.KeySeq(nseq,self__._meta)); +} +}); + +cljs.core.KeySeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.hash_ordered_coll(coll__$1); +}); + +cljs.core.KeySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.KeySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__._meta); +}); + +cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.KeySeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var me = self__.mseq.cljs$core$ISeq$_first$arity$1(null); +return me.cljs$core$IMapEntry$_key$arity$1(null); +}); + +cljs.core.KeySeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var nseq = ((((!((self__.mseq == null)))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ & (128))) || ((cljs.core.PROTOCOL_SENTINEL === self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null):cljs.core.next(self__.mseq)); +if(!((nseq == null))){ +return (new cljs.core.KeySeq(nseq,self__._meta)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.KeySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.KeySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,new_meta){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.KeySeq(self__.mseq,new_meta)); +}); + +cljs.core.KeySeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.KeySeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$mseq,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$not_DASH_native], null)),cljs.core.cst$sym$_meta], null); +}); + +cljs.core.KeySeq.cljs$lang$type = true; + +cljs.core.KeySeq.cljs$lang$ctorStr = "cljs.core/KeySeq"; + +cljs.core.KeySeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/KeySeq"); +}); + +/** + * Positional factory function for cljs.core/KeySeq. + */ +cljs.core.__GT_KeySeq = (function cljs$core$__GT_KeySeq(mseq,_meta){ +return (new cljs.core.KeySeq(mseq,_meta)); +}); + +var G__2580_2583 = cljs.core.KeySeq.prototype; +var G__2581_2584 = cljs.core.ITER_SYMBOL; +var G__2582_2585 = ((function (G__2580_2583,G__2581_2584){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2580_2583,G__2581_2584)) +; +goog.object.set(G__2580_2583,G__2581_2584,G__2582_2585); +/** + * Returns a sequence of the map's keys. + */ +cljs.core.keys = (function cljs$core$keys(hash_map){ +var temp__5457__auto__ = cljs.core.seq(hash_map); +if(temp__5457__auto__){ +var mseq = temp__5457__auto__; +return (new cljs.core.KeySeq(mseq,null)); +} else { +return null; +} +}); +/** + * Returns the key of the map entry. + */ +cljs.core.key = (function cljs$core$key(map_entry){ +return cljs.core._key(map_entry); +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.ValSeq = (function (mseq,_meta){ +this.mseq = mseq; +this._meta = _meta; +this.cljs$lang$protocol_mask$partition0$ = 32374988; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.ValSeq.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.ValSeq.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.ValSeq.prototype.indexOf = (function() { +var G__2588 = null; +var G__2588__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2588__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2588 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2588__1.call(this,x); +case 2: +return G__2588__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2588.cljs$core$IFn$_invoke$arity$1 = G__2588__1; +G__2588.cljs$core$IFn$_invoke$arity$2 = G__2588__2; +return G__2588; +})() +; + +cljs.core.ValSeq.prototype.lastIndexOf = (function() { +var G__2589 = null; +var G__2589__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2589__2 = (function (x,start){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start); +}); +G__2589 = function(x,start){ +switch(arguments.length){ +case 1: +return G__2589__1.call(this,x); +case 2: +return G__2589__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2589.cljs$core$IFn$_invoke$arity$1 = G__2589__1; +G__2589.cljs$core$IFn$_invoke$arity$2 = G__2589__2; +return G__2589; +})() +; + +cljs.core.ValSeq.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__._meta; +}); + +cljs.core.ValSeq.prototype.cljs$core$INext$_next$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var nseq = ((((!((self__.mseq == null)))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ & (128))) || ((cljs.core.PROTOCOL_SENTINEL === self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null):cljs.core.next(self__.mseq)); +if((nseq == null)){ +return null; +} else { +return (new cljs.core.ValSeq(nseq,self__._meta)); +} +}); + +cljs.core.ValSeq.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.hash_ordered_coll(coll__$1); +}); + +cljs.core.ValSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +return cljs.core.equiv_sequential(coll__$1,other); +}); + +cljs.core.ValSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__._meta); +}); + +cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (coll,f){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$2(f,coll__$1); +}); + +cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (coll,f,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core.seq_reduce.cljs$core$IFn$_invoke$arity$3(f,start,coll__$1); +}); + +cljs.core.ValSeq.prototype.cljs$core$ISeq$_first$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var me = self__.mseq.cljs$core$ISeq$_first$arity$1(null); +return me.cljs$core$IMapEntry$_val$arity$1(null); +}); + +cljs.core.ValSeq.prototype.cljs$core$ISeq$_rest$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var nseq = ((((!((self__.mseq == null)))?(((((self__.mseq.cljs$lang$protocol_mask$partition0$ & (128))) || ((cljs.core.PROTOCOL_SENTINEL === self__.mseq.cljs$core$INext$))))?true:(((!self__.mseq.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq):false)):cljs.core.native_satisfies_QMARK_(cljs.core.INext,self__.mseq)))?self__.mseq.cljs$core$INext$_next$arity$1(null):cljs.core.next(self__.mseq)); +if(!((nseq == null))){ +return (new cljs.core.ValSeq(nseq,self__._meta)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.ValSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return coll__$1; +}); + +cljs.core.ValSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,new_meta){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.ValSeq(self__.mseq,new_meta)); +}); + +cljs.core.ValSeq.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return cljs.core.cons(o,coll__$1); +}); + +cljs.core.ValSeq.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$mseq,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$not_DASH_native], null)),cljs.core.cst$sym$_meta], null); +}); + +cljs.core.ValSeq.cljs$lang$type = true; + +cljs.core.ValSeq.cljs$lang$ctorStr = "cljs.core/ValSeq"; + +cljs.core.ValSeq.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ValSeq"); +}); + +/** + * Positional factory function for cljs.core/ValSeq. + */ +cljs.core.__GT_ValSeq = (function cljs$core$__GT_ValSeq(mseq,_meta){ +return (new cljs.core.ValSeq(mseq,_meta)); +}); + +var G__2590_2593 = cljs.core.ValSeq.prototype; +var G__2591_2594 = cljs.core.ITER_SYMBOL; +var G__2592_2595 = ((function (G__2590_2593,G__2591_2594){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2590_2593,G__2591_2594)) +; +goog.object.set(G__2590_2593,G__2591_2594,G__2592_2595); +/** + * Returns a sequence of the map's values. + */ +cljs.core.vals = (function cljs$core$vals(hash_map){ +var temp__5457__auto__ = cljs.core.seq(hash_map); +if(temp__5457__auto__){ +var mseq = temp__5457__auto__; +return (new cljs.core.ValSeq(mseq,null)); +} else { +return null; +} +}); +/** + * Returns the value in the map entry. + */ +cljs.core.val = (function cljs$core$val(map_entry){ +return cljs.core._val(map_entry); +}); +/** + * Returns a map that consists of the rest of the maps conj-ed onto + * the first. If a key occurs in more than one map, the mapping from + * the latter (left-to-right) will be the mapping in the result. + */ +cljs.core.merge = (function cljs$core$merge(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2599 = arguments.length; +var i__4519__auto___2600 = (0); +while(true){ +if((i__4519__auto___2600 < len__4518__auto___2599)){ +args__4521__auto__.push((arguments[i__4519__auto___2600])); + +var G__2601 = (i__4519__auto___2600 + (1)); +i__4519__auto___2600 = G__2601; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic = (function (maps){ +if(cljs.core.truth_(cljs.core.some(cljs.core.identity,maps))){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$2((function (p1__2596_SHARP_,p2__2597_SHARP_){ +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2((function (){var or__3936__auto__ = p1__2596_SHARP_; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.PersistentArrayMap.EMPTY; +} +})(),p2__2597_SHARP_); +}),maps); +} else { +return null; +} +}); + +cljs.core.merge.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.merge.cljs$lang$applyTo = (function (seq2598){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2598)); +}); + +/** + * Returns a map that consists of the rest of the maps conj-ed onto + * the first. If a key occurs in more than one map, the mapping(s) + * from the latter (left-to-right) will be combined with the mapping in + * the result by calling (f val-in-result val-in-latter). + */ +cljs.core.merge_with = (function cljs$core$merge_with(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2606 = arguments.length; +var i__4519__auto___2607 = (0); +while(true){ +if((i__4519__auto___2607 < len__4518__auto___2606)){ +args__4521__auto__.push((arguments[i__4519__auto___2607])); + +var G__2608 = (i__4519__auto___2607 + (1)); +i__4519__auto___2607 = G__2608; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.core.merge_with.cljs$core$IFn$_invoke$arity$variadic = (function (f,maps){ +if(cljs.core.truth_(cljs.core.some(cljs.core.identity,maps))){ +var merge_entry = (function (m,e){ +var k = cljs.core.first(e); +var v = cljs.core.second(e); +if(cljs.core.contains_QMARK_(m,k)){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__2604 = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k); +var G__2605 = v; +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2604,G__2605) : f.call(null,G__2604,G__2605)); +})()); +} else { +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v); +} +}); +var merge2 = ((function (merge_entry){ +return (function (m1,m2){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(merge_entry,(function (){var or__3936__auto__ = m1; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.PersistentArrayMap.EMPTY; +} +})(),cljs.core.seq(m2)); +});})(merge_entry)) +; +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$2(merge2,maps); +} else { +return null; +} +}); + +cljs.core.merge_with.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.core.merge_with.cljs$lang$applyTo = (function (seq2602){ +var G__2603 = cljs.core.first(seq2602); +var seq2602__$1 = cljs.core.next(seq2602); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2603,seq2602__$1); +}); + +/** + * Returns a map containing only those entries in map whose key is in keys + */ +cljs.core.select_keys = (function cljs$core$select_keys(map,keyseq){ +var ret = cljs.core.PersistentArrayMap.EMPTY; +var keys = cljs.core.seq(keyseq); +while(true){ +if(keys){ +var key = cljs.core.first(keys); +var entry = cljs.core.get.cljs$core$IFn$_invoke$arity$3(map,key,cljs.core.cst$kw$cljs$core_SLASH_not_DASH_found); +var G__2609 = ((cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(entry,cljs.core.cst$kw$cljs$core_SLASH_not_DASH_found))?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,key,entry):ret); +var G__2610 = cljs.core.next(keys); +ret = G__2609; +keys = G__2610; +continue; +} else { +return cljs.core._with_meta(ret,cljs.core.meta(map)); +} +break; +} +}); + +/** +* @constructor +*/ +cljs.core.HashSetIter = (function (iter){ +this.iter = iter; +}); +cljs.core.HashSetIter.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +return self__.iter.hasNext(); +}); + +cljs.core.HashSetIter.prototype.next = (function (){ +var self__ = this; +var _ = this; +if(self__.iter.hasNext()){ +return self__.iter.next().key; +} else { +throw (new Error("No such element")); +} +}); + +cljs.core.HashSetIter.prototype.remove = (function (){ +var self__ = this; +var _ = this; +return (new Error("Unsupported operation")); +}); + +cljs.core.HashSetIter.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$iter], null); +}); + +cljs.core.HashSetIter.cljs$lang$type = true; + +cljs.core.HashSetIter.cljs$lang$ctorStr = "cljs.core/HashSetIter"; + +cljs.core.HashSetIter.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/HashSetIter"); +}); + +/** + * Positional factory function for cljs.core/HashSetIter. + */ +cljs.core.__GT_HashSetIter = (function cljs$core$__GT_HashSetIter(iter){ +return (new cljs.core.HashSetIter(iter)); +}); + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEditableCollection} + * @implements {cljs.core.ISet} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.ILookup} +*/ +cljs.core.PersistentHashSet = (function (meta,hash_map,__hash){ +this.meta = meta; +this.hash_map = hash_map; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 15077647; +this.cljs$lang$protocol_mask$partition1$ = 139268; +}); +cljs.core.PersistentHashSet.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentHashSet.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentHashSet.prototype.keys = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentHashSet.prototype.entries = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_set_entries_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentHashSet.prototype.values = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentHashSet.prototype.has = (function (k){ +var self__ = this; +var coll = this; +return cljs.core.contains_QMARK_(coll,k); +}); + +cljs.core.PersistentHashSet.prototype.forEach = (function (f){ +var self__ = this; +var coll = this; +var seq__2614 = cljs.core.seq(coll); +var chunk__2615 = null; +var count__2616 = (0); +var i__2617 = (0); +while(true){ +if((i__2617 < count__2616)){ +var vec__2618 = chunk__2615.cljs$core$IIndexed$_nth$arity$2(null,i__2617); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2618,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2618,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2627 = seq__2614; +var G__2628 = chunk__2615; +var G__2629 = count__2616; +var G__2630 = (i__2617 + (1)); +seq__2614 = G__2627; +chunk__2615 = G__2628; +count__2616 = G__2629; +i__2617 = G__2630; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2614); +if(temp__5457__auto__){ +var seq__2614__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2614__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2614__$1); +var G__2631 = cljs.core.chunk_rest(seq__2614__$1); +var G__2632 = c__4338__auto__; +var G__2633 = cljs.core.count(c__4338__auto__); +var G__2634 = (0); +seq__2614 = G__2631; +chunk__2615 = G__2632; +count__2616 = G__2633; +i__2617 = G__2634; +continue; +} else { +var vec__2621 = cljs.core.first(seq__2614__$1); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2621,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2621,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2635 = cljs.core.next(seq__2614__$1); +var G__2636 = null; +var G__2637 = (0); +var G__2638 = (0); +seq__2614 = G__2635; +chunk__2615 = G__2636; +count__2616 = G__2637; +i__2617 = G__2638; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,v){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,v,null); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,v,not_found){ +var self__ = this; +var coll__$1 = this; +var temp__5455__auto__ = cljs.core._find(self__.hash_map,v); +if(cljs.core.truth_(temp__5455__auto__)){ +var entry = temp__5455__auto__; +return cljs.core.key(entry); +} else { +return not_found; +} +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.HashSetIter(cljs.core._iterator(self__.hash_map))); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.PersistentHashSet(self__.meta,self__.hash_map,self__.__hash)); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._count(self__.hash_map); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_unordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +var and__3925__auto__ = cljs.core.set_QMARK_(other); +if(and__3925__auto__){ +var and__3925__auto____$1 = (cljs.core.count(coll__$1) === cljs.core.count(other)); +if(and__3925__auto____$1){ +try{return cljs.core.reduce_kv(((function (and__3925__auto____$1,and__3925__auto__,coll__$1){ +return (function (p1__2612_SHARP_,p2__2611_SHARP_){ +var or__3936__auto__ = cljs.core.contains_QMARK_(other,p2__2611_SHARP_); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return cljs.core.reduced(false); +} +});})(and__3925__auto____$1,and__3925__auto__,coll__$1)) +,true,self__.hash_map); +}catch (e2626){if((e2626 instanceof Error)){ +var ex = e2626; +return false; +} else { +throw e2626; + +} +}} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.TransientHashSet(cljs.core._as_transient(self__.hash_map))); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._with_meta(cljs.core.PersistentHashSet.EMPTY,self__.meta); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ISet$_disjoin$arity$2 = (function (coll,v){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentHashSet(self__.meta,cljs.core._dissoc(self__.hash_map,v),null)); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.keys(self__.hash_map); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentHashSet(meta__$1,self__.hash_map,self__.__hash)); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentHashSet(self__.meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.hash_map,o,null),null)); +}); + +cljs.core.PersistentHashSet.prototype.call = (function() { +var G__2639 = null; +var G__2639__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2639__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2639 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2639__2.call(this,self__,k); +case 3: +return G__2639__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2639.cljs$core$IFn$_invoke$arity$2 = G__2639__2; +G__2639.cljs$core$IFn$_invoke$arity$3 = G__2639__3; +return G__2639; +})() +; + +cljs.core.PersistentHashSet.prototype.apply = (function (self__,args2613){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2613))); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentHashSet.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$hash_DASH_map,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentHashSet.cljs$lang$type = true; + +cljs.core.PersistentHashSet.cljs$lang$ctorStr = "cljs.core/PersistentHashSet"; + +cljs.core.PersistentHashSet.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentHashSet"); +}); + +/** + * Positional factory function for cljs.core/PersistentHashSet. + */ +cljs.core.__GT_PersistentHashSet = (function cljs$core$__GT_PersistentHashSet(meta,hash_map,__hash){ +return (new cljs.core.PersistentHashSet(meta,hash_map,__hash)); +}); + +cljs.core.PersistentHashSet.EMPTY = (new cljs.core.PersistentHashSet(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.empty_unordered_hash)); +cljs.core.PersistentHashSet.fromArray = (function (items,no_clone){ +var len = items.length; +if((len <= cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)){ +var arr = ((no_clone)?items:cljs.core.aclone(items)); +var i = (0); +var out = cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY); +while(true){ +if((i < len)){ +var G__2640 = (i + (1)); +var G__2641 = cljs.core._assoc_BANG_(out,(items[i]),null); +i = G__2640; +out = G__2641; +continue; +} else { +return (new cljs.core.PersistentHashSet(null,cljs.core._persistent_BANG_(out),null)); +} +break; +} +} else { +var i = (0); +var out = cljs.core.transient$(cljs.core.PersistentHashSet.EMPTY); +while(true){ +if((i < len)){ +var G__2642 = (i + (1)); +var G__2643 = cljs.core._conj_BANG_(out,(items[i])); +i = G__2642; +out = G__2643; +continue; +} else { +return cljs.core._persistent_BANG_(out); +} +break; +} +} +}); +cljs.core.PersistentHashSet.createWithCheck = (function (items){ +var len = items.length; +var t = cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY); +var n__4395__auto___2644 = len; +var i_2645 = (0); +while(true){ +if((i_2645 < n__4395__auto___2644)){ +cljs.core._conj_BANG_(t,(items[i_2645])); + +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(t),(i_2645 + (1)))){ +} else { +throw (new Error(["Duplicate key: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1((items[i_2645]))].join(''))); +} + +var G__2646 = (i_2645 + (1)); +i_2645 = G__2646; +continue; +} else { +} +break; +} + +return cljs.core._persistent_BANG_(t); +}); +cljs.core.PersistentHashSet.createAsIfByAssoc = (function (items){ +var len = items.length; +var t = cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY); +var n__4395__auto___2647 = len; +var i_2648 = (0); +while(true){ +if((i_2648 < n__4395__auto___2647)){ +cljs.core._conj_BANG_(t,(items[i_2648])); + +var G__2649 = (i_2648 + (1)); +i_2648 = G__2649; +continue; +} else { +} +break; +} + +return cljs.core._persistent_BANG_(t); +}); +var G__2650_2653 = cljs.core.PersistentHashSet.prototype; +var G__2651_2654 = cljs.core.ITER_SYMBOL; +var G__2652_2655 = ((function (G__2650_2653,G__2651_2654){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2650_2653,G__2651_2654)) +; +goog.object.set(G__2650_2653,G__2651_2654,G__2652_2655); + +/** +* @constructor + * @implements {cljs.core.ITransientSet} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ITransientCollection} + * @implements {cljs.core.ILookup} +*/ +cljs.core.TransientHashSet = (function (transient_map){ +this.transient_map = transient_map; +this.cljs$lang$protocol_mask$partition1$ = 136; +this.cljs$lang$protocol_mask$partition0$ = 259; +}); +cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = (function (tcoll,o){ +var self__ = this; +var tcoll__$1 = this; +self__.transient_map = cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(self__.transient_map,o,null); + +return tcoll__$1; +}); + +cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +return (new cljs.core.PersistentHashSet(null,cljs.core.persistent_BANG_(self__.transient_map),null)); +}); + +cljs.core.TransientHashSet.prototype.cljs$core$ITransientSet$_disjoin_BANG_$arity$2 = (function (tcoll,v){ +var self__ = this; +var tcoll__$1 = this; +self__.transient_map = cljs.core.dissoc_BANG_.cljs$core$IFn$_invoke$arity$2(self__.transient_map,v); + +return tcoll__$1; +}); + +cljs.core.TransientHashSet.prototype.cljs$core$ICounted$_count$arity$1 = (function (tcoll){ +var self__ = this; +var tcoll__$1 = this; +return cljs.core.count(self__.transient_map); +}); + +cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (tcoll,v){ +var self__ = this; +var tcoll__$1 = this; +return tcoll__$1.cljs$core$ILookup$_lookup$arity$3(null,v,null); +}); + +cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (tcoll,v,not_found){ +var self__ = this; +var tcoll__$1 = this; +if((cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(self__.transient_map,v,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)){ +return not_found; +} else { +return v; +} +}); + +cljs.core.TransientHashSet.prototype.call = (function() { +var G__2657 = null; +var G__2657__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var tcoll = self____$1; +if((cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(self__.transient_map,k,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)){ +return null; +} else { +return k; +} +}); +var G__2657__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var tcoll = self____$1; +if((cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(self__.transient_map,k,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)){ +return not_found; +} else { +return k; +} +}); +G__2657 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2657__2.call(this,self__,k); +case 3: +return G__2657__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2657.cljs$core$IFn$_invoke$arity$2 = G__2657__2; +G__2657.cljs$core$IFn$_invoke$arity$3 = G__2657__3; +return G__2657; +})() +; + +cljs.core.TransientHashSet.prototype.apply = (function (self__,args2656){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2656))); +}); + +cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var tcoll = this; +if((cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(self__.transient_map,k,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)){ +return null; +} else { +return k; +} +}); + +cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var tcoll = this; +if((cljs.core._lookup.cljs$core$IFn$_invoke$arity$3(self__.transient_map,k,cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)){ +return not_found; +} else { +return k; +} +}); + +cljs.core.TransientHashSet.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$transient_DASH_map,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.TransientHashSet.cljs$lang$type = true; + +cljs.core.TransientHashSet.cljs$lang$ctorStr = "cljs.core/TransientHashSet"; + +cljs.core.TransientHashSet.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/TransientHashSet"); +}); + +/** + * Positional factory function for cljs.core/TransientHashSet. + */ +cljs.core.__GT_TransientHashSet = (function cljs$core$__GT_TransientHashSet(transient_map){ +return (new cljs.core.TransientHashSet(transient_map)); +}); + + +/** +* @constructor + * @implements {cljs.core.IReversible} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.ISet} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISorted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.ILookup} +*/ +cljs.core.PersistentTreeSet = (function (meta,tree_map,__hash){ +this.meta = meta; +this.tree_map = tree_map; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 417730831; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}); +cljs.core.PersistentTreeSet.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.PersistentTreeSet.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.PersistentTreeSet.prototype.keys = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentTreeSet.prototype.entries = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_set_entries_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentTreeSet.prototype.values = (function (){ +var self__ = this; +var coll = this; +return cljs.core.es6_iterator(cljs.core.seq(coll)); +}); + +cljs.core.PersistentTreeSet.prototype.has = (function (k){ +var self__ = this; +var coll = this; +return cljs.core.contains_QMARK_(coll,k); +}); + +cljs.core.PersistentTreeSet.prototype.forEach = (function (f){ +var self__ = this; +var coll = this; +var seq__2661 = cljs.core.seq(coll); +var chunk__2662 = null; +var count__2663 = (0); +var i__2664 = (0); +while(true){ +if((i__2664 < count__2663)){ +var vec__2665 = chunk__2662.cljs$core$IIndexed$_nth$arity$2(null,i__2664); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2665,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2665,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2674 = seq__2661; +var G__2675 = chunk__2662; +var G__2676 = count__2663; +var G__2677 = (i__2664 + (1)); +seq__2661 = G__2674; +chunk__2662 = G__2675; +count__2663 = G__2676; +i__2664 = G__2677; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2661); +if(temp__5457__auto__){ +var seq__2661__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2661__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2661__$1); +var G__2678 = cljs.core.chunk_rest(seq__2661__$1); +var G__2679 = c__4338__auto__; +var G__2680 = cljs.core.count(c__4338__auto__); +var G__2681 = (0); +seq__2661 = G__2678; +chunk__2662 = G__2679; +count__2663 = G__2680; +i__2664 = G__2681; +continue; +} else { +var vec__2668 = cljs.core.first(seq__2661__$1); +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2668,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2668,(1),null); +(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(v,k) : f.call(null,v,k)); + + +var G__2682 = cljs.core.next(seq__2661__$1); +var G__2683 = null; +var G__2684 = (0); +var G__2685 = (0); +seq__2661 = G__2682; +chunk__2662 = G__2683; +count__2663 = G__2684; +i__2664 = G__2685; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (coll,v){ +var self__ = this; +var coll__$1 = this; +return coll__$1.cljs$core$ILookup$_lookup$arity$3(null,v,null); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (coll,v,not_found){ +var self__ = this; +var coll__$1 = this; +var n = self__.tree_map.entry_at(v); +if(!((n == null))){ +return n.key; +} else { +return not_found; +} +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IMeta$_meta$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return self__.meta; +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.PersistentTreeSet(self__.meta,self__.tree_map,self__.__hash)); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ICounted$_count$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.count(self__.tree_map); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IReversible$_rseq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +if((cljs.core.count(self__.tree_map) > (0))){ +return cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.key,cljs.core.rseq(self__.tree_map)); +} else { +return null; +} +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IHash$_hash$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_unordered_coll(coll__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (coll,other){ +var self__ = this; +var coll__$1 = this; +var and__3925__auto__ = cljs.core.set_QMARK_(other); +if(and__3925__auto__){ +var and__3925__auto____$1 = (cljs.core.count(coll__$1) === cljs.core.count(other)); +if(and__3925__auto____$1){ +try{return cljs.core.reduce_kv(((function (and__3925__auto____$1,and__3925__auto__,coll__$1){ +return (function (p1__2659_SHARP_,p2__2658_SHARP_){ +var or__3936__auto__ = cljs.core.contains_QMARK_(other,p2__2658_SHARP_); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return cljs.core.reduced(false); +} +});})(and__3925__auto____$1,and__3925__auto__,coll__$1)) +,true,self__.tree_map); +}catch (e2673){if((e2673 instanceof Error)){ +var ex = e2673; +return false; +} else { +throw e2673; + +} +}} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeSet(self__.meta,cljs.core._empty(self__.tree_map),(0))); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ISet$_disjoin$arity$2 = (function (coll,v){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeSet(self__.meta,cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.tree_map,v),null)); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core.keys(self__.tree_map); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (coll,meta__$1){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeSet(meta__$1,self__.tree_map,self__.__hash)); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ICollection$_conj$arity$2 = (function (coll,o){ +var self__ = this; +var coll__$1 = this; +return (new cljs.core.PersistentTreeSet(self__.meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.tree_map,o,null),null)); +}); + +cljs.core.PersistentTreeSet.prototype.call = (function() { +var G__2686 = null; +var G__2686__2 = (function (self__,k){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); +var G__2686__3 = (function (self__,k,not_found){ +var self__ = this; +var self____$1 = this; +var coll = self____$1; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); +G__2686 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__2686__2.call(this,self__,k); +case 3: +return G__2686__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__2686.cljs$core$IFn$_invoke$arity$2 = G__2686__2; +G__2686.cljs$core$IFn$_invoke$arity$3 = G__2686__3; +return G__2686; +})() +; + +cljs.core.PersistentTreeSet.prototype.apply = (function (self__,args2660){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args2660))); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$1 = (function (k){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$2(null,k); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$2 = (function (k,not_found){ +var self__ = this; +var coll = this; +return coll.cljs$core$ILookup$_lookup$arity$3(null,k,not_found); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_sorted_seq$arity$2 = (function (coll,ascending_QMARK_){ +var self__ = this; +var coll__$1 = this; +return cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.key,cljs.core._sorted_seq(self__.tree_map,ascending_QMARK_)); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_sorted_seq_from$arity$3 = (function (coll,k,ascending_QMARK_){ +var self__ = this; +var coll__$1 = this; +return cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.key,cljs.core._sorted_seq_from(self__.tree_map,k,ascending_QMARK_)); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_entry_key$arity$2 = (function (coll,entry){ +var self__ = this; +var coll__$1 = this; +return entry; +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_comparator$arity$1 = (function (coll){ +var self__ = this; +var coll__$1 = this; +return cljs.core._comparator(self__.tree_map); +}); + +cljs.core.PersistentTreeSet.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$tree_DASH_map,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.PersistentTreeSet.cljs$lang$type = true; + +cljs.core.PersistentTreeSet.cljs$lang$ctorStr = "cljs.core/PersistentTreeSet"; + +cljs.core.PersistentTreeSet.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/PersistentTreeSet"); +}); + +/** + * Positional factory function for cljs.core/PersistentTreeSet. + */ +cljs.core.__GT_PersistentTreeSet = (function cljs$core$__GT_PersistentTreeSet(meta,tree_map,__hash){ +return (new cljs.core.PersistentTreeSet(meta,tree_map,__hash)); +}); + +cljs.core.PersistentTreeSet.EMPTY = (new cljs.core.PersistentTreeSet(null,cljs.core.PersistentTreeMap.EMPTY,cljs.core.empty_unordered_hash)); +var G__2687_2690 = cljs.core.PersistentTreeSet.prototype; +var G__2688_2691 = cljs.core.ITER_SYMBOL; +var G__2689_2692 = ((function (G__2687_2690,G__2688_2691){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2687_2690,G__2688_2691)) +; +goog.object.set(G__2687_2690,G__2688_2691,G__2689_2692); +cljs.core.set_from_indexed_seq = (function cljs$core$set_from_indexed_seq(iseq){ +var arr = iseq.arr; +var ret = (function (){var a__4392__auto__ = arr; +var l__4393__auto__ = a__4392__auto__.length; +var i = (0); +var res = cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY); +while(true){ +if((i < l__4393__auto__)){ +var G__2693 = (i + (1)); +var G__2694 = res.cljs$core$ITransientCollection$_conj_BANG_$arity$2(null,(arr[i])); +i = G__2693; +res = G__2694; +continue; +} else { +return res; +} +break; +} +})(); +return ret.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(null); +}); +/** + * Returns a set of the distinct elements of coll. + */ +cljs.core.set = (function cljs$core$set(coll){ +var in$ = cljs.core.seq(coll); +if((in$ == null)){ +return cljs.core.PersistentHashSet.EMPTY; +} else { +if((((in$ instanceof cljs.core.IndexedSeq)) && ((in$.i === (0))))){ +return cljs.core.PersistentHashSet.createAsIfByAssoc(in$.arr); +} else { +var in$__$1 = in$; +var out = cljs.core._as_transient(cljs.core.PersistentHashSet.EMPTY); +while(true){ +if(!((in$__$1 == null))){ +var G__2695 = cljs.core.next(in$__$1); +var G__2696 = out.cljs$core$ITransientCollection$_conj_BANG_$arity$2(null,in$__$1.cljs$core$ISeq$_first$arity$1(null)); +in$__$1 = G__2695; +out = G__2696; +continue; +} else { +return cljs.core.persistent_BANG_(out); +} +break; +} + +} +} +}); +/** + * Returns a new hash set with supplied keys. Any equal keys are + * handled as if by repeated uses of conj. + */ +cljs.core.hash_set = (function cljs$core$hash_set(var_args){ +var G__2699 = arguments.length; +switch (G__2699) { +case 0: +return cljs.core.hash_set.cljs$core$IFn$_invoke$arity$0(); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___2701 = arguments.length; +var i__4519__auto___2702 = (0); +while(true){ +if((i__4519__auto___2702 < len__4518__auto___2701)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___2702])); + +var G__2703 = (i__4519__auto___2702 + (1)); +i__4519__auto___2702 = G__2703; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((0)),(0),null)); +return cljs.core.hash_set.cljs$core$IFn$_invoke$arity$variadic(argseq__4534__auto__); + +} +}); + +cljs.core.hash_set.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.PersistentHashSet.EMPTY; +}); + +cljs.core.hash_set.cljs$core$IFn$_invoke$arity$variadic = (function (keys){ +return cljs.core.set(keys); +}); + +/** @this {Function} */ +cljs.core.hash_set.cljs$lang$applyTo = (function (seq2698){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2698)); +}); + +cljs.core.hash_set.cljs$lang$maxFixedArity = (0); + +/** + * Returns a new sorted set with supplied keys. + */ +cljs.core.sorted_set = (function cljs$core$sorted_set(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2705 = arguments.length; +var i__4519__auto___2706 = (0); +while(true){ +if((i__4519__auto___2706 < len__4518__auto___2705)){ +args__4521__auto__.push((arguments[i__4519__auto___2706])); + +var G__2707 = (i__4519__auto___2706 + (1)); +i__4519__auto___2706 = G__2707; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.sorted_set.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.sorted_set.cljs$core$IFn$_invoke$arity$variadic = (function (keys){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,cljs.core.PersistentTreeSet.EMPTY,keys); +}); + +cljs.core.sorted_set.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.sorted_set.cljs$lang$applyTo = (function (seq2704){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2704)); +}); + +/** + * Returns a new sorted set with supplied keys, using the supplied comparator. + */ +cljs.core.sorted_set_by = (function cljs$core$sorted_set_by(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2710 = arguments.length; +var i__4519__auto___2711 = (0); +while(true){ +if((i__4519__auto___2711 < len__4518__auto___2710)){ +args__4521__auto__.push((arguments[i__4519__auto___2711])); + +var G__2712 = (i__4519__auto___2711 + (1)); +i__4519__auto___2711 = G__2712; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.core.sorted_set_by.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.core.sorted_set_by.cljs$core$IFn$_invoke$arity$variadic = (function (comparator,keys){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,(new cljs.core.PersistentTreeSet(null,cljs.core.sorted_map_by(comparator),(0))),keys); +}); + +cljs.core.sorted_set_by.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.core.sorted_set_by.cljs$lang$applyTo = (function (seq2708){ +var G__2709 = cljs.core.first(seq2708); +var seq2708__$1 = cljs.core.next(seq2708); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2709,seq2708__$1); +}); + +/** + * Given a map of replacement pairs and a vector/collection, returns a + * vector/seq with any elements = a key in smap replaced with the + * corresponding val in smap. Returns a transducer when no collection + * is provided. + */ +cljs.core.replace = (function cljs$core$replace(var_args){ +var G__2716 = arguments.length; +switch (G__2716) { +case 1: +return cljs.core.replace.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.replace.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.replace.cljs$core$IFn$_invoke$arity$1 = (function (smap){ +return cljs.core.map.cljs$core$IFn$_invoke$arity$1((function (p1__2713_SHARP_){ +var temp__5455__auto__ = cljs.core.find(smap,p1__2713_SHARP_); +if(cljs.core.truth_(temp__5455__auto__)){ +var e = temp__5455__auto__; +return cljs.core.val(e); +} else { +return p1__2713_SHARP_; +} +})); +}); + +cljs.core.replace.cljs$core$IFn$_invoke$arity$2 = (function (smap,coll){ +if(cljs.core.vector_QMARK_(coll)){ +var n = cljs.core.count(coll); +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (n){ +return (function (v,i){ +var temp__5455__auto__ = cljs.core.find(smap,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(v,i)); +if(cljs.core.truth_(temp__5455__auto__)){ +var e = temp__5455__auto__; +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(v,i,cljs.core.second(e)); +} else { +return v; +} +});})(n)) +,coll,cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,cljs.core.iterate(cljs.core.inc,(0)))); +} else { +return cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__2714_SHARP_){ +var temp__5455__auto__ = cljs.core.find(smap,p1__2714_SHARP_); +if(cljs.core.truth_(temp__5455__auto__)){ +var e = temp__5455__auto__; +return cljs.core.second(e); +} else { +return p1__2714_SHARP_; +} +}),coll); +} +}); + +cljs.core.replace.cljs$lang$maxFixedArity = 2; + +/** + * Returns a lazy sequence of the elements of coll with duplicates removed. + * Returns a stateful transducer when no collection is provided. + */ +cljs.core.distinct = (function cljs$core$distinct(var_args){ +var G__2719 = arguments.length; +switch (G__2719) { +case 0: +return cljs.core.distinct.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.distinct.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.distinct.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (function (rf){ +var seen = cljs.core.volatile_BANG_(cljs.core.PersistentHashSet.EMPTY); +return ((function (seen){ +return (function() { +var G__2730 = null; +var G__2730__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__2730__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__2730__2 = (function (result,input){ +if(cljs.core.contains_QMARK_(cljs.core.deref(seen),input)){ +return result; +} else { +cljs.core._vreset_BANG_(seen,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core._deref(seen),input)); + +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} +}); +G__2730 = function(result,input){ +switch(arguments.length){ +case 0: +return G__2730__0.call(this); +case 1: +return G__2730__1.call(this,result); +case 2: +return G__2730__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2730.cljs$core$IFn$_invoke$arity$0 = G__2730__0; +G__2730.cljs$core$IFn$_invoke$arity$1 = G__2730__1; +G__2730.cljs$core$IFn$_invoke$arity$2 = G__2730__2; +return G__2730; +})() +;})(seen)) +}); +}); + +cljs.core.distinct.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +var step = (function cljs$core$step(xs,seen){ +return (new cljs.core.LazySeq(null,(function (){ +var fexpr__2724 = (function (p__2725,seen__$1){ +while(true){ +var vec__2726 = p__2725; +var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2726,(0),null); +var xs__$1 = vec__2726; +var temp__5457__auto__ = cljs.core.seq(xs__$1); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.contains_QMARK_(seen__$1,f)){ +var G__2731 = cljs.core.rest(s); +var G__2732 = seen__$1; +p__2725 = G__2731; +seen__$1 = G__2732; +continue; +} else { +return cljs.core.cons(f,cljs$core$step(cljs.core.rest(s),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(seen__$1,f))); +} +} else { +return null; +} +break; +} +}); +return fexpr__2724(xs,seen); +}),null,null)); +}); +return step(coll,cljs.core.PersistentHashSet.EMPTY); +}); + +cljs.core.distinct.cljs$lang$maxFixedArity = 1; + +/** + * Return a seq of all but the last item in coll, in linear time + */ +cljs.core.butlast = (function cljs$core$butlast(s){ +var ret = cljs.core.PersistentVector.EMPTY; +var s__$1 = s; +while(true){ +if(cljs.core.next(s__$1)){ +var G__2733 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ret,cljs.core.first(s__$1)); +var G__2734 = cljs.core.next(s__$1); +ret = G__2733; +s__$1 = G__2734; +continue; +} else { +return cljs.core.seq(ret); +} +break; +} +}); +/** + * Returns the name String of a string, symbol or keyword. + */ +cljs.core.name = (function cljs$core$name(x){ +if(((!((x == null)))?(((((x.cljs$lang$protocol_mask$partition1$ & (4096))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$INamed$))))?true:false):false)){ +return x.cljs$core$INamed$_name$arity$1(null); +} else { +if(typeof x === 'string'){ +return x; +} else { +throw (new Error(["Doesn't support name: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join(''))); +} +} +}); +/** + * Returns a map with the keys mapped to the corresponding vals. + */ +cljs.core.zipmap = (function cljs$core$zipmap(keys,vals){ +var map = cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY); +var ks = cljs.core.seq(keys); +var vs = cljs.core.seq(vals); +while(true){ +if(((ks) && (vs))){ +var G__2736 = cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(map,cljs.core.first(ks),cljs.core.first(vs)); +var G__2737 = cljs.core.next(ks); +var G__2738 = cljs.core.next(vs); +map = G__2736; +ks = G__2737; +vs = G__2738; +continue; +} else { +return cljs.core.persistent_BANG_(map); +} +break; +} +}); +/** + * Returns the x for which (k x), a number, is greatest. + * + * If there are multiple such xs, the last one is returned. + */ +cljs.core.max_key = (function cljs$core$max_key(var_args){ +var G__2746 = arguments.length; +switch (G__2746) { +case 2: +return cljs.core.max_key.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.max_key.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___2748 = arguments.length; +var i__4519__auto___2749 = (0); +while(true){ +if((i__4519__auto___2749 < len__4518__auto___2748)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___2749])); + +var G__2750 = (i__4519__auto___2749 + (1)); +i__4519__auto___2749 = G__2750; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.max_key.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.max_key.cljs$core$IFn$_invoke$arity$2 = (function (k,x){ +return x; +}); + +cljs.core.max_key.cljs$core$IFn$_invoke$arity$3 = (function (k,x,y){ +if(((k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(x) : k.call(null,x)) > (k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(y) : k.call(null,y)))){ +return x; +} else { +return y; +} +}); + +cljs.core.max_key.cljs$core$IFn$_invoke$arity$variadic = (function (k,x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__2739_SHARP_,p2__2740_SHARP_){ +return cljs.core.max_key.cljs$core$IFn$_invoke$arity$3(k,p1__2739_SHARP_,p2__2740_SHARP_); +}),cljs.core.max_key.cljs$core$IFn$_invoke$arity$3(k,x,y),more); +}); + +/** @this {Function} */ +cljs.core.max_key.cljs$lang$applyTo = (function (seq2742){ +var G__2743 = cljs.core.first(seq2742); +var seq2742__$1 = cljs.core.next(seq2742); +var G__2744 = cljs.core.first(seq2742__$1); +var seq2742__$2 = cljs.core.next(seq2742__$1); +var G__2745 = cljs.core.first(seq2742__$2); +var seq2742__$3 = cljs.core.next(seq2742__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2743,G__2744,G__2745,seq2742__$3); +}); + +cljs.core.max_key.cljs$lang$maxFixedArity = (3); + +/** + * Returns the x for which (k x), a number, is least. + * + * If there are multiple such xs, the last one is returned. + */ +cljs.core.min_key = (function cljs$core$min_key(var_args){ +var G__2758 = arguments.length; +switch (G__2758) { +case 2: +return cljs.core.min_key.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.min_key.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___2760 = arguments.length; +var i__4519__auto___2761 = (0); +while(true){ +if((i__4519__auto___2761 < len__4518__auto___2760)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___2761])); + +var G__2762 = (i__4519__auto___2761 + (1)); +i__4519__auto___2761 = G__2762; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.min_key.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.min_key.cljs$core$IFn$_invoke$arity$2 = (function (k,x){ +return x; +}); + +cljs.core.min_key.cljs$core$IFn$_invoke$arity$3 = (function (k,x,y){ +if(((k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(x) : k.call(null,x)) < (k.cljs$core$IFn$_invoke$arity$1 ? k.cljs$core$IFn$_invoke$arity$1(y) : k.call(null,y)))){ +return x; +} else { +return y; +} +}); + +cljs.core.min_key.cljs$core$IFn$_invoke$arity$variadic = (function (k,x,y,more){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__2751_SHARP_,p2__2752_SHARP_){ +return cljs.core.min_key.cljs$core$IFn$_invoke$arity$3(k,p1__2751_SHARP_,p2__2752_SHARP_); +}),cljs.core.min_key.cljs$core$IFn$_invoke$arity$3(k,x,y),more); +}); + +/** @this {Function} */ +cljs.core.min_key.cljs$lang$applyTo = (function (seq2754){ +var G__2755 = cljs.core.first(seq2754); +var seq2754__$1 = cljs.core.next(seq2754); +var G__2756 = cljs.core.first(seq2754__$1); +var seq2754__$2 = cljs.core.next(seq2754__$1); +var G__2757 = cljs.core.first(seq2754__$2); +var seq2754__$3 = cljs.core.next(seq2754__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2755,G__2756,G__2757,seq2754__$3); +}); + +cljs.core.min_key.cljs$lang$maxFixedArity = (3); + + +/** +* @constructor +*/ +cljs.core.ArrayList = (function (arr){ +this.arr = arr; +}); +cljs.core.ArrayList.prototype.add = (function (x){ +var self__ = this; +var _ = this; +return self__.arr.push(x); +}); + +cljs.core.ArrayList.prototype.size = (function (){ +var self__ = this; +var _ = this; +return self__.arr.length; +}); + +cljs.core.ArrayList.prototype.clear = (function (){ +var self__ = this; +var _ = this; +return self__.arr = []; +}); + +cljs.core.ArrayList.prototype.isEmpty = (function (){ +var self__ = this; +var _ = this; +return (self__.arr.length === (0)); +}); + +cljs.core.ArrayList.prototype.toArray = (function (){ +var self__ = this; +var _ = this; +return self__.arr; +}); + +cljs.core.ArrayList.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$arr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.ArrayList.cljs$lang$type = true; + +cljs.core.ArrayList.cljs$lang$ctorStr = "cljs.core/ArrayList"; + +cljs.core.ArrayList.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/ArrayList"); +}); + +/** + * Positional factory function for cljs.core/ArrayList. + */ +cljs.core.__GT_ArrayList = (function cljs$core$__GT_ArrayList(arr){ +return (new cljs.core.ArrayList(arr)); +}); + +cljs.core.array_list = (function cljs$core$array_list(){ +return (new cljs.core.ArrayList([])); +}); +/** + * Returns a lazy sequence of lists like partition, but may include + * partitions with fewer than n items at the end. Returns a stateful + * transducer when no collection is provided. + */ +cljs.core.partition_all = (function cljs$core$partition_all(var_args){ +var G__2764 = arguments.length; +switch (G__2764) { +case 1: +return cljs.core.partition_all.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.partition_all.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.partition_all.cljs$core$IFn$_invoke$arity$1 = (function (n){ +return (function (rf){ +var a = cljs.core.array_list(); +return ((function (a){ +return (function() { +var G__2766 = null; +var G__2766__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__2766__1 = (function (result){ +var result__$1 = (cljs.core.truth_(a.isEmpty())?result:(function (){var v = cljs.core.vec(a.toArray()); +a.clear(); + +return cljs.core.unreduced((rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null,result,v))); +})()); +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result__$1) : rf.call(null,result__$1)); +}); +var G__2766__2 = (function (result,input){ +a.add(input); + +if((n === a.size())){ +var v = cljs.core.vec(a.toArray()); +a.clear(); + +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null,result,v)); +} else { +return result; +} +}); +G__2766 = function(result,input){ +switch(arguments.length){ +case 0: +return G__2766__0.call(this); +case 1: +return G__2766__1.call(this,result); +case 2: +return G__2766__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2766.cljs$core$IFn$_invoke$arity$0 = G__2766__0; +G__2766.cljs$core$IFn$_invoke$arity$1 = G__2766__1; +G__2766.cljs$core$IFn$_invoke$arity$2 = G__2766__2; +return G__2766; +})() +;})(a)) +}); +}); + +cljs.core.partition_all.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +return cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3(n,n,coll); +}); + +cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3 = (function (n,step,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +return cljs.core.cons(cljs.core.take.cljs$core$IFn$_invoke$arity$2(n,s),cljs.core.partition_all.cljs$core$IFn$_invoke$arity$3(n,step,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(step,s))); +} else { +return null; +} +}),null,null)); +}); + +cljs.core.partition_all.cljs$lang$maxFixedArity = 3; + +/** + * Returns a lazy sequence of successive items from coll while + * (pred item) returns logical true. pred must be free of side-effects. + * Returns a transducer when no collection is provided. + */ +cljs.core.take_while = (function cljs$core$take_while(var_args){ +var G__2768 = arguments.length; +switch (G__2768) { +case 1: +return cljs.core.take_while.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.take_while.cljs$core$IFn$_invoke$arity$1 = (function (pred){ +return (function (rf){ +return (function() { +var G__2771 = null; +var G__2771__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__2771__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__2771__2 = (function (result,input){ +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null,input)))){ +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} else { +return cljs.core.reduced(result); +} +}); +G__2771 = function(result,input){ +switch(arguments.length){ +case 0: +return G__2771__0.call(this); +case 1: +return G__2771__1.call(this,result); +case 2: +return G__2771__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2771.cljs$core$IFn$_invoke$arity$0 = G__2771__0; +G__2771.cljs$core$IFn$_invoke$arity$1 = G__2771__1; +G__2771.cljs$core$IFn$_invoke$arity$2 = G__2771__2; +return G__2771; +})() +}); +}); + +cljs.core.take_while.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +if(cljs.core.truth_((function (){var G__2769 = cljs.core.first(s); +return (pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(G__2769) : pred.call(null,G__2769)); +})())){ +return cljs.core.cons(cljs.core.first(s),cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(pred,cljs.core.rest(s))); +} else { +return null; +} +} else { +return null; +} +}),null,null)); +}); + +cljs.core.take_while.cljs$lang$maxFixedArity = 2; + +cljs.core.mk_bound_fn = (function cljs$core$mk_bound_fn(sc,test,key){ +return (function (e){ +var comp = cljs.core._comparator(sc); +var G__2772 = (function (){var G__2774 = cljs.core._entry_key(sc,e); +var G__2775 = key; +return (comp.cljs$core$IFn$_invoke$arity$2 ? comp.cljs$core$IFn$_invoke$arity$2(G__2774,G__2775) : comp.call(null,G__2774,G__2775)); +})(); +var G__2773 = (0); +return (test.cljs$core$IFn$_invoke$arity$2 ? test.cljs$core$IFn$_invoke$arity$2(G__2772,G__2773) : test.call(null,G__2772,G__2773)); +}); +}); +/** + * sc must be a sorted collection, test(s) one of <, <=, > or + * >=. Returns a seq of those entries with keys ek for + * which (test (.. sc comparator (compare ek key)) 0) is true + */ +cljs.core.subseq = (function cljs$core$subseq(var_args){ +var G__2777 = arguments.length; +switch (G__2777) { +case 3: +return cljs.core.subseq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 5: +return cljs.core.subseq.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.subseq.cljs$core$IFn$_invoke$arity$3 = (function (sc,test,key){ +var include = cljs.core.mk_bound_fn(sc,test,key); +if(cljs.core.truth_((function (){var fexpr__2778 = cljs.core.PersistentHashSet.createAsIfByAssoc([cljs.core._GT_,cljs.core._GT__EQ_]); +return (fexpr__2778.cljs$core$IFn$_invoke$arity$1 ? fexpr__2778.cljs$core$IFn$_invoke$arity$1(test) : fexpr__2778.call(null,test)); +})())){ +var temp__5457__auto__ = cljs.core._sorted_seq_from(sc,key,true); +if(cljs.core.truth_(temp__5457__auto__)){ +var vec__2779 = temp__5457__auto__; +var e = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2779,(0),null); +var s = vec__2779; +if(cljs.core.truth_((include.cljs$core$IFn$_invoke$arity$1 ? include.cljs$core$IFn$_invoke$arity$1(e) : include.call(null,e)))){ +return s; +} else { +return cljs.core.next(s); +} +} else { +return null; +} +} else { +return cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(include,cljs.core._sorted_seq(sc,true)); +} +}); + +cljs.core.subseq.cljs$core$IFn$_invoke$arity$5 = (function (sc,start_test,start_key,end_test,end_key){ +var temp__5457__auto__ = cljs.core._sorted_seq_from(sc,start_key,true); +if(cljs.core.truth_(temp__5457__auto__)){ +var vec__2782 = temp__5457__auto__; +var e = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2782,(0),null); +var s = vec__2782; +return cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(cljs.core.mk_bound_fn(sc,end_test,end_key),(cljs.core.truth_((function (){var fexpr__2785 = cljs.core.mk_bound_fn(sc,start_test,start_key); +return (fexpr__2785.cljs$core$IFn$_invoke$arity$1 ? fexpr__2785.cljs$core$IFn$_invoke$arity$1(e) : fexpr__2785.call(null,e)); +})())?s:cljs.core.next(s))); +} else { +return null; +} +}); + +cljs.core.subseq.cljs$lang$maxFixedArity = 5; + +/** + * sc must be a sorted collection, test(s) one of <, <=, > or + * >=. Returns a reverse seq of those entries with keys ek for + * which (test (.. sc comparator (compare ek key)) 0) is true + */ +cljs.core.rsubseq = (function cljs$core$rsubseq(var_args){ +var G__2788 = arguments.length; +switch (G__2788) { +case 3: +return cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +case 5: +return cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$3 = (function (sc,test,key){ +var include = cljs.core.mk_bound_fn(sc,test,key); +if(cljs.core.truth_((function (){var fexpr__2789 = cljs.core.PersistentHashSet.createAsIfByAssoc([cljs.core._LT_,cljs.core._LT__EQ_]); +return (fexpr__2789.cljs$core$IFn$_invoke$arity$1 ? fexpr__2789.cljs$core$IFn$_invoke$arity$1(test) : fexpr__2789.call(null,test)); +})())){ +var temp__5457__auto__ = cljs.core._sorted_seq_from(sc,key,false); +if(cljs.core.truth_(temp__5457__auto__)){ +var vec__2790 = temp__5457__auto__; +var e = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2790,(0),null); +var s = vec__2790; +if(cljs.core.truth_((include.cljs$core$IFn$_invoke$arity$1 ? include.cljs$core$IFn$_invoke$arity$1(e) : include.call(null,e)))){ +return s; +} else { +return cljs.core.next(s); +} +} else { +return null; +} +} else { +return cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(include,cljs.core._sorted_seq(sc,false)); +} +}); + +cljs.core.rsubseq.cljs$core$IFn$_invoke$arity$5 = (function (sc,start_test,start_key,end_test,end_key){ +var temp__5457__auto__ = cljs.core._sorted_seq_from(sc,end_key,false); +if(cljs.core.truth_(temp__5457__auto__)){ +var vec__2793 = temp__5457__auto__; +var e = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2793,(0),null); +var s = vec__2793; +return cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(cljs.core.mk_bound_fn(sc,start_test,start_key),(cljs.core.truth_((function (){var fexpr__2796 = cljs.core.mk_bound_fn(sc,end_test,end_key); +return (fexpr__2796.cljs$core$IFn$_invoke$arity$1 ? fexpr__2796.cljs$core$IFn$_invoke$arity$1(e) : fexpr__2796.call(null,e)); +})())?s:cljs.core.next(s))); +} else { +return null; +} +}); + +cljs.core.rsubseq.cljs$lang$maxFixedArity = 5; + + +/** +* @constructor +*/ +cljs.core.RangeIterator = (function (i,end,step){ +this.i = i; +this.end = end; +this.step = step; +}); +cljs.core.RangeIterator.prototype.hasNext = (function (){ +var self__ = this; +var _ = this; +if((self__.step > (0))){ +return (self__.i < self__.end); +} else { +return (self__.i > self__.end); +} +}); + +cljs.core.RangeIterator.prototype.next = (function (){ +var self__ = this; +var _ = this; +var ret = self__.i; +self__.i = (self__.i + self__.step); + +return ret; +}); + +cljs.core.RangeIterator.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$i,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$end,cljs.core.cst$sym$step], null); +}); + +cljs.core.RangeIterator.cljs$lang$type = true; + +cljs.core.RangeIterator.cljs$lang$ctorStr = "cljs.core/RangeIterator"; + +cljs.core.RangeIterator.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/RangeIterator"); +}); + +/** + * Positional factory function for cljs.core/RangeIterator. + */ +cljs.core.__GT_RangeIterator = (function cljs$core$__GT_RangeIterator(i,end,step){ +return (new cljs.core.RangeIterator(i,end,step)); +}); + + +/** +* @constructor + * @implements {cljs.core.IIndexed} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.IEmptyableCollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeq} + * @implements {cljs.core.INext} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Range = (function (meta,start,end,step,__hash){ +this.meta = meta; +this.start = start; +this.end = end; +this.step = step; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 32375006; +this.cljs$lang$protocol_mask$partition1$ = 139264; +}); +cljs.core.Range.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.Range.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.Range.prototype.indexOf = (function() { +var G__2799 = null; +var G__2799__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,(0)); +}); +var G__2799__2 = (function (x,start__$1){ +var self__ = this; +var coll = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1); +}); +G__2799 = function(x,start__$1){ +switch(arguments.length){ +case 1: +return G__2799__1.call(this,x); +case 2: +return G__2799__2.call(this,x,start__$1); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2799.cljs$core$IFn$_invoke$arity$1 = G__2799__1; +G__2799.cljs$core$IFn$_invoke$arity$2 = G__2799__2; +return G__2799; +})() +; + +cljs.core.Range.prototype.lastIndexOf = (function() { +var G__2800 = null; +var G__2800__1 = (function (x){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,cljs.core.count(coll)); +}); +var G__2800__2 = (function (x,start__$1){ +var self__ = this; +var coll = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll,x,start__$1); +}); +G__2800 = function(x,start__$1){ +switch(arguments.length){ +case 1: +return G__2800__1.call(this,x); +case 2: +return G__2800__2.call(this,x,start__$1); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2800.cljs$core$IFn$_invoke$arity$1 = G__2800__1; +G__2800.cljs$core$IFn$_invoke$arity$2 = G__2800__2; +return G__2800; +})() +; + +cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$2 = (function (rng,n){ +var self__ = this; +var rng__$1 = this; +if(((((0) <= n)) && ((n < rng__$1.cljs$core$ICounted$_count$arity$1(null))))){ +return (self__.start + (n * self__.step)); +} else { +if(((((0) <= n)) && ((self__.start > self__.end)) && ((self__.step === (0))))){ +return self__.start; +} else { +throw (new Error("Index out of bounds")); +} +} +}); + +cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$3 = (function (rng,n,not_found){ +var self__ = this; +var rng__$1 = this; +if(((((0) <= n)) && ((n < rng__$1.cljs$core$ICounted$_count$arity$1(null))))){ +return (self__.start + (n * self__.step)); +} else { +if(((((0) <= n)) && ((self__.start > self__.end)) && ((self__.step === (0))))){ +return self__.start; +} else { +return not_found; +} +} +}); + +cljs.core.Range.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.RangeIterator(self__.start,self__.end,self__.step)); +}); + +cljs.core.Range.prototype.cljs$core$IMeta$_meta$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +return self__.meta; +}); + +cljs.core.Range.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return (new cljs.core.Range(self__.meta,self__.start,self__.end,self__.step,self__.__hash)); +}); + +cljs.core.Range.prototype.cljs$core$INext$_next$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +if((self__.step > (0))){ +if(((self__.start + self__.step) < self__.end)){ +return (new cljs.core.Range(self__.meta,(self__.start + self__.step),self__.end,self__.step,null)); +} else { +return null; +} +} else { +if(((self__.start + self__.step) > self__.end)){ +return (new cljs.core.Range(self__.meta,(self__.start + self__.step),self__.end,self__.step,null)); +} else { +return null; +} +} +}); + +cljs.core.Range.prototype.cljs$core$ICounted$_count$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +if(cljs.core.not(rng__$1.cljs$core$ISeqable$_seq$arity$1(null))){ +return (0); +} else { +var G__2798 = ((self__.end - self__.start) / self__.step); +return Math.ceil(G__2798); +} +}); + +cljs.core.Range.prototype.cljs$core$IHash$_hash$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = cljs.core.hash_ordered_coll(rng__$1); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.core.Range.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (rng,other){ +var self__ = this; +var rng__$1 = this; +return cljs.core.equiv_sequential(rng__$1,other); +}); + +cljs.core.Range.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +return cljs.core._with_meta(cljs.core.List.EMPTY,self__.meta); +}); + +cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (rng,f){ +var self__ = this; +var rng__$1 = this; +return cljs.core.ci_reduce.cljs$core$IFn$_invoke$arity$2(rng__$1,f); +}); + +cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (rng,f,init){ +var self__ = this; +var rng__$1 = this; +var i = self__.start; +var ret = init; +while(true){ +if((((self__.step > (0)))?(i < self__.end):(i > self__.end))){ +var ret__$1 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(ret,i) : f.call(null,ret,i)); +if(cljs.core.reduced_QMARK_(ret__$1)){ +return cljs.core.deref(ret__$1); +} else { +var G__2801 = (i + self__.step); +var G__2802 = ret__$1; +i = G__2801; +ret = G__2802; +continue; +} +} else { +return ret; +} +break; +} +}); + +cljs.core.Range.prototype.cljs$core$ISeq$_first$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +if((rng__$1.cljs$core$ISeqable$_seq$arity$1(null) == null)){ +return null; +} else { +return self__.start; +} +}); + +cljs.core.Range.prototype.cljs$core$ISeq$_rest$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +if(!((rng__$1.cljs$core$ISeqable$_seq$arity$1(null) == null))){ +return (new cljs.core.Range(self__.meta,(self__.start + self__.step),self__.end,self__.step,null)); +} else { +return cljs.core.List.EMPTY; +} +}); + +cljs.core.Range.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (rng){ +var self__ = this; +var rng__$1 = this; +if((self__.step > (0))){ +if((self__.start < self__.end)){ +return rng__$1; +} else { +return null; +} +} else { +if((self__.step < (0))){ +if((self__.start > self__.end)){ +return rng__$1; +} else { +return null; +} +} else { +if((self__.start === self__.end)){ +return null; +} else { +return rng__$1; +} + +} +} +}); + +cljs.core.Range.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (rng,meta__$1){ +var self__ = this; +var rng__$1 = this; +return (new cljs.core.Range(meta__$1,self__.start,self__.end,self__.step,self__.__hash)); +}); + +cljs.core.Range.prototype.cljs$core$ICollection$_conj$arity$2 = (function (rng,o){ +var self__ = this; +var rng__$1 = this; +return cljs.core.cons(o,rng__$1); +}); + +cljs.core.Range.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$meta,cljs.core.cst$sym$start,cljs.core.cst$sym$end,cljs.core.cst$sym$step,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Range.cljs$lang$type = true; + +cljs.core.Range.cljs$lang$ctorStr = "cljs.core/Range"; + +cljs.core.Range.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Range"); +}); + +/** + * Positional factory function for cljs.core/Range. + */ +cljs.core.__GT_Range = (function cljs$core$__GT_Range(meta,start,end,step,__hash){ +return (new cljs.core.Range(meta,start,end,step,__hash)); +}); + +var G__2803_2806 = cljs.core.Range.prototype; +var G__2804_2807 = cljs.core.ITER_SYMBOL; +var G__2805_2808 = ((function (G__2803_2806,G__2804_2807){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__2803_2806,G__2804_2807)) +; +goog.object.set(G__2803_2806,G__2804_2807,G__2805_2808); +/** + * Returns a lazy seq of nums from start (inclusive) to end + * (exclusive), by step, where start defaults to 0, step to 1, + * and end to infinity. + */ +cljs.core.range = (function cljs$core$range(var_args){ +var G__2810 = arguments.length; +switch (G__2810) { +case 0: +return cljs.core.range.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.range.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.range.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.range.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.range.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.range.cljs$core$IFn$_invoke$arity$3((0),Number.MAX_VALUE,(1)); +}); + +cljs.core.range.cljs$core$IFn$_invoke$arity$1 = (function (end){ +return cljs.core.range.cljs$core$IFn$_invoke$arity$3((0),end,(1)); +}); + +cljs.core.range.cljs$core$IFn$_invoke$arity$2 = (function (start,end){ +return cljs.core.range.cljs$core$IFn$_invoke$arity$3(start,end,(1)); +}); + +cljs.core.range.cljs$core$IFn$_invoke$arity$3 = (function (start,end,step){ +return (new cljs.core.Range(null,start,end,step,null)); +}); + +cljs.core.range.cljs$lang$maxFixedArity = 3; + +/** + * Returns a lazy seq of every nth item in coll. Returns a stateful + * transducer when no collection is provided. + */ +cljs.core.take_nth = (function cljs$core$take_nth(var_args){ +var G__2813 = arguments.length; +switch (G__2813) { +case 1: +return cljs.core.take_nth.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.take_nth.cljs$core$IFn$_invoke$arity$1 = (function (n){ +if(typeof n === 'number'){ +} else { +throw (new Error("Assert failed: (number? n)")); +} + +return (function (rf){ +var ia = cljs.core.volatile_BANG_((-1)); +return ((function (ia){ +return (function() { +var G__2815 = null; +var G__2815__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__2815__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__2815__2 = (function (result,input){ +var i = cljs.core._vreset_BANG_(ia,(cljs.core._deref(ia) + (1))); +if((cljs.core.rem(i,n) === (0))){ +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} else { +return result; +} +}); +G__2815 = function(result,input){ +switch(arguments.length){ +case 0: +return G__2815__0.call(this); +case 1: +return G__2815__1.call(this,result); +case 2: +return G__2815__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2815.cljs$core$IFn$_invoke$arity$0 = G__2815__0; +G__2815.cljs$core$IFn$_invoke$arity$1 = G__2815__1; +G__2815.cljs$core$IFn$_invoke$arity$2 = G__2815__2; +return G__2815; +})() +;})(ia)) +}); +}); + +cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +if(typeof n === 'number'){ +} else { +throw (new Error("Assert failed: (number? n)")); +} + +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +return cljs.core.cons(cljs.core.first(s),cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2(n,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(n,s))); +} else { +return null; +} +}),null,null)); +}); + +cljs.core.take_nth.cljs$lang$maxFixedArity = 2; + +/** + * Returns a vector of [(take-while pred coll) (drop-while pred coll)] + */ +cljs.core.split_with = (function cljs$core$split_with(pred,coll){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(pred,coll),cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2(pred,coll)], null); +}); +/** + * Applies f to each value in coll, splitting it each time f returns a + * new value. Returns a lazy seq of partitions. Returns a stateful + * transducer when no collection is provided. + */ +cljs.core.partition_by = (function cljs$core$partition_by(var_args){ +var G__2818 = arguments.length; +switch (G__2818) { +case 1: +return cljs.core.partition_by.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.partition_by.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.partition_by.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (function (rf){ +var a = cljs.core.array_list(); +var pa = cljs.core.volatile_BANG_(cljs.core.cst$kw$cljs$core_SLASH_none); +return ((function (a,pa){ +return (function() { +var G__2820 = null; +var G__2820__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__2820__1 = (function (result){ +var result__$1 = (cljs.core.truth_(a.isEmpty())?result:(function (){var v = cljs.core.vec(a.toArray()); +a.clear(); + +return cljs.core.unreduced((rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null,result,v))); +})()); +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result__$1) : rf.call(null,result__$1)); +}); +var G__2820__2 = (function (result,input){ +var pval = cljs.core.deref(pa); +var val = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(input) : f.call(null,input)); +cljs.core.vreset_BANG_(pa,val); + +if(((cljs.core.keyword_identical_QMARK_(pval,cljs.core.cst$kw$cljs$core_SLASH_none)) || (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(val,pval)))){ +a.add(input); + +return result; +} else { +var v = cljs.core.vec(a.toArray()); +a.clear(); + +var ret = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,v) : rf.call(null,result,v)); +if(cljs.core.reduced_QMARK_(ret)){ +} else { +a.add(input); +} + +return ret; +} +}); +G__2820 = function(result,input){ +switch(arguments.length){ +case 0: +return G__2820__0.call(this); +case 1: +return G__2820__1.call(this,result); +case 2: +return G__2820__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2820.cljs$core$IFn$_invoke$arity$0 = G__2820__0; +G__2820.cljs$core$IFn$_invoke$arity$1 = G__2820__1; +G__2820.cljs$core$IFn$_invoke$arity$2 = G__2820__2; +return G__2820; +})() +;})(a,pa)) +}); +}); + +cljs.core.partition_by.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +var fst = cljs.core.first(s); +var fv = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(fst) : f.call(null,fst)); +var run = cljs.core.cons(fst,cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(((function (fst,fv,s,temp__5457__auto__){ +return (function (p1__2816_SHARP_){ +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(fv,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(p1__2816_SHARP_) : f.call(null,p1__2816_SHARP_))); +});})(fst,fv,s,temp__5457__auto__)) +,cljs.core.next(s))); +return cljs.core.cons(run,cljs.core.partition_by.cljs$core$IFn$_invoke$arity$2(f,cljs.core.seq(cljs.core.drop.cljs$core$IFn$_invoke$arity$2(cljs.core.count(run),s)))); +} else { +return null; +} +}),null,null)); +}); + +cljs.core.partition_by.cljs$lang$maxFixedArity = 2; + +/** + * Returns a map from distinct items in coll to the number of times + * they appear. + */ +cljs.core.frequencies = (function cljs$core$frequencies(coll){ +return cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (counts,x){ +return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(counts,x,(cljs.core.get.cljs$core$IFn$_invoke$arity$3(counts,x,(0)) + (1))); +}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),coll)); +}); +/** + * Returns a lazy seq of the intermediate values of the reduction (as + * per reduce) of coll by f, starting with init. + */ +cljs.core.reductions = (function cljs$core$reductions(var_args){ +var G__2822 = arguments.length; +switch (G__2822) { +case 2: +return cljs.core.reductions.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.reductions.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.reductions.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){ +return (new cljs.core.LazySeq(null,(function (){ +var temp__5455__auto__ = cljs.core.seq(coll); +if(temp__5455__auto__){ +var s = temp__5455__auto__; +return cljs.core.reductions.cljs$core$IFn$_invoke$arity$3(f,cljs.core.first(s),cljs.core.rest(s)); +} else { +return (new cljs.core.List(null,(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)),null,(1),null)); +} +}),null,null)); +}); + +cljs.core.reductions.cljs$core$IFn$_invoke$arity$3 = (function (f,init,coll){ +if(cljs.core.reduced_QMARK_(init)){ +return (new cljs.core.List(null,cljs.core.deref(init),null,(1),null)); +} else { +return cljs.core.cons(init,(new cljs.core.LazySeq(null,(function (){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +return cljs.core.reductions.cljs$core$IFn$_invoke$arity$3(f,(function (){var G__2823 = init; +var G__2824 = cljs.core.first(s); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2823,G__2824) : f.call(null,G__2823,G__2824)); +})(),cljs.core.rest(s)); +} else { +return null; +} +}),null,null))); +} +}); + +cljs.core.reductions.cljs$lang$maxFixedArity = 3; + +/** + * Takes a set of functions and returns a fn that is the juxtaposition + * of those fns. The returned fn takes a variable number of args, and + * returns a vector containing the result of applying each fn to the + * args (left-to-right). + * ((juxt a b c) x) => [(a x) (b x) (c x)] + */ +cljs.core.juxt = (function cljs$core$juxt(var_args){ +var G__2841 = arguments.length; +switch (G__2841) { +case 1: +return cljs.core.juxt.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.juxt.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.juxt.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___2843 = arguments.length; +var i__4519__auto___2844 = (0); +while(true){ +if((i__4519__auto___2844 < len__4518__auto___2843)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___2844])); + +var G__2845 = (i__4519__auto___2844 + (1)); +i__4519__auto___2844 = G__2845; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((3)),(0),null)); +return cljs.core.juxt.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__4534__auto__); + +} +}); + +cljs.core.juxt.cljs$core$IFn$_invoke$arity$1 = (function (f){ +return (function() { +var G__2846 = null; +var G__2846__0 = (function (){ +return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null))],null)); +}); +var G__2846__1 = (function (x){ +return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null,x))],null)); +}); +var G__2846__2 = (function (x,y){ +return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null,x,y))],null)); +}); +var G__2846__3 = (function (x,y,z){ +return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(x,y,z) : f.call(null,x,y,z))],null)); +}); +var G__2846__4 = (function() { +var G__2847__delegate = function (x,y,z,args){ +return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,x,y,z,args)],null)); +}; +var G__2847 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__2848__i = 0, G__2848__a = new Array(arguments.length - 3); +while (G__2848__i < G__2848__a.length) {G__2848__a[G__2848__i] = arguments[G__2848__i + 3]; ++G__2848__i;} + args = new cljs.core.IndexedSeq(G__2848__a,0,null); +} +return G__2847__delegate.call(this,x,y,z,args);}; +G__2847.cljs$lang$maxFixedArity = 3; +G__2847.cljs$lang$applyTo = (function (arglist__2849){ +var x = cljs.core.first(arglist__2849); +arglist__2849 = cljs.core.next(arglist__2849); +var y = cljs.core.first(arglist__2849); +arglist__2849 = cljs.core.next(arglist__2849); +var z = cljs.core.first(arglist__2849); +var args = cljs.core.rest(arglist__2849); +return G__2847__delegate(x,y,z,args); +}); +G__2847.cljs$core$IFn$_invoke$arity$variadic = G__2847__delegate; +return G__2847; +})() +; +G__2846 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__2846__0.call(this); +case 1: +return G__2846__1.call(this,x); +case 2: +return G__2846__2.call(this,x,y); +case 3: +return G__2846__3.call(this,x,y,z); +default: +var G__2850 = null; +if (arguments.length > 3) { +var G__2851__i = 0, G__2851__a = new Array(arguments.length - 3); +while (G__2851__i < G__2851__a.length) {G__2851__a[G__2851__i] = arguments[G__2851__i + 3]; ++G__2851__i;} +G__2850 = new cljs.core.IndexedSeq(G__2851__a,0,null); +} +return G__2846__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__2850); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2846.cljs$lang$maxFixedArity = 3; +G__2846.cljs$lang$applyTo = G__2846__4.cljs$lang$applyTo; +G__2846.cljs$core$IFn$_invoke$arity$0 = G__2846__0; +G__2846.cljs$core$IFn$_invoke$arity$1 = G__2846__1; +G__2846.cljs$core$IFn$_invoke$arity$2 = G__2846__2; +G__2846.cljs$core$IFn$_invoke$arity$3 = G__2846__3; +G__2846.cljs$core$IFn$_invoke$arity$variadic = G__2846__4.cljs$core$IFn$_invoke$arity$variadic; +return G__2846; +})() +}); + +cljs.core.juxt.cljs$core$IFn$_invoke$arity$2 = (function (f,g){ +return (function() { +var G__2852 = null; +var G__2852__0 = (function (){ +return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)),(g.cljs$core$IFn$_invoke$arity$0 ? g.cljs$core$IFn$_invoke$arity$0() : g.call(null))],null)); +}); +var G__2852__1 = (function (x){ +return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null,x)),(g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(x) : g.call(null,x))],null)); +}); +var G__2852__2 = (function (x,y){ +return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null,x,y)),(g.cljs$core$IFn$_invoke$arity$2 ? g.cljs$core$IFn$_invoke$arity$2(x,y) : g.call(null,x,y))],null)); +}); +var G__2852__3 = (function (x,y,z){ +return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(x,y,z) : f.call(null,x,y,z)),(g.cljs$core$IFn$_invoke$arity$3 ? g.cljs$core$IFn$_invoke$arity$3(x,y,z) : g.call(null,x,y,z))],null)); +}); +var G__2852__4 = (function() { +var G__2853__delegate = function (x,y,z,args){ +return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,x,y,z,args),cljs.core.apply.cljs$core$IFn$_invoke$arity$5(g,x,y,z,args)],null)); +}; +var G__2853 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__2854__i = 0, G__2854__a = new Array(arguments.length - 3); +while (G__2854__i < G__2854__a.length) {G__2854__a[G__2854__i] = arguments[G__2854__i + 3]; ++G__2854__i;} + args = new cljs.core.IndexedSeq(G__2854__a,0,null); +} +return G__2853__delegate.call(this,x,y,z,args);}; +G__2853.cljs$lang$maxFixedArity = 3; +G__2853.cljs$lang$applyTo = (function (arglist__2855){ +var x = cljs.core.first(arglist__2855); +arglist__2855 = cljs.core.next(arglist__2855); +var y = cljs.core.first(arglist__2855); +arglist__2855 = cljs.core.next(arglist__2855); +var z = cljs.core.first(arglist__2855); +var args = cljs.core.rest(arglist__2855); +return G__2853__delegate(x,y,z,args); +}); +G__2853.cljs$core$IFn$_invoke$arity$variadic = G__2853__delegate; +return G__2853; +})() +; +G__2852 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__2852__0.call(this); +case 1: +return G__2852__1.call(this,x); +case 2: +return G__2852__2.call(this,x,y); +case 3: +return G__2852__3.call(this,x,y,z); +default: +var G__2856 = null; +if (arguments.length > 3) { +var G__2857__i = 0, G__2857__a = new Array(arguments.length - 3); +while (G__2857__i < G__2857__a.length) {G__2857__a[G__2857__i] = arguments[G__2857__i + 3]; ++G__2857__i;} +G__2856 = new cljs.core.IndexedSeq(G__2857__a,0,null); +} +return G__2852__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__2856); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2852.cljs$lang$maxFixedArity = 3; +G__2852.cljs$lang$applyTo = G__2852__4.cljs$lang$applyTo; +G__2852.cljs$core$IFn$_invoke$arity$0 = G__2852__0; +G__2852.cljs$core$IFn$_invoke$arity$1 = G__2852__1; +G__2852.cljs$core$IFn$_invoke$arity$2 = G__2852__2; +G__2852.cljs$core$IFn$_invoke$arity$3 = G__2852__3; +G__2852.cljs$core$IFn$_invoke$arity$variadic = G__2852__4.cljs$core$IFn$_invoke$arity$variadic; +return G__2852; +})() +}); + +cljs.core.juxt.cljs$core$IFn$_invoke$arity$3 = (function (f,g,h){ +return (function() { +var G__2858 = null; +var G__2858__0 = (function (){ +return (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)),(g.cljs$core$IFn$_invoke$arity$0 ? g.cljs$core$IFn$_invoke$arity$0() : g.call(null)),(h.cljs$core$IFn$_invoke$arity$0 ? h.cljs$core$IFn$_invoke$arity$0() : h.call(null))],null)); +}); +var G__2858__1 = (function (x){ +return (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null,x)),(g.cljs$core$IFn$_invoke$arity$1 ? g.cljs$core$IFn$_invoke$arity$1(x) : g.call(null,x)),(h.cljs$core$IFn$_invoke$arity$1 ? h.cljs$core$IFn$_invoke$arity$1(x) : h.call(null,x))],null)); +}); +var G__2858__2 = (function (x,y){ +return (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(x,y) : f.call(null,x,y)),(g.cljs$core$IFn$_invoke$arity$2 ? g.cljs$core$IFn$_invoke$arity$2(x,y) : g.call(null,x,y)),(h.cljs$core$IFn$_invoke$arity$2 ? h.cljs$core$IFn$_invoke$arity$2(x,y) : h.call(null,x,y))],null)); +}); +var G__2858__3 = (function (x,y,z){ +return (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[(f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(x,y,z) : f.call(null,x,y,z)),(g.cljs$core$IFn$_invoke$arity$3 ? g.cljs$core$IFn$_invoke$arity$3(x,y,z) : g.call(null,x,y,z)),(h.cljs$core$IFn$_invoke$arity$3 ? h.cljs$core$IFn$_invoke$arity$3(x,y,z) : h.call(null,x,y,z))],null)); +}); +var G__2858__4 = (function() { +var G__2859__delegate = function (x,y,z,args){ +return (new cljs.core.PersistentVector(null,3,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.cljs$core$IFn$_invoke$arity$5(f,x,y,z,args),cljs.core.apply.cljs$core$IFn$_invoke$arity$5(g,x,y,z,args),cljs.core.apply.cljs$core$IFn$_invoke$arity$5(h,x,y,z,args)],null)); +}; +var G__2859 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__2860__i = 0, G__2860__a = new Array(arguments.length - 3); +while (G__2860__i < G__2860__a.length) {G__2860__a[G__2860__i] = arguments[G__2860__i + 3]; ++G__2860__i;} + args = new cljs.core.IndexedSeq(G__2860__a,0,null); +} +return G__2859__delegate.call(this,x,y,z,args);}; +G__2859.cljs$lang$maxFixedArity = 3; +G__2859.cljs$lang$applyTo = (function (arglist__2861){ +var x = cljs.core.first(arglist__2861); +arglist__2861 = cljs.core.next(arglist__2861); +var y = cljs.core.first(arglist__2861); +arglist__2861 = cljs.core.next(arglist__2861); +var z = cljs.core.first(arglist__2861); +var args = cljs.core.rest(arglist__2861); +return G__2859__delegate(x,y,z,args); +}); +G__2859.cljs$core$IFn$_invoke$arity$variadic = G__2859__delegate; +return G__2859; +})() +; +G__2858 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__2858__0.call(this); +case 1: +return G__2858__1.call(this,x); +case 2: +return G__2858__2.call(this,x,y); +case 3: +return G__2858__3.call(this,x,y,z); +default: +var G__2862 = null; +if (arguments.length > 3) { +var G__2863__i = 0, G__2863__a = new Array(arguments.length - 3); +while (G__2863__i < G__2863__a.length) {G__2863__a[G__2863__i] = arguments[G__2863__i + 3]; ++G__2863__i;} +G__2862 = new cljs.core.IndexedSeq(G__2863__a,0,null); +} +return G__2858__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__2862); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2858.cljs$lang$maxFixedArity = 3; +G__2858.cljs$lang$applyTo = G__2858__4.cljs$lang$applyTo; +G__2858.cljs$core$IFn$_invoke$arity$0 = G__2858__0; +G__2858.cljs$core$IFn$_invoke$arity$1 = G__2858__1; +G__2858.cljs$core$IFn$_invoke$arity$2 = G__2858__2; +G__2858.cljs$core$IFn$_invoke$arity$3 = G__2858__3; +G__2858.cljs$core$IFn$_invoke$arity$variadic = G__2858__4.cljs$core$IFn$_invoke$arity$variadic; +return G__2858; +})() +}); + +cljs.core.juxt.cljs$core$IFn$_invoke$arity$variadic = (function (f,g,h,fs){ +var fs__$1 = cljs.core.list_STAR_.cljs$core$IFn$_invoke$arity$4(f,g,h,fs); +return ((function (fs__$1){ +return (function() { +var G__2864 = null; +var G__2864__0 = (function (){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (fs__$1){ +return (function (p1__2826_SHARP_,p2__2827_SHARP_){ +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__2826_SHARP_,(p2__2827_SHARP_.cljs$core$IFn$_invoke$arity$0 ? p2__2827_SHARP_.cljs$core$IFn$_invoke$arity$0() : p2__2827_SHARP_.call(null))); +});})(fs__$1)) +,cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__2864__1 = (function (x){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (fs__$1){ +return (function (p1__2828_SHARP_,p2__2829_SHARP_){ +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__2828_SHARP_,(p2__2829_SHARP_.cljs$core$IFn$_invoke$arity$1 ? p2__2829_SHARP_.cljs$core$IFn$_invoke$arity$1(x) : p2__2829_SHARP_.call(null,x))); +});})(fs__$1)) +,cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__2864__2 = (function (x,y){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (fs__$1){ +return (function (p1__2830_SHARP_,p2__2831_SHARP_){ +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__2830_SHARP_,(p2__2831_SHARP_.cljs$core$IFn$_invoke$arity$2 ? p2__2831_SHARP_.cljs$core$IFn$_invoke$arity$2(x,y) : p2__2831_SHARP_.call(null,x,y))); +});})(fs__$1)) +,cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__2864__3 = (function (x,y,z){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (fs__$1){ +return (function (p1__2832_SHARP_,p2__2833_SHARP_){ +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__2832_SHARP_,(p2__2833_SHARP_.cljs$core$IFn$_invoke$arity$3 ? p2__2833_SHARP_.cljs$core$IFn$_invoke$arity$3(x,y,z) : p2__2833_SHARP_.call(null,x,y,z))); +});})(fs__$1)) +,cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__2864__4 = (function() { +var G__2865__delegate = function (x,y,z,args){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (fs__$1){ +return (function (p1__2834_SHARP_,p2__2835_SHARP_){ +return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(p1__2834_SHARP_,cljs.core.apply.cljs$core$IFn$_invoke$arity$5(p2__2835_SHARP_,x,y,z,args)); +});})(fs__$1)) +,cljs.core.PersistentVector.EMPTY,fs__$1); +}; +var G__2865 = function (x,y,z,var_args){ +var args = null; +if (arguments.length > 3) { +var G__2866__i = 0, G__2866__a = new Array(arguments.length - 3); +while (G__2866__i < G__2866__a.length) {G__2866__a[G__2866__i] = arguments[G__2866__i + 3]; ++G__2866__i;} + args = new cljs.core.IndexedSeq(G__2866__a,0,null); +} +return G__2865__delegate.call(this,x,y,z,args);}; +G__2865.cljs$lang$maxFixedArity = 3; +G__2865.cljs$lang$applyTo = (function (arglist__2867){ +var x = cljs.core.first(arglist__2867); +arglist__2867 = cljs.core.next(arglist__2867); +var y = cljs.core.first(arglist__2867); +arglist__2867 = cljs.core.next(arglist__2867); +var z = cljs.core.first(arglist__2867); +var args = cljs.core.rest(arglist__2867); +return G__2865__delegate(x,y,z,args); +}); +G__2865.cljs$core$IFn$_invoke$arity$variadic = G__2865__delegate; +return G__2865; +})() +; +G__2864 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__2864__0.call(this); +case 1: +return G__2864__1.call(this,x); +case 2: +return G__2864__2.call(this,x,y); +case 3: +return G__2864__3.call(this,x,y,z); +default: +var G__2868 = null; +if (arguments.length > 3) { +var G__2869__i = 0, G__2869__a = new Array(arguments.length - 3); +while (G__2869__i < G__2869__a.length) {G__2869__a[G__2869__i] = arguments[G__2869__i + 3]; ++G__2869__i;} +G__2868 = new cljs.core.IndexedSeq(G__2869__a,0,null); +} +return G__2864__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, G__2868); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__2864.cljs$lang$maxFixedArity = 3; +G__2864.cljs$lang$applyTo = G__2864__4.cljs$lang$applyTo; +G__2864.cljs$core$IFn$_invoke$arity$0 = G__2864__0; +G__2864.cljs$core$IFn$_invoke$arity$1 = G__2864__1; +G__2864.cljs$core$IFn$_invoke$arity$2 = G__2864__2; +G__2864.cljs$core$IFn$_invoke$arity$3 = G__2864__3; +G__2864.cljs$core$IFn$_invoke$arity$variadic = G__2864__4.cljs$core$IFn$_invoke$arity$variadic; +return G__2864; +})() +;})(fs__$1)) +}); + +/** @this {Function} */ +cljs.core.juxt.cljs$lang$applyTo = (function (seq2837){ +var G__2838 = cljs.core.first(seq2837); +var seq2837__$1 = cljs.core.next(seq2837); +var G__2839 = cljs.core.first(seq2837__$1); +var seq2837__$2 = cljs.core.next(seq2837__$1); +var G__2840 = cljs.core.first(seq2837__$2); +var seq2837__$3 = cljs.core.next(seq2837__$2); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2838,G__2839,G__2840,seq2837__$3); +}); + +cljs.core.juxt.cljs$lang$maxFixedArity = (3); + +/** + * When lazy sequences are produced via functions that have side + * effects, any effects other than those needed to produce the first + * element in the seq do not occur until the seq is consumed. dorun can + * be used to force any effects. Walks through the successive nexts of + * the seq, does not retain the head and returns nil. + */ +cljs.core.dorun = (function cljs$core$dorun(var_args){ +var G__2871 = arguments.length; +switch (G__2871) { +case 1: +return cljs.core.dorun.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.dorun.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.dorun.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +while(true){ +var temp__5457__auto__ = cljs.core.seq(coll); +if(temp__5457__auto__){ +var s = temp__5457__auto__; +var G__2873 = cljs.core.next(s); +coll = G__2873; +continue; +} else { +return null; +} +break; +} +}); + +cljs.core.dorun.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +while(true){ +if(((cljs.core.seq(coll)) && ((n > (0))))){ +var G__2874 = (n - (1)); +var G__2875 = cljs.core.next(coll); +n = G__2874; +coll = G__2875; +continue; +} else { +return null; +} +break; +} +}); + +cljs.core.dorun.cljs$lang$maxFixedArity = 2; + +/** + * When lazy sequences are produced via functions that have side + * effects, any effects other than those needed to produce the first + * element in the seq do not occur until the seq is consumed. doall can + * be used to force any effects. Walks through the successive nexts of + * the seq, retains the head and returns it, thus causing the entire + * seq to reside in memory at one time. + */ +cljs.core.doall = (function cljs$core$doall(var_args){ +var G__2877 = arguments.length; +switch (G__2877) { +case 1: +return cljs.core.doall.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.doall.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.doall.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +cljs.core.dorun.cljs$core$IFn$_invoke$arity$1(coll); + +return coll; +}); + +cljs.core.doall.cljs$core$IFn$_invoke$arity$2 = (function (n,coll){ +cljs.core.dorun.cljs$core$IFn$_invoke$arity$2(n,coll); + +return coll; +}); + +cljs.core.doall.cljs$lang$maxFixedArity = 2; + +/** + * Returns true if x is a JavaScript RegExp instance. + */ +cljs.core.regexp_QMARK_ = (function cljs$core$regexp_QMARK_(x){ +return (x instanceof RegExp); +}); +/** + * Returns the result of (re-find re s) if re fully matches s. + */ +cljs.core.re_matches = (function cljs$core$re_matches(re,s){ +if(typeof s === 'string'){ +var matches = re.exec(s); +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.first(matches),s)){ +if((cljs.core.count(matches) === (1))){ +return cljs.core.first(matches); +} else { +return cljs.core.vec(matches); +} +} else { +return null; +} +} else { +throw (new TypeError("re-matches must match against a string.")); +} +}); +/** + * Returns the first regex match, if any, of s to re, using + * re.exec(s). Returns a vector, containing first the matching + * substring, then any capturing groups if the regular expression contains + * capturing groups. + */ +cljs.core.re_find = (function cljs$core$re_find(re,s){ +if(typeof s === 'string'){ +var matches = re.exec(s); +if((matches == null)){ +return null; +} else { +if((cljs.core.count(matches) === (1))){ +return cljs.core.first(matches); +} else { +return cljs.core.vec(matches); +} +} +} else { +throw (new TypeError("re-find must match against a string.")); +} +}); +/** + * Returns a lazy sequence of successive matches of re in s. + */ +cljs.core.re_seq = (function cljs$core$re_seq(re,s){ +var match_data = cljs.core.re_find(re,s); +var match_idx = s.search(re); +var match_str = ((cljs.core.coll_QMARK_(match_data))?cljs.core.first(match_data):match_data); +var post_idx = (match_idx + (function (){var x__4024__auto__ = (1); +var y__4025__auto__ = cljs.core.count(match_str); +return ((x__4024__auto__ > y__4025__auto__) ? x__4024__auto__ : y__4025__auto__); +})()); +var post_match = cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,post_idx); +if(cljs.core.truth_(match_data)){ +return (new cljs.core.LazySeq(null,((function (match_data,match_idx,match_str,post_idx,post_match){ +return (function (){ +return cljs.core.cons(match_data,(((post_idx <= cljs.core.count(s)))?(cljs.core.re_seq.cljs$core$IFn$_invoke$arity$2 ? cljs.core.re_seq.cljs$core$IFn$_invoke$arity$2(re,post_match) : cljs.core.re_seq.call(null,re,post_match)):null)); +});})(match_data,match_idx,match_str,post_idx,post_match)) +,null,null)); +} else { +return null; +} +}); +/** + * Returns an instance of RegExp which has compiled the provided string. + */ +cljs.core.re_pattern = (function cljs$core$re_pattern(s){ +if((s instanceof RegExp)){ +return s; +} else { +var vec__2879 = cljs.core.re_find(/^\(\?([idmsux]*)\)/,s); +var prefix = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2879,(0),null); +var flags = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2879,(1),null); +var pattern = cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,cljs.core.count(prefix)); +return (new RegExp(pattern,(function (){var or__3936__auto__ = flags; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return ""; +} +})())); +} +}); +cljs.core.pr_sequential_writer = (function cljs$core$pr_sequential_writer(writer,print_one,begin,sep,end,opts,coll){ +var _STAR_print_level_STAR_2882 = cljs.core._STAR_print_level_STAR_; +cljs.core._STAR_print_level_STAR_ = (((cljs.core._STAR_print_level_STAR_ == null))?null:(cljs.core._STAR_print_level_STAR_ - (1))); + +try{if(((!((cljs.core._STAR_print_level_STAR_ == null))) && ((cljs.core._STAR_print_level_STAR_ < (0))))){ +return cljs.core._write(writer,"#"); +} else { +cljs.core._write(writer,begin); + +if((cljs.core.cst$kw$print_DASH_length.cljs$core$IFn$_invoke$arity$1(opts) === (0))){ +if(cljs.core.seq(coll)){ +cljs.core._write(writer,(function (){var or__3936__auto__ = cljs.core.cst$kw$more_DASH_marker.cljs$core$IFn$_invoke$arity$1(opts); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return "..."; +} +})()); +} else { +} +} else { +if(cljs.core.seq(coll)){ +var G__2883_2889 = cljs.core.first(coll); +var G__2884_2890 = writer; +var G__2885_2891 = opts; +(print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__2883_2889,G__2884_2890,G__2885_2891) : print_one.call(null,G__2883_2889,G__2884_2890,G__2885_2891)); +} else { +} + +var coll_2892__$1 = cljs.core.next(coll); +var n_2893 = (cljs.core.cst$kw$print_DASH_length.cljs$core$IFn$_invoke$arity$1(opts) - (1)); +while(true){ +if(((coll_2892__$1) && ((((n_2893 == null)) || (!((n_2893 === (0)))))))){ +cljs.core._write(writer,sep); + +var G__2886_2894 = cljs.core.first(coll_2892__$1); +var G__2887_2895 = writer; +var G__2888_2896 = opts; +(print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__2886_2894,G__2887_2895,G__2888_2896) : print_one.call(null,G__2886_2894,G__2887_2895,G__2888_2896)); + +var G__2897 = cljs.core.next(coll_2892__$1); +var G__2898 = (n_2893 - (1)); +coll_2892__$1 = G__2897; +n_2893 = G__2898; +continue; +} else { +if(((cljs.core.seq(coll_2892__$1)) && ((n_2893 === (0))))){ +cljs.core._write(writer,sep); + +cljs.core._write(writer,(function (){var or__3936__auto__ = cljs.core.cst$kw$more_DASH_marker.cljs$core$IFn$_invoke$arity$1(opts); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return "..."; +} +})()); +} else { +} +} +break; +} +} + +return cljs.core._write(writer,end); +} +}finally {cljs.core._STAR_print_level_STAR_ = _STAR_print_level_STAR_2882; +}}); +cljs.core.write_all = (function cljs$core$write_all(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2905 = arguments.length; +var i__4519__auto___2906 = (0); +while(true){ +if((i__4519__auto___2906 < len__4518__auto___2905)){ +args__4521__auto__.push((arguments[i__4519__auto___2906])); + +var G__2907 = (i__4519__auto___2906 + (1)); +i__4519__auto___2906 = G__2907; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic = (function (writer,ss){ +var seq__2901 = cljs.core.seq(ss); +var chunk__2902 = null; +var count__2903 = (0); +var i__2904 = (0); +while(true){ +if((i__2904 < count__2903)){ +var s = chunk__2902.cljs$core$IIndexed$_nth$arity$2(null,i__2904); +cljs.core._write(writer,s); + + +var G__2908 = seq__2901; +var G__2909 = chunk__2902; +var G__2910 = count__2903; +var G__2911 = (i__2904 + (1)); +seq__2901 = G__2908; +chunk__2902 = G__2909; +count__2903 = G__2910; +i__2904 = G__2911; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2901); +if(temp__5457__auto__){ +var seq__2901__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2901__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2901__$1); +var G__2912 = cljs.core.chunk_rest(seq__2901__$1); +var G__2913 = c__4338__auto__; +var G__2914 = cljs.core.count(c__4338__auto__); +var G__2915 = (0); +seq__2901 = G__2912; +chunk__2902 = G__2913; +count__2903 = G__2914; +i__2904 = G__2915; +continue; +} else { +var s = cljs.core.first(seq__2901__$1); +cljs.core._write(writer,s); + + +var G__2916 = cljs.core.next(seq__2901__$1); +var G__2917 = null; +var G__2918 = (0); +var G__2919 = (0); +seq__2901 = G__2916; +chunk__2902 = G__2917; +count__2903 = G__2918; +i__2904 = G__2919; +continue; +} +} else { +return null; +} +} +break; +} +}); + +cljs.core.write_all.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.core.write_all.cljs$lang$applyTo = (function (seq2899){ +var G__2900 = cljs.core.first(seq2899); +var seq2899__$1 = cljs.core.next(seq2899); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2900,seq2899__$1); +}); + +cljs.core.string_print = (function cljs$core$string_print(x){ +if((cljs.core._STAR_print_fn_STAR_ == null)){ +throw (new Error("No *print-fn* fn set for evaluation environment")); +} else { +} + +(cljs.core._STAR_print_fn_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.core._STAR_print_fn_STAR_.cljs$core$IFn$_invoke$arity$1(x) : cljs.core._STAR_print_fn_STAR_.call(null,x)); + +return null; +}); +cljs.core.flush = (function cljs$core$flush(){ +return null; +}); +cljs.core.char_escapes = (function (){var obj2921 = {"\"":"\\\"","\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"}; +return obj2921; +})(); +cljs.core.quote_string = (function cljs$core$quote_string(s){ +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1("\""),cljs.core.str.cljs$core$IFn$_invoke$arity$1(s.replace(RegExp("[\\\\\"\b\f\n\r\t]","g"),(function (match){ +return (cljs.core.char_escapes[match]); +}))),cljs.core.str.cljs$core$IFn$_invoke$arity$1("\"")].join(''); +}); +cljs.core.print_meta_QMARK_ = (function cljs$core$print_meta_QMARK_(opts,obj){ +var and__3925__auto__ = cljs.core.boolean$(cljs.core.get.cljs$core$IFn$_invoke$arity$2(opts,cljs.core.cst$kw$meta)); +if(and__3925__auto__){ +var and__3925__auto____$1 = ((!((obj == null)))?(((((obj.cljs$lang$protocol_mask$partition0$ & (131072))) || ((cljs.core.PROTOCOL_SENTINEL === obj.cljs$core$IMeta$))))?true:false):false); +if(and__3925__auto____$1){ +return !((cljs.core.meta(obj) == null)); +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +}); +cljs.core.pr_writer_impl = (function cljs$core$pr_writer_impl(obj,writer,opts){ +if((obj == null)){ +return cljs.core._write(writer,"nil"); +} else { +if(cljs.core.print_meta_QMARK_(opts,obj)){ +cljs.core._write(writer,"^"); + +cljs.core.pr_writer(cljs.core.meta(obj),writer,opts); + +cljs.core._write(writer," "); +} else { +} + +if(obj.cljs$lang$type){ +return obj.cljs$lang$ctorPrWriter(obj,writer,opts); +} else { +if(((!((obj == null)))?(((((obj.cljs$lang$protocol_mask$partition0$ & (2147483648))) || ((cljs.core.PROTOCOL_SENTINEL === obj.cljs$core$IPrintWithWriter$))))?true:false):false)){ +return obj.cljs$core$IPrintWithWriter$_pr_writer$arity$3(null,writer,opts); +} else { +if(((obj === true) || (obj === false))){ +return cljs.core._write(writer,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj)].join('')); +} else { +if(typeof obj === 'number'){ +return cljs.core._write(writer,((isNaN(obj))?"##NaN":(((obj === Number.POSITIVE_INFINITY))?"##Inf":(((obj === Number.NEGATIVE_INFINITY))?"##-Inf":[cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj)].join('') +)))); +} else { +if(cljs.core.object_QMARK_(obj)){ +cljs.core._write(writer,"#js "); + +return cljs.core.print_map(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (k){ +return (new cljs.core.MapEntry((function (){var G__2926 = k; +if(!((cljs.core.re_matches(/[A-Za-z_\*\+\?!\-'][\w\*\+\?!\-']*/,k) == null))){ +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(G__2926); +} else { +return G__2926; +} +})(),(obj[k]),null)); +}),cljs.core.js_keys(obj)),cljs.core.pr_writer,writer,opts); +} else { +if(cljs.core.array_QMARK_(obj)){ +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"#js ["," ","]",opts,obj); +} else { +if(goog.isString(obj)){ +if(cljs.core.truth_(cljs.core.cst$kw$readably.cljs$core$IFn$_invoke$arity$1(opts))){ +return cljs.core._write(writer,cljs.core.quote_string(obj)); +} else { +return cljs.core._write(writer,obj); +} +} else { +if(goog.isFunction(obj)){ +var name = obj.name; +var name__$1 = (cljs.core.truth_((function (){var or__3936__auto__ = (name == null); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return goog.string.isEmpty(name); +} +})())?"Function":name); +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["#object[",name__$1,((cljs.core._STAR_print_fn_bodies_STAR_)?[" \"",cljs.core.str.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj)].join('')),"\""].join(''):""),"]"], 0)); +} else { +if((obj instanceof Date)){ +var normalize = (function (n,len){ +var ns = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)].join(''); +while(true){ +if((cljs.core.count(ns) < len)){ +var G__2929 = ["0",cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns)].join(''); +ns = G__2929; +continue; +} else { +return ns; +} +break; +} +}); +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["#inst \"",[cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj.getUTCFullYear())].join(''),"-",normalize((obj.getUTCMonth() + (1)),(2)),"-",normalize(obj.getUTCDate(),(2)),"T",normalize(obj.getUTCHours(),(2)),":",normalize(obj.getUTCMinutes(),(2)),":",normalize(obj.getUTCSeconds(),(2)),".",normalize(obj.getUTCMilliseconds(),(3)),"-","00:00\""], 0)); +} else { +if(cljs.core.regexp_QMARK_(obj)){ +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["#\"",obj.source,"\""], 0)); +} else { +if(cljs.core.truth_((function (){var G__2927 = obj; +var G__2927__$1 = (((G__2927 == null))?null:G__2927.constructor); +if((G__2927__$1 == null)){ +return null; +} else { +return G__2927__$1.cljs$lang$ctorStr; +} +})())){ +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["#object[",obj.constructor.cljs$lang$ctorStr.replace((new RegExp("/","g")),"."),"]"], 0)); +} else { +var name = (function (){var G__2928 = obj; +var G__2928__$1 = (((G__2928 == null))?null:G__2928.constructor); +if((G__2928__$1 == null)){ +return null; +} else { +return G__2928__$1.name; +} +})(); +var name__$1 = (cljs.core.truth_((function (){var or__3936__auto__ = (name == null); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return goog.string.isEmpty(name); +} +})())?"Object":name); +if((obj.constructor == null)){ +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["#object[",name__$1,"]"], 0)); +} else { +return cljs.core.write_all.cljs$core$IFn$_invoke$arity$variadic(writer,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["#object[",name__$1," ",[cljs.core.str.cljs$core$IFn$_invoke$arity$1(obj)].join(''),"]"], 0)); +} +} + +} +} +} +} +} +} +} +} +} +} + +} +}); +/** + * Prefer this to pr-seq, because it makes the printing function + * configurable, allowing efficient implementations such as appending + * to a StringBuffer. + */ +cljs.core.pr_writer = (function cljs$core$pr_writer(obj,writer,opts){ +var temp__5455__auto__ = cljs.core.cst$kw$alt_DASH_impl.cljs$core$IFn$_invoke$arity$1(opts); +if(cljs.core.truth_(temp__5455__auto__)){ +var alt_impl = temp__5455__auto__; +var G__2930 = obj; +var G__2931 = writer; +var G__2932 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(opts,cljs.core.cst$kw$fallback_DASH_impl,cljs.core.pr_writer_impl); +return (alt_impl.cljs$core$IFn$_invoke$arity$3 ? alt_impl.cljs$core$IFn$_invoke$arity$3(G__2930,G__2931,G__2932) : alt_impl.call(null,G__2930,G__2931,G__2932)); +} else { +return cljs.core.pr_writer_impl(obj,writer,opts); +} +}); +cljs.core.pr_seq_writer = (function cljs$core$pr_seq_writer(objs,writer,opts){ +cljs.core.pr_writer(cljs.core.first(objs),writer,opts); + +var seq__2933 = cljs.core.seq(cljs.core.next(objs)); +var chunk__2934 = null; +var count__2935 = (0); +var i__2936 = (0); +while(true){ +if((i__2936 < count__2935)){ +var obj = chunk__2934.cljs$core$IIndexed$_nth$arity$2(null,i__2936); +cljs.core._write(writer," "); + +cljs.core.pr_writer(obj,writer,opts); + + +var G__2937 = seq__2933; +var G__2938 = chunk__2934; +var G__2939 = count__2935; +var G__2940 = (i__2936 + (1)); +seq__2933 = G__2937; +chunk__2934 = G__2938; +count__2935 = G__2939; +i__2936 = G__2940; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__2933); +if(temp__5457__auto__){ +var seq__2933__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__2933__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__2933__$1); +var G__2941 = cljs.core.chunk_rest(seq__2933__$1); +var G__2942 = c__4338__auto__; +var G__2943 = cljs.core.count(c__4338__auto__); +var G__2944 = (0); +seq__2933 = G__2941; +chunk__2934 = G__2942; +count__2935 = G__2943; +i__2936 = G__2944; +continue; +} else { +var obj = cljs.core.first(seq__2933__$1); +cljs.core._write(writer," "); + +cljs.core.pr_writer(obj,writer,opts); + + +var G__2945 = cljs.core.next(seq__2933__$1); +var G__2946 = null; +var G__2947 = (0); +var G__2948 = (0); +seq__2933 = G__2945; +chunk__2934 = G__2946; +count__2935 = G__2947; +i__2936 = G__2948; +continue; +} +} else { +return null; +} +} +break; +} +}); +cljs.core.pr_sb_with_opts = (function cljs$core$pr_sb_with_opts(objs,opts){ +var sb = (new goog.string.StringBuffer()); +var writer = (new cljs.core.StringBufferWriter(sb)); +cljs.core.pr_seq_writer(objs,writer,opts); + +writer.cljs$core$IWriter$_flush$arity$1(null); + +return sb; +}); +/** + * Prints a sequence of objects to a string, observing all the + * options given in opts + */ +cljs.core.pr_str_with_opts = (function cljs$core$pr_str_with_opts(objs,opts){ +if(cljs.core.empty_QMARK_(objs)){ +return ""; +} else { +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_sb_with_opts(objs,opts))].join(''); +} +}); +/** + * Same as pr-str-with-opts followed by (newline) + */ +cljs.core.prn_str_with_opts = (function cljs$core$prn_str_with_opts(objs,opts){ +if(cljs.core.empty_QMARK_(objs)){ +return "\n"; +} else { +var sb = cljs.core.pr_sb_with_opts(objs,opts); +sb.append("\n"); + +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)].join(''); +} +}); +/** + * Prints a sequence of objects using string-print, observing all + * the options given in opts + */ +cljs.core.pr_with_opts = (function cljs$core$pr_with_opts(objs,opts){ +return cljs.core.string_print(cljs.core.pr_str_with_opts(objs,opts)); +}); +/** + * Prints a newline using *print-fn* + */ +cljs.core.newline = (function cljs$core$newline(var_args){ +var G__2950 = arguments.length; +switch (G__2950) { +case 0: +return cljs.core.newline.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.newline.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.newline.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.newline.cljs$core$IFn$_invoke$arity$1(null); +}); + +cljs.core.newline.cljs$core$IFn$_invoke$arity$1 = (function (opts){ +cljs.core.string_print("\n"); + +if(cljs.core.truth_(cljs.core.get.cljs$core$IFn$_invoke$arity$2(opts,cljs.core.cst$kw$flush_DASH_on_DASH_newline))){ +return cljs.core.flush(); +} else { +return null; +} +}); + +cljs.core.newline.cljs$lang$maxFixedArity = 1; + +/** + * pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter. + */ +cljs.core.pr_str = (function cljs$core$pr_str(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2953 = arguments.length; +var i__4519__auto___2954 = (0); +while(true){ +if((i__4519__auto___2954 < len__4518__auto___2953)){ +args__4521__auto__.push((arguments[i__4519__auto___2954])); + +var G__2955 = (i__4519__auto___2954 + (1)); +i__4519__auto___2954 = G__2955; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +return cljs.core.pr_str_with_opts(objs,cljs.core.pr_opts()); +}); + +cljs.core.pr_str.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.pr_str.cljs$lang$applyTo = (function (seq2952){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2952)); +}); + +/** + * Same as pr-str followed by (newline) + */ +cljs.core.prn_str = (function cljs$core$prn_str(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2957 = arguments.length; +var i__4519__auto___2958 = (0); +while(true){ +if((i__4519__auto___2958 < len__4518__auto___2957)){ +args__4521__auto__.push((arguments[i__4519__auto___2958])); + +var G__2959 = (i__4519__auto___2958 + (1)); +i__4519__auto___2958 = G__2959; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.prn_str.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.prn_str.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +return cljs.core.prn_str_with_opts(objs,cljs.core.pr_opts()); +}); + +cljs.core.prn_str.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.prn_str.cljs$lang$applyTo = (function (seq2956){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2956)); +}); + +/** + * Prints the object(s) using string-print. Prints the + * object(s), separated by spaces if there is more than one. + * By default, pr and prn print in a way that objects can be + * read by the reader + */ +cljs.core.pr = (function cljs$core$pr(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2961 = arguments.length; +var i__4519__auto___2962 = (0); +while(true){ +if((i__4519__auto___2962 < len__4518__auto___2961)){ +args__4521__auto__.push((arguments[i__4519__auto___2962])); + +var G__2963 = (i__4519__auto___2962 + (1)); +i__4519__auto___2962 = G__2963; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.pr.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.pr.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +return cljs.core.pr_with_opts(objs,cljs.core.pr_opts()); +}); + +cljs.core.pr.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.pr.cljs$lang$applyTo = (function (seq2960){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2960)); +}); + +/** + * Prints the object(s) using string-print. + * print and println produce output for human consumption. + * @param {...*} var_args + */ +cljs.core.print = (function() { +var cljs$core$cljs_core_print__delegate = function (objs){ +return cljs.core.pr_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),cljs.core.cst$kw$readably,false)); +}; +var cljs$core$cljs_core_print = function (var_args){ +var objs = null; +if (arguments.length > 0) { +var G__2964__i = 0, G__2964__a = new Array(arguments.length - 0); +while (G__2964__i < G__2964__a.length) {G__2964__a[G__2964__i] = arguments[G__2964__i + 0]; ++G__2964__i;} + objs = new cljs.core.IndexedSeq(G__2964__a,0,null); +} +return cljs$core$cljs_core_print__delegate.call(this,objs);}; +cljs$core$cljs_core_print.cljs$lang$maxFixedArity = 0; +cljs$core$cljs_core_print.cljs$lang$applyTo = (function (arglist__2965){ +var objs = cljs.core.seq(arglist__2965); +return cljs$core$cljs_core_print__delegate(objs); +}); +cljs$core$cljs_core_print.cljs$core$IFn$_invoke$arity$variadic = cljs$core$cljs_core_print__delegate; +return cljs$core$cljs_core_print; +})() +; +/** + * print to a string, returning it + */ +cljs.core.print_str = (function cljs$core$print_str(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2967 = arguments.length; +var i__4519__auto___2968 = (0); +while(true){ +if((i__4519__auto___2968 < len__4518__auto___2967)){ +args__4521__auto__.push((arguments[i__4519__auto___2968])); + +var G__2969 = (i__4519__auto___2968 + (1)); +i__4519__auto___2968 = G__2969; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.print_str.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.print_str.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +return cljs.core.pr_str_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),cljs.core.cst$kw$readably,false)); +}); + +cljs.core.print_str.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.print_str.cljs$lang$applyTo = (function (seq2966){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2966)); +}); + +/** + * Same as print followed by (newline) + */ +cljs.core.println = (function cljs$core$println(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2971 = arguments.length; +var i__4519__auto___2972 = (0); +while(true){ +if((i__4519__auto___2972 < len__4518__auto___2971)){ +args__4521__auto__.push((arguments[i__4519__auto___2972])); + +var G__2973 = (i__4519__auto___2972 + (1)); +i__4519__auto___2972 = G__2973; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.println.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +cljs.core.pr_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),cljs.core.cst$kw$readably,false)); + +if(cljs.core._STAR_print_newline_STAR_){ +return cljs.core.newline.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_opts()); +} else { +return null; +} +}); + +cljs.core.println.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.println.cljs$lang$applyTo = (function (seq2970){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2970)); +}); + +/** + * println to a string, returning it + */ +cljs.core.println_str = (function cljs$core$println_str(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2975 = arguments.length; +var i__4519__auto___2976 = (0); +while(true){ +if((i__4519__auto___2976 < len__4518__auto___2975)){ +args__4521__auto__.push((arguments[i__4519__auto___2976])); + +var G__2977 = (i__4519__auto___2976 + (1)); +i__4519__auto___2976 = G__2977; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.println_str.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.println_str.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +return cljs.core.prn_str_with_opts(objs,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.pr_opts(),cljs.core.cst$kw$readably,false)); +}); + +cljs.core.println_str.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.println_str.cljs$lang$applyTo = (function (seq2974){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2974)); +}); + +/** + * Same as pr followed by (newline). + */ +cljs.core.prn = (function cljs$core$prn(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___2979 = arguments.length; +var i__4519__auto___2980 = (0); +while(true){ +if((i__4519__auto___2980 < len__4518__auto___2979)){ +args__4521__auto__.push((arguments[i__4519__auto___2980])); + +var G__2981 = (i__4519__auto___2980 + (1)); +i__4519__auto___2980 = G__2981; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.prn.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.prn.cljs$core$IFn$_invoke$arity$variadic = (function (objs){ +cljs.core.pr_with_opts(objs,cljs.core.pr_opts()); + +if(cljs.core._STAR_print_newline_STAR_){ +return cljs.core.newline.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_opts()); +} else { +return null; +} +}); + +cljs.core.prn.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.prn.cljs$lang$applyTo = (function (seq2978){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq2978)); +}); + +cljs.core.strip_ns = (function cljs$core$strip_ns(named){ +if((named instanceof cljs.core.Symbol)){ +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(null,cljs.core.name(named)); +} else { +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$2(null,cljs.core.name(named)); +} +}); +/** + * Returns [lifted-ns lifted-map] or nil if m can't be lifted. + */ +cljs.core.lift_ns = (function cljs$core$lift_ns(m){ +if(cljs.core._STAR_print_namespace_maps_STAR_){ +var ns = null; +var G__2988 = cljs.core.seq(m); +var vec__2989 = G__2988; +var seq__2990 = cljs.core.seq(vec__2989); +var first__2991 = cljs.core.first(seq__2990); +var seq__2990__$1 = cljs.core.next(seq__2990); +var vec__2992 = first__2991; +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2992,(0),null); +var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2992,(1),null); +var entry = vec__2992; +var entries = seq__2990__$1; +var lm = cljs.core.empty(m); +var ns__$1 = ns; +var G__2988__$1 = G__2988; +var lm__$1 = lm; +while(true){ +var ns__$2 = ns__$1; +var vec__2995 = G__2988__$1; +var seq__2996 = cljs.core.seq(vec__2995); +var first__2997 = cljs.core.first(seq__2996); +var seq__2996__$1 = cljs.core.next(seq__2996); +var vec__2998 = first__2997; +var k__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2998,(0),null); +var v__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2998,(1),null); +var entry__$1 = vec__2998; +var entries__$1 = seq__2996__$1; +var lm__$2 = lm__$1; +if(cljs.core.truth_(entry__$1)){ +if((((k__$1 instanceof cljs.core.Keyword)) || ((k__$1 instanceof cljs.core.Symbol)))){ +if(cljs.core.truth_(ns__$2)){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ns__$2,cljs.core.namespace(k__$1))){ +var G__3001 = ns__$2; +var G__3002 = entries__$1; +var G__3003 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(lm__$2,cljs.core.strip_ns(k__$1),v__$1); +ns__$1 = G__3001; +G__2988__$1 = G__3002; +lm__$1 = G__3003; +continue; +} else { +return null; +} +} else { +var temp__5457__auto__ = cljs.core.namespace(k__$1); +if(cljs.core.truth_(temp__5457__auto__)){ +var new_ns = temp__5457__auto__; +var G__3004 = new_ns; +var G__3005 = entries__$1; +var G__3006 = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(lm__$2,cljs.core.strip_ns(k__$1),v__$1); +ns__$1 = G__3004; +G__2988__$1 = G__3005; +lm__$1 = G__3006; +continue; +} else { +return null; +} +} +} else { +return null; +} +} else { +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns__$2,lm__$2], null); +} +break; +} +} else { +return null; +} +}); +cljs.core.print_prefix_map = (function cljs$core$print_prefix_map(prefix,m,print_one,writer,opts){ +return cljs.core.pr_sequential_writer(writer,(function (e,w,opts__$1){ +var G__3007_3013 = cljs.core.key(e); +var G__3008_3014 = w; +var G__3009_3015 = opts__$1; +(print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__3007_3013,G__3008_3014,G__3009_3015) : print_one.call(null,G__3007_3013,G__3008_3014,G__3009_3015)); + +cljs.core._write(w," "); + +var G__3010 = cljs.core.val(e); +var G__3011 = w; +var G__3012 = opts__$1; +return (print_one.cljs$core$IFn$_invoke$arity$3 ? print_one.cljs$core$IFn$_invoke$arity$3(G__3010,G__3011,G__3012) : print_one.call(null,G__3010,G__3011,G__3012)); +}),[cljs.core.str.cljs$core$IFn$_invoke$arity$1(prefix),"{"].join(''),", ","}",opts,cljs.core.seq(m)); +}); +cljs.core.print_map = (function cljs$core$print_map(m,print_one,writer,opts){ +var vec__3016 = ((cljs.core.map_QMARK_(m))?cljs.core.lift_ns(m):null); +var ns = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3016,(0),null); +var lift_map = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3016,(1),null); +if(cljs.core.truth_(ns)){ +return cljs.core.print_prefix_map(["#:",cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns)].join(''),lift_map,print_one,writer,opts); +} else { +return cljs.core.print_prefix_map(null,m,print_one,writer,opts); +} +}); +cljs.core.Volatile.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Volatile.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (a,writer,opts){ +var a__$1 = this; +cljs.core._write(writer,"#object [cljs.core.Volatile "); + +cljs.core.pr_writer(new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$val,a__$1.state], null),writer,opts); + +return cljs.core._write(writer,"]"); +}); + +cljs.core.Var.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Var.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (a,writer,opts){ +var a__$1 = this; +cljs.core._write(writer,"#'"); + +return cljs.core.pr_writer(a__$1.sym,writer,opts); +}); + +cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.MapEntry.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.MapEntry.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"["," ","]",opts,coll__$1); +}); + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.BlackNode.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.BlackNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"["," ","]",opts,coll__$1); +}); + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.ES6IteratorSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ES6IteratorSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"#{"," ","}",opts,coll__$1); +}); + +cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts); +}); + +cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.Iterate.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Iterate.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts); +}); + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"["," ","]",opts,coll__$1); +}); + +cljs.core.Cycle.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Cycle.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts); +}); + +cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"#{"," ","}",opts,coll__$1); +}); + +cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.Atom.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Atom.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (a,writer,opts){ +var a__$1 = this; +cljs.core._write(writer,"#object [cljs.core.Atom "); + +cljs.core.pr_writer(new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$val,a__$1.state], null),writer,opts); + +return cljs.core._write(writer,"]"); +}); + +cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"["," ","]",opts,coll__$1); +}); + +cljs.core.Repeat.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Repeat.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"["," ","]",opts,coll__$1); +}); + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentQueueSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core._write(writer,"()"); +}); + +cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"#queue ["," ","]",opts,cljs.core.seq(coll__$1)); +}); + +cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.print_map(coll__$1,cljs.core.pr_writer,writer,opts); +}); + +cljs.core.Range.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Range.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.TransformerIterator.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.TransformerIterator.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); + +cljs.core.List.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.List.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$1); +}); +cljs.core.Symbol.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Symbol.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if((y instanceof cljs.core.Symbol)){ +return cljs.core.compare_symbols(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); + +cljs.core.Keyword.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Keyword.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if((y instanceof cljs.core.Keyword)){ +return cljs.core.compare_keywords(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); + +cljs.core.Subvec.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.Subvec.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if(cljs.core.vector_QMARK_(y)){ +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); + +cljs.core.PersistentVector.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.PersistentVector.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if(cljs.core.vector_QMARK_(y)){ +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); + +cljs.core.MapEntry.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.MapEntry.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if(cljs.core.vector_QMARK_(y)){ +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); + +cljs.core.BlackNode.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.BlackNode.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if(cljs.core.vector_QMARK_(y)){ +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); + +cljs.core.RedNode.prototype.cljs$core$IComparable$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.RedNode.prototype.cljs$core$IComparable$_compare$arity$2 = (function (x,y){ +var x__$1 = this; +if(cljs.core.vector_QMARK_(y)){ +return cljs.core.compare_indexed.cljs$core$IFn$_invoke$arity$2(x__$1,y); +} else { +throw (new Error(["Cannot compare ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)," to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(y)].join(''))); +} +}); +/** + * Atomically sets the metadata for a namespace/var/ref/agent/atom to be: + * + * (apply f its-current-meta args) + * + * f must be free of side-effects + */ +cljs.core.alter_meta_BANG_ = (function cljs$core$alter_meta_BANG_(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___3022 = arguments.length; +var i__4519__auto___3023 = (0); +while(true){ +if((i__4519__auto___3023 < len__4518__auto___3022)){ +args__4521__auto__.push((arguments[i__4519__auto___3023])); + +var G__3024 = (i__4519__auto___3023 + (1)); +i__4519__auto___3023 = G__3024; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((2) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((2)),(0),null)):null); +return cljs.core.alter_meta_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4522__auto__); +}); + +cljs.core.alter_meta_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (iref,f,args){ +return iref.meta = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,iref.meta,args); +}); + +cljs.core.alter_meta_BANG_.cljs$lang$maxFixedArity = (2); + +/** @this {Function} */ +cljs.core.alter_meta_BANG_.cljs$lang$applyTo = (function (seq3019){ +var G__3020 = cljs.core.first(seq3019); +var seq3019__$1 = cljs.core.next(seq3019); +var G__3021 = cljs.core.first(seq3019__$1); +var seq3019__$2 = cljs.core.next(seq3019__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__3020,G__3021,seq3019__$2); +}); + +/** + * Atomically resets the metadata for an atom + */ +cljs.core.reset_meta_BANG_ = (function cljs$core$reset_meta_BANG_(iref,m){ +return iref.meta = m; +}); +/** + * Adds a watch function to an atom reference. The watch fn must be a + * fn of 4 args: a key, the reference, its old-state, its + * new-state. Whenever the reference's state might have been changed, + * any registered watches will have their functions called. The watch + * fn will be called synchronously. Note that an atom's state + * may have changed again prior to the fn call, so use old/new-state + * rather than derefing the reference. Keys must be unique per + * reference, and can be used to remove the watch with remove-watch, + * but are otherwise considered opaque by the watch mechanism. Bear in + * mind that regardless of the result or action of the watch fns the + * atom's value will change. Example: + * + * (def a (atom 0)) + * (add-watch a :inc (fn [k r o n] (assert (== 0 n)))) + * (swap! a inc) + * ;; Assertion Error + * (deref a) + * ;=> 1 + */ +cljs.core.add_watch = (function cljs$core$add_watch(iref,key,f){ +cljs.core._add_watch(iref,key,f); + +return iref; +}); +/** + * Removes a watch (set by add-watch) from a reference + */ +cljs.core.remove_watch = (function cljs$core$remove_watch(iref,key){ +cljs.core._remove_watch(iref,key); + +return iref; +}); +/** + * @type {*} + */ +cljs.core.gensym_counter = null; +/** + * Returns a new symbol with a unique name. If a prefix string is + * supplied, the name is prefix# where # is some unique number. If + * prefix is not supplied, the prefix is 'G__'. + */ +cljs.core.gensym = (function cljs$core$gensym(var_args){ +var G__3026 = arguments.length; +switch (G__3026) { +case 0: +return cljs.core.gensym.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.gensym.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.gensym.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.gensym.cljs$core$IFn$_invoke$arity$1("G__"); +}); + +cljs.core.gensym.cljs$core$IFn$_invoke$arity$1 = (function (prefix_string){ +if((cljs.core.gensym_counter == null)){ +cljs.core.gensym_counter = cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)); +} else { +} + +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(prefix_string),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(cljs.core.gensym_counter,cljs.core.inc))].join('')); +}); + +cljs.core.gensym.cljs$lang$maxFixedArity = 1; + + +/** +* @constructor + * @implements {cljs.core.IPending} + * @implements {cljs.core.IDeref} +*/ +cljs.core.Delay = (function (f,value){ +this.f = f; +this.value = value; +this.cljs$lang$protocol_mask$partition0$ = 32768; +this.cljs$lang$protocol_mask$partition1$ = 1; +}); +cljs.core.Delay.prototype.cljs$core$IDeref$_deref$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +if(cljs.core.truth_(self__.f)){ +self__.value = (self__.f.cljs$core$IFn$_invoke$arity$0 ? self__.f.cljs$core$IFn$_invoke$arity$0() : self__.f.call(null)); + +self__.f = null; +} else { +} + +return self__.value; +}); + +cljs.core.Delay.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = (function (x){ +var self__ = this; +var x__$1 = this; +return cljs.core.not(self__.f); +}); + +cljs.core.Delay.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$f,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$value,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.Delay.cljs$lang$type = true; + +cljs.core.Delay.cljs$lang$ctorStr = "cljs.core/Delay"; + +cljs.core.Delay.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Delay"); +}); + +/** + * Positional factory function for cljs.core/Delay. + */ +cljs.core.__GT_Delay = (function cljs$core$__GT_Delay(f,value){ +return (new cljs.core.Delay(f,value)); +}); + +/** + * returns true if x is a Delay created with delay + */ +cljs.core.delay_QMARK_ = (function cljs$core$delay_QMARK_(x){ +return (x instanceof cljs.core.Delay); +}); +/** + * If x is a Delay, returns the (possibly cached) value of its expression, else returns x + */ +cljs.core.force = (function cljs$core$force(x){ +if(cljs.core.delay_QMARK_(x)){ +return cljs.core.deref(x); +} else { +return x; +} +}); +/** + * Returns true if a value has been produced for a delay or lazy sequence. + */ +cljs.core.realized_QMARK_ = (function cljs$core$realized_QMARK_(x){ +return cljs.core._realized_QMARK_(x); +}); +cljs.core.preserving_reduced = (function cljs$core$preserving_reduced(rf){ +return (function (p1__3028_SHARP_,p2__3029_SHARP_){ +var ret = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(p1__3028_SHARP_,p2__3029_SHARP_) : rf.call(null,p1__3028_SHARP_,p2__3029_SHARP_)); +if(cljs.core.reduced_QMARK_(ret)){ +return cljs.core.reduced(ret); +} else { +return ret; +} +}); +}); +/** + * A transducer which concatenates the contents of each input, which must be a + * collection, into the reduction. + */ +cljs.core.cat = (function cljs$core$cat(rf){ +var rf1 = cljs.core.preserving_reduced(rf); +return ((function (rf1){ +return (function() { +var G__3030 = null; +var G__3030__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__3030__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__3030__2 = (function (result,input){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(rf1,result,input); +}); +G__3030 = function(result,input){ +switch(arguments.length){ +case 0: +return G__3030__0.call(this); +case 1: +return G__3030__1.call(this,result); +case 2: +return G__3030__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__3030.cljs$core$IFn$_invoke$arity$0 = G__3030__0; +G__3030.cljs$core$IFn$_invoke$arity$1 = G__3030__1; +G__3030.cljs$core$IFn$_invoke$arity$2 = G__3030__2; +return G__3030; +})() +;})(rf1)) +}); +/** + * Returns a transducer that ends transduction when pred returns true + * for an input. When retf is supplied it must be a fn of 2 arguments - + * it will be passed the (completed) result so far and the input that + * triggered the predicate, and its return value (if it does not throw + * an exception) will be the return value of the transducer. If retf + * is not supplied, the input that triggered the predicate will be + * returned. If the predicate never returns true the transduction is + * unaffected. + */ +cljs.core.halt_when = (function cljs$core$halt_when(var_args){ +var G__3032 = arguments.length; +switch (G__3032) { +case 1: +return cljs.core.halt_when.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.halt_when.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.halt_when.cljs$core$IFn$_invoke$arity$1 = (function (pred){ +return cljs.core.halt_when.cljs$core$IFn$_invoke$arity$2(pred,null); +}); + +cljs.core.halt_when.cljs$core$IFn$_invoke$arity$2 = (function (pred,retf){ +return (function (rf){ +return (function() { +var G__3036 = null; +var G__3036__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__3036__1 = (function (result){ +if(((cljs.core.map_QMARK_(result)) && (cljs.core.contains_QMARK_(result,cljs.core.cst$kw$cljs$core_SLASH_halt)))){ +return cljs.core.cst$kw$cljs$core_SLASH_halt.cljs$core$IFn$_invoke$arity$1(result); +} else { +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +} +}); +var G__3036__2 = (function (result,input){ +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(input) : pred.call(null,input)))){ +return cljs.core.reduced(new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$cljs$core_SLASH_halt,(cljs.core.truth_(retf)?(function (){var G__3033 = (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +var G__3034 = input; +return (retf.cljs$core$IFn$_invoke$arity$2 ? retf.cljs$core$IFn$_invoke$arity$2(G__3033,G__3034) : retf.call(null,G__3033,G__3034)); +})():input)], null)); +} else { +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} +}); +G__3036 = function(result,input){ +switch(arguments.length){ +case 0: +return G__3036__0.call(this); +case 1: +return G__3036__1.call(this,result); +case 2: +return G__3036__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__3036.cljs$core$IFn$_invoke$arity$0 = G__3036__0; +G__3036.cljs$core$IFn$_invoke$arity$1 = G__3036__1; +G__3036.cljs$core$IFn$_invoke$arity$2 = G__3036__2; +return G__3036; +})() +}); +}); + +cljs.core.halt_when.cljs$lang$maxFixedArity = 2; + +/** + * Returns a lazy sequence removing consecutive duplicates in coll. + * Returns a transducer when no collection is provided. + */ +cljs.core.dedupe = (function cljs$core$dedupe(var_args){ +var G__3038 = arguments.length; +switch (G__3038) { +case 0: +return cljs.core.dedupe.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.dedupe.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.dedupe.cljs$core$IFn$_invoke$arity$0 = (function (){ +return (function (rf){ +var pa = cljs.core.volatile_BANG_(cljs.core.cst$kw$cljs$core_SLASH_none); +return ((function (pa){ +return (function() { +var G__3040 = null; +var G__3040__0 = (function (){ +return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null)); +}); +var G__3040__1 = (function (result){ +return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null,result)); +}); +var G__3040__2 = (function (result,input){ +var prior = cljs.core.deref(pa); +cljs.core.vreset_BANG_(pa,input); + +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(prior,input)){ +return result; +} else { +return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,input) : rf.call(null,result,input)); +} +}); +G__3040 = function(result,input){ +switch(arguments.length){ +case 0: +return G__3040__0.call(this); +case 1: +return G__3040__1.call(this,result); +case 2: +return G__3040__2.call(this,result,input); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__3040.cljs$core$IFn$_invoke$arity$0 = G__3040__0; +G__3040.cljs$core$IFn$_invoke$arity$1 = G__3040__1; +G__3040.cljs$core$IFn$_invoke$arity$2 = G__3040__2; +return G__3040; +})() +;})(pa)) +}); +}); + +cljs.core.dedupe.cljs$core$IFn$_invoke$arity$1 = (function (coll){ +return cljs.core.sequence.cljs$core$IFn$_invoke$arity$2(cljs.core.dedupe.cljs$core$IFn$_invoke$arity$0(),coll); +}); + +cljs.core.dedupe.cljs$lang$maxFixedArity = 1; + +/** + * Returns items from coll with random probability of prob (0.0 - + * 1.0). Returns a transducer when no collection is provided. + */ +cljs.core.random_sample = (function cljs$core$random_sample(var_args){ +var G__3042 = arguments.length; +switch (G__3042) { +case 1: +return cljs.core.random_sample.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.random_sample.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.random_sample.cljs$core$IFn$_invoke$arity$1 = (function (prob){ +return cljs.core.filter.cljs$core$IFn$_invoke$arity$1((function (_){ +return (cljs.core.rand.cljs$core$IFn$_invoke$arity$0() < prob); +})); +}); + +cljs.core.random_sample.cljs$core$IFn$_invoke$arity$2 = (function (prob,coll){ +return cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (_){ +return (cljs.core.rand.cljs$core$IFn$_invoke$arity$0() < prob); +}),coll); +}); + +cljs.core.random_sample.cljs$lang$maxFixedArity = 2; + + +/** +* @constructor + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IPrintWithWriter} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.ISequential} + * @implements {cljs.core.IReduce} +*/ +cljs.core.Eduction = (function (xform,coll){ +this.xform = xform; +this.coll = coll; +this.cljs$lang$protocol_mask$partition0$ = 2173173760; +this.cljs$lang$protocol_mask$partition1$ = 131072; +}); +cljs.core.Eduction.prototype.indexOf = (function() { +var G__3044 = null; +var G__3044__1 = (function (x){ +var self__ = this; +var coll__$1 = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,(0)); +}); +var G__3044__2 = (function (x,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core._indexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,start); +}); +G__3044 = function(x,start){ +switch(arguments.length){ +case 1: +return G__3044__1.call(this,x); +case 2: +return G__3044__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__3044.cljs$core$IFn$_invoke$arity$1 = G__3044__1; +G__3044.cljs$core$IFn$_invoke$arity$2 = G__3044__2; +return G__3044; +})() +; + +cljs.core.Eduction.prototype.lastIndexOf = (function() { +var G__3045 = null; +var G__3045__1 = (function (x){ +var self__ = this; +var coll__$1 = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,cljs.core.count(coll__$1)); +}); +var G__3045__2 = (function (x,start){ +var self__ = this; +var coll__$1 = this; +return cljs.core._lastIndexOf.cljs$core$IFn$_invoke$arity$3(coll__$1,x,start); +}); +G__3045 = function(x,start){ +switch(arguments.length){ +case 1: +return G__3045__1.call(this,x); +case 2: +return G__3045__2.call(this,x,start); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__3045.cljs$core$IFn$_invoke$arity$1 = G__3045__1; +G__3045.cljs$core$IFn$_invoke$arity$2 = G__3045__2; +return G__3045; +})() +; + +cljs.core.Eduction.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return cljs.core.TransformerIterator.create(self__.xform,cljs.core.iter(self__.coll)); +}); + +cljs.core.Eduction.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return cljs.core.seq(cljs.core.sequence.cljs$core$IFn$_invoke$arity$2(self__.xform,self__.coll)); +}); + +cljs.core.Eduction.prototype.cljs$core$IReduce$_reduce$arity$2 = (function (_,f){ +var self__ = this; +var ___$1 = this; +return cljs.core.transduce.cljs$core$IFn$_invoke$arity$3(self__.xform,cljs.core.completing.cljs$core$IFn$_invoke$arity$1(f),self__.coll); +}); + +cljs.core.Eduction.prototype.cljs$core$IReduce$_reduce$arity$3 = (function (_,f,init){ +var self__ = this; +var ___$1 = this; +return cljs.core.transduce.cljs$core$IFn$_invoke$arity$4(self__.xform,cljs.core.completing.cljs$core$IFn$_invoke$arity$1(f),init,self__.coll); +}); + +cljs.core.Eduction.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll__$1,writer,opts){ +var self__ = this; +var coll__$2 = this; +return cljs.core.pr_sequential_writer(writer,cljs.core.pr_writer,"("," ",")",opts,coll__$2); +}); + +cljs.core.Eduction.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$xform,cljs.core.cst$sym$coll], null); +}); + +cljs.core.Eduction.cljs$lang$type = true; + +cljs.core.Eduction.cljs$lang$ctorStr = "cljs.core/Eduction"; + +cljs.core.Eduction.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Eduction"); +}); + +/** + * Positional factory function for cljs.core/Eduction. + */ +cljs.core.__GT_Eduction = (function cljs$core$__GT_Eduction(xform,coll){ +return (new cljs.core.Eduction(xform,coll)); +}); + +var G__3046_3049 = cljs.core.Eduction.prototype; +var G__3047_3050 = cljs.core.ITER_SYMBOL; +var G__3048_3051 = ((function (G__3046_3049,G__3047_3050){ +return (function (){ +var this__4457__auto__ = this; +return cljs.core.es6_iterator(this__4457__auto__); +});})(G__3046_3049,G__3047_3050)) +; +goog.object.set(G__3046_3049,G__3047_3050,G__3048_3051); +/** + * Returns a reducible/iterable application of the transducers + * to the items in coll. Transducers are applied in order as if + * combined with comp. Note that these applications will be + * performed every time reduce/iterator is called. + */ +cljs.core.eduction = (function cljs$core$eduction(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___3053 = arguments.length; +var i__4519__auto___3054 = (0); +while(true){ +if((i__4519__auto___3054 < len__4518__auto___3053)){ +args__4521__auto__.push((arguments[i__4519__auto___3054])); + +var G__3055 = (i__4519__auto___3054 + (1)); +i__4519__auto___3054 = G__3055; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((0) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((0)),(0),null)):null); +return cljs.core.eduction.cljs$core$IFn$_invoke$arity$variadic(argseq__4522__auto__); +}); + +cljs.core.eduction.cljs$core$IFn$_invoke$arity$variadic = (function (xforms){ +return (new cljs.core.Eduction(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.comp,cljs.core.butlast(xforms)),cljs.core.last(xforms))); +}); + +cljs.core.eduction.cljs$lang$maxFixedArity = (0); + +/** @this {Function} */ +cljs.core.eduction.cljs$lang$applyTo = (function (seq3052){ +var self__4506__auto__ = this; +return self__4506__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq3052)); +}); + +/** + * Runs the supplied procedure (via reduce), for purposes of side + * effects, on successive items in the collection. Returns nil + */ +cljs.core.run_BANG_ = (function cljs$core$run_BANG_(proc,coll){ +cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__3057_SHARP_,p2__3056_SHARP_){ +return (proc.cljs$core$IFn$_invoke$arity$1 ? proc.cljs$core$IFn$_invoke$arity$1(p2__3056_SHARP_) : proc.call(null,p2__3056_SHARP_)); +}),null,coll); + +return null; +}); + +/** + * @interface + */ +cljs.core.IEncodeJS = function(){}; + +/** + * Recursively transforms clj values to JavaScript + */ +cljs.core._clj__GT_js = (function cljs$core$_clj__GT_js(x){ +if(((!((x == null))) && (!((x.cljs$core$IEncodeJS$_clj__GT_js$arity$1 == null))))){ +return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._clj__GT_js[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto__.call(null,x)); +} else { +var m__4231__auto____$1 = (cljs.core._clj__GT_js["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto____$1.call(null,x)); +} else { +throw cljs.core.missing_protocol("IEncodeJS.-clj->js",x); +} +} +} +}); + +/** + * Transforms map keys to valid JavaScript keys. Arbitrary keys are + * encoded to their string representation via (pr-str x) + */ +cljs.core._key__GT_js = (function cljs$core$_key__GT_js(x){ +if(((!((x == null))) && (!((x.cljs$core$IEncodeJS$_key__GT_js$arity$1 == null))))){ +return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._key__GT_js[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto__.call(null,x)); +} else { +var m__4231__auto____$1 = (cljs.core._key__GT_js["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(x) : m__4231__auto____$1.call(null,x)); +} else { +throw cljs.core.missing_protocol("IEncodeJS.-key->js",x); +} +} +} +}); + +cljs.core.key__GT_js = (function cljs$core$key__GT_js(var_args){ +var G__3059 = arguments.length; +switch (G__3059) { +case 1: +return cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$1 = (function (k){ +return cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2(k,cljs.core.clj__GT_js); +}); + +cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2 = (function (k,primitive_fn){ +if(((!((k == null)))?((((false) || ((cljs.core.PROTOCOL_SENTINEL === k.cljs$core$IEncodeJS$))))?true:(((!k.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,k):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,k))){ +return cljs.core._clj__GT_js(k); +} else { +if(((typeof k === 'string') || (typeof k === 'number') || ((k instanceof cljs.core.Keyword)) || ((k instanceof cljs.core.Symbol)))){ +return (primitive_fn.cljs$core$IFn$_invoke$arity$1 ? primitive_fn.cljs$core$IFn$_invoke$arity$1(k) : primitive_fn.call(null,k)); +} else { +return cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([k], 0)); + +} +} +}); + +cljs.core.key__GT_js.cljs$lang$maxFixedArity = 2; + +/** + * Recursively transforms ClojureScript values to JavaScript. + * sets/vectors/lists become Arrays, Keywords and Symbol become Strings, + * Maps become Objects. Arbitrary keys are encoded to by `key->js`. + * Options is a key-value pair, where the only valid key is + * :keyword-fn, which should point to a single-argument function to be + * called on keyword keys. Default to `name`. + */ +cljs.core.clj__GT_js = (function cljs$core$clj__GT_js(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___3113 = arguments.length; +var i__4519__auto___3114 = (0); +while(true){ +if((i__4519__auto___3114 < len__4518__auto___3113)){ +args__4521__auto__.push((arguments[i__4519__auto___3114])); + +var G__3115 = (i__4519__auto___3114 + (1)); +i__4519__auto___3114 = G__3115; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.core.clj__GT_js.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.core.clj__GT_js.cljs$core$IFn$_invoke$arity$variadic = (function (x,p__3064){ +var map__3065 = p__3064; +var map__3065__$1 = ((((!((map__3065 == null)))?(((((map__3065.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === map__3065.cljs$core$ISeq$))))?true:false):false))?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,map__3065):map__3065); +var options = map__3065__$1; +var keyword_fn = cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__3065__$1,cljs.core.cst$kw$keyword_DASH_fn,cljs.core.name); +var keyfn = ((function (map__3065,map__3065__$1,options,keyword_fn){ +return (function cljs$core$keyfn(k){ +return cljs.core.key__GT_js.cljs$core$IFn$_invoke$arity$2(k,thisfn); +});})(map__3065,map__3065__$1,options,keyword_fn)) +; +var thisfn = ((function (map__3065,map__3065__$1,options,keyword_fn){ +return (function cljs$core$thisfn(x__$1){ +if((x__$1 == null)){ +return null; +} else { +if(((!((x__$1 == null)))?((((false) || ((cljs.core.PROTOCOL_SENTINEL === x__$1.cljs$core$IEncodeJS$))))?true:(((!x__$1.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,x__$1):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeJS,x__$1))){ +return cljs.core._clj__GT_js(x__$1); +} else { +if((x__$1 instanceof cljs.core.Keyword)){ +return (keyword_fn.cljs$core$IFn$_invoke$arity$1 ? keyword_fn.cljs$core$IFn$_invoke$arity$1(x__$1) : keyword_fn.call(null,x__$1)); +} else { +if((x__$1 instanceof cljs.core.Symbol)){ +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(x__$1)].join(''); +} else { +if(cljs.core.map_QMARK_(x__$1)){ +var m = {}; +var seq__3093_3116 = cljs.core.seq(x__$1); +var chunk__3094_3117 = null; +var count__3095_3118 = (0); +var i__3096_3119 = (0); +while(true){ +if((i__3096_3119 < count__3095_3118)){ +var vec__3097_3120 = chunk__3094_3117.cljs$core$IIndexed$_nth$arity$2(null,i__3096_3119); +var k_3121 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3097_3120,(0),null); +var v_3122 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3097_3120,(1),null); +var G__3100_3123 = m; +var G__3101_3124 = keyfn(k_3121); +var G__3102_3125 = cljs$core$thisfn(v_3122); +goog.object.set(G__3100_3123,G__3101_3124,G__3102_3125); + + +var G__3126 = seq__3093_3116; +var G__3127 = chunk__3094_3117; +var G__3128 = count__3095_3118; +var G__3129 = (i__3096_3119 + (1)); +seq__3093_3116 = G__3126; +chunk__3094_3117 = G__3127; +count__3095_3118 = G__3128; +i__3096_3119 = G__3129; +continue; +} else { +var temp__5457__auto___3130 = cljs.core.seq(seq__3093_3116); +if(temp__5457__auto___3130){ +var seq__3093_3131__$1 = temp__5457__auto___3130; +if(cljs.core.chunked_seq_QMARK_(seq__3093_3131__$1)){ +var c__4338__auto___3132 = cljs.core.chunk_first(seq__3093_3131__$1); +var G__3133 = cljs.core.chunk_rest(seq__3093_3131__$1); +var G__3134 = c__4338__auto___3132; +var G__3135 = cljs.core.count(c__4338__auto___3132); +var G__3136 = (0); +seq__3093_3116 = G__3133; +chunk__3094_3117 = G__3134; +count__3095_3118 = G__3135; +i__3096_3119 = G__3136; +continue; +} else { +var vec__3103_3137 = cljs.core.first(seq__3093_3131__$1); +var k_3138 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3103_3137,(0),null); +var v_3139 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3103_3137,(1),null); +var G__3106_3140 = m; +var G__3107_3141 = keyfn(k_3138); +var G__3108_3142 = cljs$core$thisfn(v_3139); +goog.object.set(G__3106_3140,G__3107_3141,G__3108_3142); + + +var G__3143 = cljs.core.next(seq__3093_3131__$1); +var G__3144 = null; +var G__3145 = (0); +var G__3146 = (0); +seq__3093_3116 = G__3143; +chunk__3094_3117 = G__3144; +count__3095_3118 = G__3145; +i__3096_3119 = G__3146; +continue; +} +} else { +} +} +break; +} + +return m; +} else { +if(cljs.core.coll_QMARK_(x__$1)){ +var arr = []; +var seq__3109_3147 = cljs.core.seq(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs$core$thisfn,x__$1)); +var chunk__3110_3148 = null; +var count__3111_3149 = (0); +var i__3112_3150 = (0); +while(true){ +if((i__3112_3150 < count__3111_3149)){ +var x_3151__$2 = chunk__3110_3148.cljs$core$IIndexed$_nth$arity$2(null,i__3112_3150); +arr.push(x_3151__$2); + + +var G__3152 = seq__3109_3147; +var G__3153 = chunk__3110_3148; +var G__3154 = count__3111_3149; +var G__3155 = (i__3112_3150 + (1)); +seq__3109_3147 = G__3152; +chunk__3110_3148 = G__3153; +count__3111_3149 = G__3154; +i__3112_3150 = G__3155; +continue; +} else { +var temp__5457__auto___3156 = cljs.core.seq(seq__3109_3147); +if(temp__5457__auto___3156){ +var seq__3109_3157__$1 = temp__5457__auto___3156; +if(cljs.core.chunked_seq_QMARK_(seq__3109_3157__$1)){ +var c__4338__auto___3158 = cljs.core.chunk_first(seq__3109_3157__$1); +var G__3159 = cljs.core.chunk_rest(seq__3109_3157__$1); +var G__3160 = c__4338__auto___3158; +var G__3161 = cljs.core.count(c__4338__auto___3158); +var G__3162 = (0); +seq__3109_3147 = G__3159; +chunk__3110_3148 = G__3160; +count__3111_3149 = G__3161; +i__3112_3150 = G__3162; +continue; +} else { +var x_3163__$2 = cljs.core.first(seq__3109_3157__$1); +arr.push(x_3163__$2); + + +var G__3164 = cljs.core.next(seq__3109_3157__$1); +var G__3165 = null; +var G__3166 = (0); +var G__3167 = (0); +seq__3109_3147 = G__3164; +chunk__3110_3148 = G__3165; +count__3111_3149 = G__3166; +i__3112_3150 = G__3167; +continue; +} +} else { +} +} +break; +} + +return arr; +} else { +return x__$1; + +} +} +} +} +} +} +});})(map__3065,map__3065__$1,options,keyword_fn)) +; +return thisfn(x); +}); + +cljs.core.clj__GT_js.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.core.clj__GT_js.cljs$lang$applyTo = (function (seq3062){ +var G__3063 = cljs.core.first(seq3062); +var seq3062__$1 = cljs.core.next(seq3062); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__3063,seq3062__$1); +}); + + +/** + * @interface + */ +cljs.core.IEncodeClojure = function(){}; + +/** + * Transforms JavaScript values to Clojure + */ +cljs.core._js__GT_clj = (function cljs$core$_js__GT_clj(x,options){ +if(((!((x == null))) && (!((x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2 == null))))){ +return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x,options); +} else { +var x__4230__auto__ = (((x == null))?null:x); +var m__4231__auto__ = (cljs.core._js__GT_clj[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(x,options) : m__4231__auto__.call(null,x,options)); +} else { +var m__4231__auto____$1 = (cljs.core._js__GT_clj["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(x,options) : m__4231__auto____$1.call(null,x,options)); +} else { +throw cljs.core.missing_protocol("IEncodeClojure.-js->clj",x); +} +} +} +}); + +/** + * Recursively transforms JavaScript arrays into ClojureScript + * vectors, and JavaScript objects into ClojureScript maps. With + * option ':keywordize-keys true' will convert object fields from + * strings to keywords. + */ +cljs.core.js__GT_clj = (function cljs$core$js__GT_clj(var_args){ +var G__3171 = arguments.length; +switch (G__3171) { +case 1: +return cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___3180 = arguments.length; +var i__4519__auto___3181 = (0); +while(true){ +if((i__4519__auto___3181 < len__4518__auto___3180)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___3181])); + +var G__3182 = (i__4519__auto___3181 + (1)); +i__4519__auto___3181 = G__3182; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((1)),(0),null)); +return cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4534__auto__); + +} +}); + +cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$variadic(x,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$keywordize_DASH_keys,false], 0)); +}); + +cljs.core.js__GT_clj.cljs$core$IFn$_invoke$arity$variadic = (function (x,opts){ +var map__3172 = opts; +var map__3172__$1 = ((((!((map__3172 == null)))?(((((map__3172.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === map__3172.cljs$core$ISeq$))))?true:false):false))?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,map__3172):map__3172); +var keywordize_keys = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__3172__$1,cljs.core.cst$kw$keywordize_DASH_keys); +var keyfn = (cljs.core.truth_(keywordize_keys)?cljs.core.keyword:cljs.core.str); +var f = ((function (map__3172,map__3172__$1,keywordize_keys,keyfn){ +return (function cljs$core$thisfn(x__$1){ +if(((!((x__$1 == null)))?((((false) || ((cljs.core.PROTOCOL_SENTINEL === x__$1.cljs$core$IEncodeClojure$))))?true:(((!x__$1.cljs$lang$protocol_mask$partition$))?cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeClojure,x__$1):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IEncodeClojure,x__$1))){ +return cljs.core._js__GT_clj(x__$1,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.array_map,opts)); +} else { +if(cljs.core.seq_QMARK_(x__$1)){ +return cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs$core$thisfn,x__$1)); +} else { +if(cljs.core.map_entry_QMARK_(x__$1)){ +return (new cljs.core.MapEntry(cljs$core$thisfn(cljs.core.key(x__$1)),cljs$core$thisfn(cljs.core.val(x__$1)),null)); +} else { +if(cljs.core.coll_QMARK_(x__$1)){ +return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.empty(x__$1),cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs$core$thisfn,x__$1)); +} else { +if(cljs.core.array_QMARK_(x__$1)){ +return cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs$core$thisfn,x__$1)); +} else { +if((cljs.core.type(x__$1) === Object)){ +return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,(function (){var iter__4311__auto__ = ((function (map__3172,map__3172__$1,keywordize_keys,keyfn){ +return (function cljs$core$thisfn_$_iter__3175(s__3176){ +return (new cljs.core.LazySeq(null,((function (map__3172,map__3172__$1,keywordize_keys,keyfn){ +return (function (){ +var s__3176__$1 = s__3176; +while(true){ +var temp__5457__auto__ = cljs.core.seq(s__3176__$1); +if(temp__5457__auto__){ +var s__3176__$2 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s__3176__$2)){ +var c__4309__auto__ = cljs.core.chunk_first(s__3176__$2); +var size__4310__auto__ = cljs.core.count(c__4309__auto__); +var b__3178 = cljs.core.chunk_buffer(size__4310__auto__); +if((function (){var i__3177 = (0); +while(true){ +if((i__3177 < size__4310__auto__)){ +var k = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c__4309__auto__,i__3177); +cljs.core.chunk_append(b__3178,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(k) : keyfn.call(null,k)),cljs$core$thisfn((x__$1[k]))], null)); + +var G__3183 = (i__3177 + (1)); +i__3177 = G__3183; +continue; +} else { +return true; +} +break; +} +})()){ +return cljs.core.chunk_cons(cljs.core.chunk(b__3178),cljs$core$thisfn_$_iter__3175(cljs.core.chunk_rest(s__3176__$2))); +} else { +return cljs.core.chunk_cons(cljs.core.chunk(b__3178),null); +} +} else { +var k = cljs.core.first(s__3176__$2); +return cljs.core.cons(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(keyfn.cljs$core$IFn$_invoke$arity$1 ? keyfn.cljs$core$IFn$_invoke$arity$1(k) : keyfn.call(null,k)),cljs$core$thisfn((x__$1[k]))], null),cljs$core$thisfn_$_iter__3175(cljs.core.rest(s__3176__$2))); +} +} else { +return null; +} +break; +} +});})(map__3172,map__3172__$1,keywordize_keys,keyfn)) +,null,null)); +});})(map__3172,map__3172__$1,keywordize_keys,keyfn)) +; +return iter__4311__auto__(cljs.core.js_keys(x__$1)); +})()); +} else { +return x__$1; + +} +} +} +} +} +} +});})(map__3172,map__3172__$1,keywordize_keys,keyfn)) +; +return f(x); +}); + +/** @this {Function} */ +cljs.core.js__GT_clj.cljs$lang$applyTo = (function (seq3169){ +var G__3170 = cljs.core.first(seq3169); +var seq3169__$1 = cljs.core.next(seq3169); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__3170,seq3169__$1); +}); + +cljs.core.js__GT_clj.cljs$lang$maxFixedArity = (1); + +/** + * Returns a memoized version of a referentially transparent function. The + * memoized version of the function keeps a cache of the mapping from arguments + * to results and, when calls with the same arguments are repeated often, has + * higher performance at the expense of higher memory use. + */ +cljs.core.memoize = (function cljs$core$memoize(f){ +var mem = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +return ((function (mem){ +return (function() { +var G__3184__delegate = function (args){ +var v = cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(mem),args,cljs.core.lookup_sentinel); +if((v === cljs.core.lookup_sentinel)){ +var ret = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,args); +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(mem,cljs.core.assoc,args,ret); + +return ret; +} else { +return v; +} +}; +var G__3184 = function (var_args){ +var args = null; +if (arguments.length > 0) { +var G__3185__i = 0, G__3185__a = new Array(arguments.length - 0); +while (G__3185__i < G__3185__a.length) {G__3185__a[G__3185__i] = arguments[G__3185__i + 0]; ++G__3185__i;} + args = new cljs.core.IndexedSeq(G__3185__a,0,null); +} +return G__3184__delegate.call(this,args);}; +G__3184.cljs$lang$maxFixedArity = 0; +G__3184.cljs$lang$applyTo = (function (arglist__3186){ +var args = cljs.core.seq(arglist__3186); +return G__3184__delegate(args); +}); +G__3184.cljs$core$IFn$_invoke$arity$variadic = G__3184__delegate; +return G__3184; +})() +; +;})(mem)) +}); +/** + * trampoline can be used to convert algorithms requiring mutual + * recursion without stack consumption. Calls f with supplied args, if + * any. If f returns a fn, calls that fn with no arguments, and + * continues to repeat, until the return value is not a fn, then + * returns that non-fn value. Note that if you want to return a fn as a + * final value, you must wrap it in some data structure and unpack it + * after trampoline returns. + */ +cljs.core.trampoline = (function cljs$core$trampoline(var_args){ +var G__3190 = arguments.length; +switch (G__3190) { +case 1: +return cljs.core.trampoline.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +var args_arr__4533__auto__ = []; +var len__4518__auto___3192 = arguments.length; +var i__4519__auto___3193 = (0); +while(true){ +if((i__4519__auto___3193 < len__4518__auto___3192)){ +args_arr__4533__auto__.push((arguments[i__4519__auto___3193])); + +var G__3194 = (i__4519__auto___3193 + (1)); +i__4519__auto___3193 = G__3194; +continue; +} else { +} +break; +} + +var argseq__4534__auto__ = (new cljs.core.IndexedSeq(args_arr__4533__auto__.slice((1)),(0),null)); +return cljs.core.trampoline.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4534__auto__); + +} +}); + +cljs.core.trampoline.cljs$core$IFn$_invoke$arity$1 = (function (f){ +while(true){ +var ret = (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +if(cljs.core.fn_QMARK_(ret)){ +var G__3195 = ret; +f = G__3195; +continue; +} else { +return ret; +} +break; +} +}); + +cljs.core.trampoline.cljs$core$IFn$_invoke$arity$variadic = (function (f,args){ +return cljs.core.trampoline.cljs$core$IFn$_invoke$arity$1((function (){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,args); +})); +}); + +/** @this {Function} */ +cljs.core.trampoline.cljs$lang$applyTo = (function (seq3188){ +var G__3189 = cljs.core.first(seq3188); +var seq3188__$1 = cljs.core.next(seq3188); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__3189,seq3188__$1); +}); + +cljs.core.trampoline.cljs$lang$maxFixedArity = (1); + +/** + * Returns a random floating point number between 0 (inclusive) and + * n (default 1) (exclusive). + */ +cljs.core.rand = (function cljs$core$rand(var_args){ +var G__3197 = arguments.length; +switch (G__3197) { +case 0: +return cljs.core.rand.cljs$core$IFn$_invoke$arity$0(); + +break; +case 1: +return cljs.core.rand.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.rand.cljs$core$IFn$_invoke$arity$0 = (function (){ +return cljs.core.rand.cljs$core$IFn$_invoke$arity$1((1)); +}); + +cljs.core.rand.cljs$core$IFn$_invoke$arity$1 = (function (n){ +return (Math.random() * n); +}); + +cljs.core.rand.cljs$lang$maxFixedArity = 1; + +/** + * Returns a random integer between 0 (inclusive) and n (exclusive). + */ +cljs.core.rand_int = (function cljs$core$rand_int(n){ +var G__3199 = (Math.random() * n); +return Math.floor(G__3199); +}); +/** + * Return a random element of the (sequential) collection. Will have + * the same performance characteristics as nth for the given + * collection. + */ +cljs.core.rand_nth = (function cljs$core$rand_nth(coll){ +return cljs.core.nth.cljs$core$IFn$_invoke$arity$2(coll,cljs.core.rand_int(cljs.core.count(coll))); +}); +/** + * Returns a map of the elements of coll keyed by the result of + * f on each element. The value at each key will be a vector of the + * corresponding elements, in the order they appeared in coll. + */ +cljs.core.group_by = (function cljs$core$group_by(f,coll){ +return cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (ret,x){ +var k = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null,x)); +return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(ret,k,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(ret,k,cljs.core.PersistentVector.EMPTY),x)); +}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),coll)); +}); +/** + * Creates a hierarchy object for use with derive, isa? etc. + */ +cljs.core.make_hierarchy = (function cljs$core$make_hierarchy(){ +return new cljs.core.PersistentArrayMap(null, 3, [cljs.core.cst$kw$parents,cljs.core.PersistentArrayMap.EMPTY,cljs.core.cst$kw$descendants,cljs.core.PersistentArrayMap.EMPTY,cljs.core.cst$kw$ancestors,cljs.core.PersistentArrayMap.EMPTY], null); +}); +/** + * @type {*} + */ +cljs.core._global_hierarchy = null; +cljs.core.get_global_hierarchy = (function cljs$core$get_global_hierarchy(){ +if((cljs.core._global_hierarchy == null)){ +cljs.core._global_hierarchy = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.make_hierarchy()); +} else { +} + +return cljs.core._global_hierarchy; +}); +cljs.core.swap_global_hierarchy_BANG_ = (function cljs$core$swap_global_hierarchy_BANG_(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___3202 = arguments.length; +var i__4519__auto___3203 = (0); +while(true){ +if((i__4519__auto___3203 < len__4518__auto___3202)){ +args__4521__auto__.push((arguments[i__4519__auto___3203])); + +var G__3204 = (i__4519__auto___3203 + (1)); +i__4519__auto___3203 = G__3204; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (f,args){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$4(cljs.core.swap_BANG_,cljs.core.get_global_hierarchy(),f,args); +}); + +cljs.core.swap_global_hierarchy_BANG_.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.core.swap_global_hierarchy_BANG_.cljs$lang$applyTo = (function (seq3200){ +var G__3201 = cljs.core.first(seq3200); +var seq3200__$1 = cljs.core.next(seq3200); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__3201,seq3200__$1); +}); + +/** + * Returns true if (= child parent), or child is directly or indirectly derived from + * parent, either via a JavaScript type inheritance relationship or a + * relationship established via derive. h must be a hierarchy obtained + * from make-hierarchy, if not supplied defaults to the global + * hierarchy + */ +cljs.core.isa_QMARK_ = (function cljs$core$isa_QMARK_(var_args){ +var G__3206 = arguments.length; +switch (G__3206) { +case 2: +return cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$2 = (function (child,parent){ +return cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(cljs.core.get_global_hierarchy()),child,parent); +}); + +cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3 = (function (h,child,parent){ +var or__3936__auto__ = cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(child,parent); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = cljs.core.contains_QMARK_((function (){var fexpr__3209 = cljs.core.cst$kw$ancestors.cljs$core$IFn$_invoke$arity$1(h); +return (fexpr__3209.cljs$core$IFn$_invoke$arity$1 ? fexpr__3209.cljs$core$IFn$_invoke$arity$1(child) : fexpr__3209.call(null,child)); +})(),parent); +if(or__3936__auto____$1){ +return or__3936__auto____$1; +} else { +var and__3925__auto__ = cljs.core.vector_QMARK_(parent); +if(and__3925__auto__){ +var and__3925__auto____$1 = cljs.core.vector_QMARK_(child); +if(and__3925__auto____$1){ +var and__3925__auto____$2 = (cljs.core.count(parent) === cljs.core.count(child)); +if(and__3925__auto____$2){ +var ret = true; +var i = (0); +while(true){ +if(((!(ret)) || ((i === cljs.core.count(parent))))){ +return ret; +} else { +var G__3211 = cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(h,(child.cljs$core$IFn$_invoke$arity$1 ? child.cljs$core$IFn$_invoke$arity$1(i) : child.call(null,i)),(parent.cljs$core$IFn$_invoke$arity$1 ? parent.cljs$core$IFn$_invoke$arity$1(i) : parent.call(null,i))); +var G__3212 = (i + (1)); +ret = G__3211; +i = G__3212; +continue; +} +break; +} +} else { +return and__3925__auto____$2; +} +} else { +return and__3925__auto____$1; +} +} else { +return and__3925__auto__; +} +} +} +}); + +cljs.core.isa_QMARK_.cljs$lang$maxFixedArity = 3; + +/** + * Returns the immediate parents of tag, either via a JavaScript type + * inheritance relationship or a relationship established via derive. h + * must be a hierarchy obtained from make-hierarchy, if not supplied + * defaults to the global hierarchy + */ +cljs.core.parents = (function cljs$core$parents(var_args){ +var G__3214 = arguments.length; +switch (G__3214) { +case 1: +return cljs.core.parents.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.parents.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.parents.cljs$core$IFn$_invoke$arity$1 = (function (tag){ +return cljs.core.parents.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.get_global_hierarchy()),tag); +}); + +cljs.core.parents.cljs$core$IFn$_invoke$arity$2 = (function (h,tag){ +return cljs.core.not_empty(cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$kw$parents.cljs$core$IFn$_invoke$arity$1(h),tag)); +}); + +cljs.core.parents.cljs$lang$maxFixedArity = 2; + +/** + * Returns the immediate and indirect parents of tag, either via a JavaScript type + * inheritance relationship or a relationship established via derive. h + * must be a hierarchy obtained from make-hierarchy, if not supplied + * defaults to the global hierarchy + */ +cljs.core.ancestors = (function cljs$core$ancestors(var_args){ +var G__3217 = arguments.length; +switch (G__3217) { +case 1: +return cljs.core.ancestors.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.ancestors.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.ancestors.cljs$core$IFn$_invoke$arity$1 = (function (tag){ +return cljs.core.ancestors.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.get_global_hierarchy()),tag); +}); + +cljs.core.ancestors.cljs$core$IFn$_invoke$arity$2 = (function (h,tag){ +return cljs.core.not_empty(cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$kw$ancestors.cljs$core$IFn$_invoke$arity$1(h),tag)); +}); + +cljs.core.ancestors.cljs$lang$maxFixedArity = 2; + +/** + * Returns the immediate and indirect children of tag, through a + * relationship established via derive. h must be a hierarchy obtained + * from make-hierarchy, if not supplied defaults to the global + * hierarchy. Note: does not work on JavaScript type inheritance + * relationships. + */ +cljs.core.descendants = (function cljs$core$descendants(var_args){ +var G__3220 = arguments.length; +switch (G__3220) { +case 1: +return cljs.core.descendants.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.descendants.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.descendants.cljs$core$IFn$_invoke$arity$1 = (function (tag){ +return cljs.core.descendants.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.get_global_hierarchy()),tag); +}); + +cljs.core.descendants.cljs$core$IFn$_invoke$arity$2 = (function (h,tag){ +return cljs.core.not_empty(cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$kw$descendants.cljs$core$IFn$_invoke$arity$1(h),tag)); +}); + +cljs.core.descendants.cljs$lang$maxFixedArity = 2; + +/** + * Establishes a parent/child relationship between parent and + * tag. Parent must be a namespace-qualified symbol or keyword and + * child can be either a namespace-qualified symbol or keyword or a + * class. h must be a hierarchy obtained from make-hierarchy, if not + * supplied defaults to, and modifies, the global hierarchy. + */ +cljs.core.derive = (function cljs$core$derive(var_args){ +var G__3223 = arguments.length; +switch (G__3223) { +case 2: +return cljs.core.derive.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.derive.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.derive.cljs$core$IFn$_invoke$arity$2 = (function (tag,parent){ +if(cljs.core.truth_(cljs.core.namespace(parent))){ +} else { +throw (new Error("Assert failed: (namespace parent)")); +} + +cljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.derive,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([tag,parent], 0)); + +return null; +}); + +cljs.core.derive.cljs$core$IFn$_invoke$arity$3 = (function (h,tag,parent){ +if(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(tag,parent)){ +} else { +throw (new Error("Assert failed: (not= tag parent)")); +} + +var tp = cljs.core.cst$kw$parents.cljs$core$IFn$_invoke$arity$1(h); +var td = cljs.core.cst$kw$descendants.cljs$core$IFn$_invoke$arity$1(h); +var ta = cljs.core.cst$kw$ancestors.cljs$core$IFn$_invoke$arity$1(h); +var tf = ((function (tp,td,ta){ +return (function (m,source,sources,target,targets){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (tp,td,ta){ +return (function (ret,k){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,k,cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core.conj,cljs.core.get.cljs$core$IFn$_invoke$arity$3(targets,k,cljs.core.PersistentHashSet.EMPTY),cljs.core.cons(target,(targets.cljs$core$IFn$_invoke$arity$1 ? targets.cljs$core$IFn$_invoke$arity$1(target) : targets.call(null,target))))); +});})(tp,td,ta)) +,m,cljs.core.cons(source,(sources.cljs$core$IFn$_invoke$arity$1 ? sources.cljs$core$IFn$_invoke$arity$1(source) : sources.call(null,source)))); +});})(tp,td,ta)) +; +var or__3936__auto__ = ((cljs.core.contains_QMARK_((tp.cljs$core$IFn$_invoke$arity$1 ? tp.cljs$core$IFn$_invoke$arity$1(tag) : tp.call(null,tag)),parent))?null:(function (){ +if(cljs.core.contains_QMARK_((ta.cljs$core$IFn$_invoke$arity$1 ? ta.cljs$core$IFn$_invoke$arity$1(tag) : ta.call(null,tag)),parent)){ +throw (new Error([cljs.core.str.cljs$core$IFn$_invoke$arity$1(tag),"already has",cljs.core.str.cljs$core$IFn$_invoke$arity$1(parent),"as ancestor"].join(''))); +} else { +} + +if(cljs.core.contains_QMARK_((ta.cljs$core$IFn$_invoke$arity$1 ? ta.cljs$core$IFn$_invoke$arity$1(parent) : ta.call(null,parent)),tag)){ +throw (new Error(["Cyclic derivation:",cljs.core.str.cljs$core$IFn$_invoke$arity$1(parent),"has",cljs.core.str.cljs$core$IFn$_invoke$arity$1(tag),"as ancestor"].join(''))); +} else { +} + +return new cljs.core.PersistentArrayMap(null, 3, [cljs.core.cst$kw$parents,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.core.cst$kw$parents.cljs$core$IFn$_invoke$arity$1(h),tag,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(tp,tag,cljs.core.PersistentHashSet.EMPTY),parent)),cljs.core.cst$kw$ancestors,tf(cljs.core.cst$kw$ancestors.cljs$core$IFn$_invoke$arity$1(h),tag,td,parent,ta),cljs.core.cst$kw$descendants,tf(cljs.core.cst$kw$descendants.cljs$core$IFn$_invoke$arity$1(h),parent,ta,tag,td)], null); +})() +); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return h; +} +}); + +cljs.core.derive.cljs$lang$maxFixedArity = 3; + +/** + * Removes a parent/child relationship between parent and + * tag. h must be a hierarchy obtained from make-hierarchy, if not + * supplied defaults to, and modifies, the global hierarchy. + */ +cljs.core.underive = (function cljs$core$underive(var_args){ +var G__3229 = arguments.length; +switch (G__3229) { +case 2: +return cljs.core.underive.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.underive.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.underive.cljs$core$IFn$_invoke$arity$2 = (function (tag,parent){ +cljs.core.swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic(cljs.core.underive,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([tag,parent], 0)); + +return null; +}); + +cljs.core.underive.cljs$core$IFn$_invoke$arity$3 = (function (h,tag,parent){ +var parentMap = cljs.core.cst$kw$parents.cljs$core$IFn$_invoke$arity$1(h); +var childsParents = (cljs.core.truth_((parentMap.cljs$core$IFn$_invoke$arity$1 ? parentMap.cljs$core$IFn$_invoke$arity$1(tag) : parentMap.call(null,tag)))?cljs.core.disj.cljs$core$IFn$_invoke$arity$2((parentMap.cljs$core$IFn$_invoke$arity$1 ? parentMap.cljs$core$IFn$_invoke$arity$1(tag) : parentMap.call(null,tag)),parent):cljs.core.PersistentHashSet.EMPTY); +var newParents = (cljs.core.truth_(cljs.core.not_empty(childsParents))?cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(parentMap,tag,childsParents):cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(parentMap,tag)); +var deriv_seq = cljs.core.flatten(cljs.core.map.cljs$core$IFn$_invoke$arity$2(((function (parentMap,childsParents,newParents){ +return (function (p1__3225_SHARP_){ +return cljs.core.cons(cljs.core.first(p1__3225_SHARP_),cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(cljs.core.first(p1__3225_SHARP_),cljs.core.second(p1__3225_SHARP_))); +});})(parentMap,childsParents,newParents)) +,cljs.core.seq(newParents))); +if(cljs.core.contains_QMARK_((parentMap.cljs$core$IFn$_invoke$arity$1 ? parentMap.cljs$core$IFn$_invoke$arity$1(tag) : parentMap.call(null,tag)),parent)){ +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(((function (parentMap,childsParents,newParents,deriv_seq){ +return (function (p1__3226_SHARP_,p2__3227_SHARP_){ +return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.derive,p1__3226_SHARP_,p2__3227_SHARP_); +});})(parentMap,childsParents,newParents,deriv_seq)) +,cljs.core.make_hierarchy(),cljs.core.partition.cljs$core$IFn$_invoke$arity$2((2),deriv_seq)); +} else { +return h; +} +}); + +cljs.core.underive.cljs$lang$maxFixedArity = 3; + +cljs.core.reset_cache = (function cljs$core$reset_cache(method_cache,method_table,cached_hierarchy,hierarchy){ +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(method_cache,(function (_){ +return cljs.core.deref(method_table); +})); + +return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(cached_hierarchy,(function (_){ +return cljs.core.deref(hierarchy); +})); +}); +cljs.core.prefers_STAR_ = (function cljs$core$prefers_STAR_(x,y,prefer_table){ +var xprefs = (function (){var fexpr__3231 = cljs.core.deref(prefer_table); +return (fexpr__3231.cljs$core$IFn$_invoke$arity$1 ? fexpr__3231.cljs$core$IFn$_invoke$arity$1(x) : fexpr__3231.call(null,x)); +})(); +var or__3936__auto__ = (cljs.core.truth_((function (){var and__3925__auto__ = xprefs; +if(cljs.core.truth_(and__3925__auto__)){ +return (xprefs.cljs$core$IFn$_invoke$arity$1 ? xprefs.cljs$core$IFn$_invoke$arity$1(y) : xprefs.call(null,y)); +} else { +return and__3925__auto__; +} +})())?true:null); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (function (){var ps = cljs.core.parents.cljs$core$IFn$_invoke$arity$1(y); +while(true){ +if((cljs.core.count(ps) > (0))){ +if(cljs.core.truth_((function (){var G__3235 = x; +var G__3236 = cljs.core.first(ps); +var G__3237 = prefer_table; +return (cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3 ? cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3(G__3235,G__3236,G__3237) : cljs.core.prefers_STAR_.call(null,G__3235,G__3236,G__3237)); +})())){ +} else { +} + +var G__3244 = cljs.core.rest(ps); +ps = G__3244; +continue; +} else { +return null; +} +break; +} +})(); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = (function (){var ps = cljs.core.parents.cljs$core$IFn$_invoke$arity$1(x); +while(true){ +if((cljs.core.count(ps) > (0))){ +if(cljs.core.truth_((function (){var G__3241 = cljs.core.first(ps); +var G__3242 = y; +var G__3243 = prefer_table; +return (cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3 ? cljs.core.prefers_STAR_.cljs$core$IFn$_invoke$arity$3(G__3241,G__3242,G__3243) : cljs.core.prefers_STAR_.call(null,G__3241,G__3242,G__3243)); +})())){ +} else { +} + +var G__3245 = cljs.core.rest(ps); +ps = G__3245; +continue; +} else { +return null; +} +break; +} +})(); +if(cljs.core.truth_(or__3936__auto____$2)){ +return or__3936__auto____$2; +} else { +return false; +} +} +} +}); +cljs.core.dominates = (function cljs$core$dominates(x,y,prefer_table,hierarchy){ +var or__3936__auto__ = cljs.core.prefers_STAR_(x,y,prefer_table); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(hierarchy,x,y); +} +}); +cljs.core.find_and_cache_best_method = (function cljs$core$find_and_cache_best_method(name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy,default_dispatch_val){ +var best_entry = cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (be,p__3246){ +var vec__3247 = p__3246; +var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3247,(0),null); +var _ = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3247,(1),null); +var e = vec__3247; +if(cljs.core.isa_QMARK_.cljs$core$IFn$_invoke$arity$3(cljs.core.deref(hierarchy),dispatch_val,k)){ +var be2 = (cljs.core.truth_((function (){var or__3936__auto__ = (be == null); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +return cljs.core.dominates(k,cljs.core.first(be),prefer_table,cljs.core.deref(hierarchy)); +} +})())?e:be); +if(cljs.core.truth_(cljs.core.dominates(cljs.core.first(be2),k,prefer_table,cljs.core.deref(hierarchy)))){ +} else { +throw (new Error(["Multiple methods in multimethod '",cljs.core.str.cljs$core$IFn$_invoke$arity$1(name),"' match dispatch value: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val)," -> ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(k)," and ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(be2)),", and neither is preferred"].join(''))); +} + +return be2; +} else { +return be; +} +}),null,cljs.core.deref(method_table)); +var best_entry__$1 = (function (){var temp__5455__auto__ = (function (){var and__3925__auto__ = (best_entry == null); +if(and__3925__auto__){ +var fexpr__3251 = cljs.core.deref(method_table); +return (fexpr__3251.cljs$core$IFn$_invoke$arity$1 ? fexpr__3251.cljs$core$IFn$_invoke$arity$1(default_dispatch_val) : fexpr__3251.call(null,default_dispatch_val)); +} else { +return and__3925__auto__; +} +})(); +if(cljs.core.truth_(temp__5455__auto__)){ +var entry = temp__5455__auto__; +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [default_dispatch_val,entry], null); +} else { +return best_entry; +} +})(); +if(cljs.core.truth_(best_entry__$1)){ +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cached_hierarchy),cljs.core.deref(hierarchy))){ +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(method_cache,cljs.core.assoc,dispatch_val,cljs.core.second(best_entry__$1)); + +return cljs.core.second(best_entry__$1); +} else { +cljs.core.reset_cache(method_cache,method_table,cached_hierarchy,hierarchy); + +return (cljs.core.find_and_cache_best_method.cljs$core$IFn$_invoke$arity$8 ? cljs.core.find_and_cache_best_method.cljs$core$IFn$_invoke$arity$8(name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy,default_dispatch_val) : cljs.core.find_and_cache_best_method.call(null,name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy,default_dispatch_val)); +} +} else { +return null; +} +}); + +/** + * @interface + */ +cljs.core.IMultiFn = function(){}; + +cljs.core._reset = (function cljs$core$_reset(mf){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_reset$arity$1 == null))))){ +return mf.cljs$core$IMultiFn$_reset$arity$1(mf); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._reset[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto__.call(null,mf)); +} else { +var m__4231__auto____$1 = (cljs.core._reset["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto____$1.call(null,mf)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-reset",mf); +} +} +} +}); + +cljs.core._add_method = (function cljs$core$_add_method(mf,dispatch_val,method){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_add_method$arity$3 == null))))){ +return mf.cljs$core$IMultiFn$_add_method$arity$3(mf,dispatch_val,method); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._add_method[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,method) : m__4231__auto__.call(null,mf,dispatch_val,method)); +} else { +var m__4231__auto____$1 = (cljs.core._add_method["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,method) : m__4231__auto____$1.call(null,mf,dispatch_val,method)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-add-method",mf); +} +} +} +}); + +cljs.core._remove_method = (function cljs$core$_remove_method(mf,dispatch_val){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_remove_method$arity$2 == null))))){ +return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf,dispatch_val); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._remove_method[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__4231__auto__.call(null,mf,dispatch_val)); +} else { +var m__4231__auto____$1 = (cljs.core._remove_method["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__4231__auto____$1.call(null,mf,dispatch_val)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-remove-method",mf); +} +} +} +}); + +cljs.core._prefer_method = (function cljs$core$_prefer_method(mf,dispatch_val,dispatch_val_y){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_prefer_method$arity$3 == null))))){ +return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf,dispatch_val,dispatch_val_y); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._prefer_method[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,dispatch_val_y) : m__4231__auto__.call(null,mf,dispatch_val,dispatch_val_y)); +} else { +var m__4231__auto____$1 = (cljs.core._prefer_method["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$3(mf,dispatch_val,dispatch_val_y) : m__4231__auto____$1.call(null,mf,dispatch_val,dispatch_val_y)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-prefer-method",mf); +} +} +} +}); + +cljs.core._get_method = (function cljs$core$_get_method(mf,dispatch_val){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_get_method$arity$2 == null))))){ +return mf.cljs$core$IMultiFn$_get_method$arity$2(mf,dispatch_val); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._get_method[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__4231__auto__.call(null,mf,dispatch_val)); +} else { +var m__4231__auto____$1 = (cljs.core._get_method["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(mf,dispatch_val) : m__4231__auto____$1.call(null,mf,dispatch_val)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-get-method",mf); +} +} +} +}); + +cljs.core._methods = (function cljs$core$_methods(mf){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_methods$arity$1 == null))))){ +return mf.cljs$core$IMultiFn$_methods$arity$1(mf); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._methods[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto__.call(null,mf)); +} else { +var m__4231__auto____$1 = (cljs.core._methods["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto____$1.call(null,mf)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-methods",mf); +} +} +} +}); + +cljs.core._prefers = (function cljs$core$_prefers(mf){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_prefers$arity$1 == null))))){ +return mf.cljs$core$IMultiFn$_prefers$arity$1(mf); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._prefers[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto__.call(null,mf)); +} else { +var m__4231__auto____$1 = (cljs.core._prefers["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto____$1.call(null,mf)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-prefers",mf); +} +} +} +}); + +cljs.core._default_dispatch_val = (function cljs$core$_default_dispatch_val(mf){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_default_dispatch_val$arity$1 == null))))){ +return mf.cljs$core$IMultiFn$_default_dispatch_val$arity$1(mf); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._default_dispatch_val[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto__.call(null,mf)); +} else { +var m__4231__auto____$1 = (cljs.core._default_dispatch_val["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto____$1.call(null,mf)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-default-dispatch-val",mf); +} +} +} +}); + +cljs.core._dispatch_fn = (function cljs$core$_dispatch_fn(mf){ +if(((!((mf == null))) && (!((mf.cljs$core$IMultiFn$_dispatch_fn$arity$1 == null))))){ +return mf.cljs$core$IMultiFn$_dispatch_fn$arity$1(mf); +} else { +var x__4230__auto__ = (((mf == null))?null:mf); +var m__4231__auto__ = (cljs.core._dispatch_fn[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto__.call(null,mf)); +} else { +var m__4231__auto____$1 = (cljs.core._dispatch_fn["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(mf) : m__4231__auto____$1.call(null,mf)); +} else { +throw cljs.core.missing_protocol("IMultiFn.-dispatch-fn",mf); +} +} +} +}); + +cljs.core.throw_no_method_error = (function cljs$core$throw_no_method_error(name,dispatch_val){ +throw (new Error(["No method in multimethod '",cljs.core.str.cljs$core$IFn$_invoke$arity$1(name),"' for dispatch value: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val)].join(''))); +}); + +/** +* @constructor + * @implements {cljs.core.IHash} + * @implements {cljs.core.IFn} + * @implements {cljs.core.IMultiFn} + * @implements {cljs.core.INamed} +*/ +cljs.core.MultiFn = (function (name,dispatch_fn,default_dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy){ +this.name = name; +this.dispatch_fn = dispatch_fn; +this.default_dispatch_val = default_dispatch_val; +this.hierarchy = hierarchy; +this.method_table = method_table; +this.prefer_table = prefer_table; +this.method_cache = method_cache; +this.cached_hierarchy = cached_hierarchy; +this.cljs$lang$protocol_mask$partition0$ = 4194305; +this.cljs$lang$protocol_mask$partition1$ = 4352; +}); +cljs.core.MultiFn.prototype.call = (function() { +var G__3254 = null; +var G__3254__1 = (function (self__){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$0 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$0() : self__.dispatch_fn.call(null)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$0 ? target_fn.cljs$core$IFn$_invoke$arity$0() : target_fn.call(null)); +}); +var G__3254__2 = (function (self__,a){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$1 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$1(a) : self__.dispatch_fn.call(null,a)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$1 ? target_fn.cljs$core$IFn$_invoke$arity$1(a) : target_fn.call(null,a)); +}); +var G__3254__3 = (function (self__,a,b){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$2 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.dispatch_fn.call(null,a,b)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$2 ? target_fn.cljs$core$IFn$_invoke$arity$2(a,b) : target_fn.call(null,a,b)); +}); +var G__3254__4 = (function (self__,a,b,c){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$3 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.dispatch_fn.call(null,a,b,c)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$3 ? target_fn.cljs$core$IFn$_invoke$arity$3(a,b,c) : target_fn.call(null,a,b,c)); +}); +var G__3254__5 = (function (self__,a,b,c,d){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$4 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.dispatch_fn.call(null,a,b,c,d)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$4 ? target_fn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : target_fn.call(null,a,b,c,d)); +}); +var G__3254__6 = (function (self__,a,b,c,d,e){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$5 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.dispatch_fn.call(null,a,b,c,d,e)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$5 ? target_fn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : target_fn.call(null,a,b,c,d,e)); +}); +var G__3254__7 = (function (self__,a,b,c,d,e,f){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$6 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : self__.dispatch_fn.call(null,a,b,c,d,e,f)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$6 ? target_fn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : target_fn.call(null,a,b,c,d,e,f)); +}); +var G__3254__8 = (function (self__,a,b,c,d,e,f,g){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$7 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$7 ? target_fn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : target_fn.call(null,a,b,c,d,e,f,g)); +}); +var G__3254__9 = (function (self__,a,b,c,d,e,f,g,h){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$8 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$8 ? target_fn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : target_fn.call(null,a,b,c,d,e,f,g,h)); +}); +var G__3254__10 = (function (self__,a,b,c,d,e,f,g,h,i){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$9 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$9 ? target_fn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : target_fn.call(null,a,b,c,d,e,f,g,h,i)); +}); +var G__3254__11 = (function (self__,a,b,c,d,e,f,g,h,i,j){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$10 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$10 ? target_fn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j)); +}); +var G__3254__12 = (function (self__,a,b,c,d,e,f,g,h,i,j,k){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$11 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$11 ? target_fn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k)); +}); +var G__3254__13 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$12 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$12 ? target_fn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +}); +var G__3254__14 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$13 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$13 ? target_fn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +}); +var G__3254__15 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$14 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$14 ? target_fn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +}); +var G__3254__16 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$15 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$15 ? target_fn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +}); +var G__3254__17 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$16 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$16 ? target_fn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +}); +var G__3254__18 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$17 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$17 ? target_fn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +}); +var G__3254__19 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$18 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$18 ? target_fn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +}); +var G__3254__20 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$19 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$19 ? target_fn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +}); +var G__3254__21 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$20 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$20 ? target_fn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +}); +var G__3254__22 = (function (self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +var self__ = this; +var self____$1 = this; +var mf = self____$1; +var dispatch_val = cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.dispatch_fn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(target_fn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +}); +G__3254 = function(self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +switch(arguments.length){ +case 1: +return G__3254__1.call(this,self__); +case 2: +return G__3254__2.call(this,self__,a); +case 3: +return G__3254__3.call(this,self__,a,b); +case 4: +return G__3254__4.call(this,self__,a,b,c); +case 5: +return G__3254__5.call(this,self__,a,b,c,d); +case 6: +return G__3254__6.call(this,self__,a,b,c,d,e); +case 7: +return G__3254__7.call(this,self__,a,b,c,d,e,f); +case 8: +return G__3254__8.call(this,self__,a,b,c,d,e,f,g); +case 9: +return G__3254__9.call(this,self__,a,b,c,d,e,f,g,h); +case 10: +return G__3254__10.call(this,self__,a,b,c,d,e,f,g,h,i); +case 11: +return G__3254__11.call(this,self__,a,b,c,d,e,f,g,h,i,j); +case 12: +return G__3254__12.call(this,self__,a,b,c,d,e,f,g,h,i,j,k); +case 13: +return G__3254__13.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l); +case 14: +return G__3254__14.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m); +case 15: +return G__3254__15.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n); +case 16: +return G__3254__16.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o); +case 17: +return G__3254__17.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p); +case 18: +return G__3254__18.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q); +case 19: +return G__3254__19.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r); +case 20: +return G__3254__20.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s); +case 21: +return G__3254__21.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t); +case 22: +return G__3254__22.call(this,self__,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest); +} +throw(new Error('Invalid arity: ' + (arguments.length - 1))); +}; +G__3254.cljs$core$IFn$_invoke$arity$1 = G__3254__1; +G__3254.cljs$core$IFn$_invoke$arity$2 = G__3254__2; +G__3254.cljs$core$IFn$_invoke$arity$3 = G__3254__3; +G__3254.cljs$core$IFn$_invoke$arity$4 = G__3254__4; +G__3254.cljs$core$IFn$_invoke$arity$5 = G__3254__5; +G__3254.cljs$core$IFn$_invoke$arity$6 = G__3254__6; +G__3254.cljs$core$IFn$_invoke$arity$7 = G__3254__7; +G__3254.cljs$core$IFn$_invoke$arity$8 = G__3254__8; +G__3254.cljs$core$IFn$_invoke$arity$9 = G__3254__9; +G__3254.cljs$core$IFn$_invoke$arity$10 = G__3254__10; +G__3254.cljs$core$IFn$_invoke$arity$11 = G__3254__11; +G__3254.cljs$core$IFn$_invoke$arity$12 = G__3254__12; +G__3254.cljs$core$IFn$_invoke$arity$13 = G__3254__13; +G__3254.cljs$core$IFn$_invoke$arity$14 = G__3254__14; +G__3254.cljs$core$IFn$_invoke$arity$15 = G__3254__15; +G__3254.cljs$core$IFn$_invoke$arity$16 = G__3254__16; +G__3254.cljs$core$IFn$_invoke$arity$17 = G__3254__17; +G__3254.cljs$core$IFn$_invoke$arity$18 = G__3254__18; +G__3254.cljs$core$IFn$_invoke$arity$19 = G__3254__19; +G__3254.cljs$core$IFn$_invoke$arity$20 = G__3254__20; +G__3254.cljs$core$IFn$_invoke$arity$21 = G__3254__21; +G__3254.cljs$core$IFn$_invoke$arity$22 = G__3254__22; +return G__3254; +})() +; + +cljs.core.MultiFn.prototype.apply = (function (self__,args3252){ +var self__ = this; +var self____$1 = this; +return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone(args3252))); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$0 = (function (){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$0 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$0() : self__.dispatch_fn.call(null)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$0 ? target_fn.cljs$core$IFn$_invoke$arity$0() : target_fn.call(null)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$1 = (function (a){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$1 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$1(a) : self__.dispatch_fn.call(null,a)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$1 ? target_fn.cljs$core$IFn$_invoke$arity$1(a) : target_fn.call(null,a)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$2 = (function (a,b){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$2 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$2(a,b) : self__.dispatch_fn.call(null,a,b)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$2 ? target_fn.cljs$core$IFn$_invoke$arity$2(a,b) : target_fn.call(null,a,b)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$3 = (function (a,b,c){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$3 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$3(a,b,c) : self__.dispatch_fn.call(null,a,b,c)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$3 ? target_fn.cljs$core$IFn$_invoke$arity$3(a,b,c) : target_fn.call(null,a,b,c)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$4 = (function (a,b,c,d){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$4 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : self__.dispatch_fn.call(null,a,b,c,d)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$4 ? target_fn.cljs$core$IFn$_invoke$arity$4(a,b,c,d) : target_fn.call(null,a,b,c,d)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$5 = (function (a,b,c,d,e){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$5 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : self__.dispatch_fn.call(null,a,b,c,d,e)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$5 ? target_fn.cljs$core$IFn$_invoke$arity$5(a,b,c,d,e) : target_fn.call(null,a,b,c,d,e)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$6 = (function (a,b,c,d,e,f){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$6 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : self__.dispatch_fn.call(null,a,b,c,d,e,f)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$6 ? target_fn.cljs$core$IFn$_invoke$arity$6(a,b,c,d,e,f) : target_fn.call(null,a,b,c,d,e,f)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$7 = (function (a,b,c,d,e,f,g){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$7 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$7 ? target_fn.cljs$core$IFn$_invoke$arity$7(a,b,c,d,e,f,g) : target_fn.call(null,a,b,c,d,e,f,g)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$8 = (function (a,b,c,d,e,f,g,h){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$8 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$8 ? target_fn.cljs$core$IFn$_invoke$arity$8(a,b,c,d,e,f,g,h) : target_fn.call(null,a,b,c,d,e,f,g,h)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$9 = (function (a,b,c,d,e,f,g,h,i){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$9 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$9 ? target_fn.cljs$core$IFn$_invoke$arity$9(a,b,c,d,e,f,g,h,i) : target_fn.call(null,a,b,c,d,e,f,g,h,i)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$10 = (function (a,b,c,d,e,f,g,h,i,j){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$10 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$10 ? target_fn.cljs$core$IFn$_invoke$arity$10(a,b,c,d,e,f,g,h,i,j) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$11 = (function (a,b,c,d,e,f,g,h,i,j,k){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$11 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$11 ? target_fn.cljs$core$IFn$_invoke$arity$11(a,b,c,d,e,f,g,h,i,j,k) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$12 = (function (a,b,c,d,e,f,g,h,i,j,k,l){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$12 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$12 ? target_fn.cljs$core$IFn$_invoke$arity$12(a,b,c,d,e,f,g,h,i,j,k,l) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$13 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$13 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$13 ? target_fn.cljs$core$IFn$_invoke$arity$13(a,b,c,d,e,f,g,h,i,j,k,l,m) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$14 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$14 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$14 ? target_fn.cljs$core$IFn$_invoke$arity$14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$15 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$15 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$15 ? target_fn.cljs$core$IFn$_invoke$arity$15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$16 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$16 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$16 ? target_fn.cljs$core$IFn$_invoke$arity$16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$17 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$17 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$17 ? target_fn.cljs$core$IFn$_invoke$arity$17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$18 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$18 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$18 ? target_fn.cljs$core$IFn$_invoke$arity$18(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$19 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$19 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$19 ? target_fn.cljs$core$IFn$_invoke$arity$19(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$20 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t){ +var self__ = this; +var mf = this; +var dispatch_val = (self__.dispatch_fn.cljs$core$IFn$_invoke$arity$20 ? self__.dispatch_fn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : self__.dispatch_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return (target_fn.cljs$core$IFn$_invoke$arity$20 ? target_fn.cljs$core$IFn$_invoke$arity$20(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) : target_fn.call(null,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IFn$_invoke$arity$21 = (function (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest){ +var self__ = this; +var mf = this; +var dispatch_val = cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(self__.dispatch_fn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +var target_fn = mf.cljs$core$IMultiFn$_get_method$arity$2(null,dispatch_val); +if(cljs.core.truth_(target_fn)){ +} else { +cljs.core.throw_no_method_error(self__.name,dispatch_val); +} + +return cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(target_fn,a,b,c,d,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,rest], 0)); +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_prefer_method$arity$3 = (function (mf,dispatch_val_x,dispatch_val_y){ +var self__ = this; +var mf__$1 = this; +if(cljs.core.truth_(cljs.core.prefers_STAR_(dispatch_val_x,dispatch_val_y,self__.prefer_table))){ +throw (new Error(["Preference conflict in multimethod '",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.name),"': ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val_y)," is already preferred to ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(dispatch_val_x)].join(''))); +} else { +} + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.prefer_table,((function (mf__$1){ +return (function (old){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(old,dispatch_val_x,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$3(old,dispatch_val_x,cljs.core.PersistentHashSet.EMPTY),dispatch_val_y)); +});})(mf__$1)) +); + +return cljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy); +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_default_dispatch_val$arity$1 = (function (mf){ +var self__ = this; +var mf__$1 = this; +return self__.default_dispatch_val; +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_remove_method$arity$2 = (function (mf,dispatch_val){ +var self__ = this; +var mf__$1 = this; +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(self__.method_table,cljs.core.dissoc,dispatch_val); + +cljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy); + +return mf__$1; +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_methods$arity$1 = (function (mf){ +var self__ = this; +var mf__$1 = this; +return cljs.core.deref(self__.method_table); +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_prefers$arity$1 = (function (mf){ +var self__ = this; +var mf__$1 = this; +return cljs.core.deref(self__.prefer_table); +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_dispatch_fn$arity$1 = (function (mf){ +var self__ = this; +var mf__$1 = this; +return self__.dispatch_fn; +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_add_method$arity$3 = (function (mf,dispatch_val,method){ +var self__ = this; +var mf__$1 = this; +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(self__.method_table,cljs.core.assoc,dispatch_val,method); + +cljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy); + +return mf__$1; +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_reset$arity$1 = (function (mf){ +var self__ = this; +var mf__$1 = this; +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.method_table,((function (mf__$1){ +return (function (mf__$2){ +return cljs.core.PersistentArrayMap.EMPTY; +});})(mf__$1)) +); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.method_cache,((function (mf__$1){ +return (function (mf__$2){ +return cljs.core.PersistentArrayMap.EMPTY; +});})(mf__$1)) +); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.prefer_table,((function (mf__$1){ +return (function (mf__$2){ +return cljs.core.PersistentArrayMap.EMPTY; +});})(mf__$1)) +); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(self__.cached_hierarchy,((function (mf__$1){ +return (function (mf__$2){ +return null; +});})(mf__$1)) +); + +return mf__$1; +}); + +cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_get_method$arity$2 = (function (mf,dispatch_val){ +var self__ = this; +var mf__$1 = this; +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(self__.cached_hierarchy),cljs.core.deref(self__.hierarchy))){ +} else { +cljs.core.reset_cache(self__.method_cache,self__.method_table,self__.cached_hierarchy,self__.hierarchy); +} + +var temp__5455__auto__ = (function (){var fexpr__3253 = cljs.core.deref(self__.method_cache); +return (fexpr__3253.cljs$core$IFn$_invoke$arity$1 ? fexpr__3253.cljs$core$IFn$_invoke$arity$1(dispatch_val) : fexpr__3253.call(null,dispatch_val)); +})(); +if(cljs.core.truth_(temp__5455__auto__)){ +var target_fn = temp__5455__auto__; +return target_fn; +} else { +return cljs.core.find_and_cache_best_method(self__.name,dispatch_val,self__.hierarchy,self__.method_table,self__.prefer_table,self__.method_cache,self__.cached_hierarchy,self__.default_dispatch_val); +} +}); + +cljs.core.MultiFn.prototype.cljs$core$INamed$_name$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return cljs.core._name(self__.name); +}); + +cljs.core.MultiFn.prototype.cljs$core$INamed$_namespace$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return cljs.core._namespace(self__.name); +}); + +cljs.core.MultiFn.prototype.cljs$core$IHash$_hash$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return goog.getUid(this$__$1); +}); + +cljs.core.MultiFn.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$name,cljs.core.cst$sym$dispatch_DASH_fn,cljs.core.cst$sym$default_DASH_dispatch_DASH_val,cljs.core.cst$sym$hierarchy,cljs.core.cst$sym$method_DASH_table,cljs.core.cst$sym$prefer_DASH_table,cljs.core.cst$sym$method_DASH_cache,cljs.core.cst$sym$cached_DASH_hierarchy], null); +}); + +cljs.core.MultiFn.cljs$lang$type = true; + +cljs.core.MultiFn.cljs$lang$ctorStr = "cljs.core/MultiFn"; + +cljs.core.MultiFn.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/MultiFn"); +}); + +/** + * Positional factory function for cljs.core/MultiFn. + */ +cljs.core.__GT_MultiFn = (function cljs$core$__GT_MultiFn(name,dispatch_fn,default_dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy){ +return (new cljs.core.MultiFn(name,dispatch_fn,default_dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy)); +}); + +/** + * Removes all of the methods of multimethod. + */ +cljs.core.remove_all_methods = (function cljs$core$remove_all_methods(multifn){ +return cljs.core._reset(multifn); +}); +/** + * Removes the method of multimethod associated with dispatch-value. + */ +cljs.core.remove_method = (function cljs$core$remove_method(multifn,dispatch_val){ +return cljs.core._remove_method(multifn,dispatch_val); +}); +/** + * Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y + * when there is a conflict + */ +cljs.core.prefer_method = (function cljs$core$prefer_method(multifn,dispatch_val_x,dispatch_val_y){ +return cljs.core._prefer_method(multifn,dispatch_val_x,dispatch_val_y); +}); +/** + * Given a multimethod, returns a map of dispatch values -> dispatch fns + */ +cljs.core.methods$ = (function cljs$core$methods(multifn){ +return cljs.core._methods(multifn); +}); +/** + * Given a multimethod and a dispatch value, returns the dispatch fn + * that would apply to that value, or nil if none apply and no default + */ +cljs.core.get_method = (function cljs$core$get_method(multifn,dispatch_val){ +return cljs.core._get_method(multifn,dispatch_val); +}); +/** + * Given a multimethod, returns a map of preferred value -> set of other values + */ +cljs.core.prefers = (function cljs$core$prefers(multifn){ +return cljs.core._prefers(multifn); +}); +/** + * Given a multimethod, return it's default-dispatch-val. + */ +cljs.core.default_dispatch_val = (function cljs$core$default_dispatch_val(multifn){ +return cljs.core._default_dispatch_val(multifn); +}); +/** + * Given a multimethod, return it's dispatch-fn. + */ +cljs.core.dispatch_fn = (function cljs$core$dispatch_fn(multifn){ +return cljs.core._dispatch_fn(multifn); +}); + +/** + * A marker protocol for UUIDs + * @interface + */ +cljs.core.IUUID = function(){}; + + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IPrintWithWriter} + * @implements {cljs.core.IComparable} + * @implements {cljs.core.IUUID} +*/ +cljs.core.UUID = (function (uuid,__hash){ +this.uuid = uuid; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 2153775104; +this.cljs$lang$protocol_mask$partition1$ = 2048; +}); +cljs.core.UUID.prototype.cljs$core$IUUID$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.UUID.prototype.toString = (function (){ +var self__ = this; +var _ = this; +return self__.uuid; +}); + +cljs.core.UUID.prototype.equiv = (function (other){ +var self__ = this; +var this$ = this; +return this$.cljs$core$IEquiv$_equiv$arity$2(null,other); +}); + +cljs.core.UUID.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (_,other){ +var self__ = this; +var ___$1 = this; +return (((other instanceof cljs.core.UUID)) && ((self__.uuid === other.uuid))); +}); + +cljs.core.UUID.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (_,writer,___$1){ +var self__ = this; +var ___$2 = this; +return cljs.core._write(writer,["#uuid \"",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.uuid),"\""].join('')); +}); + +cljs.core.UUID.prototype.cljs$core$IHash$_hash$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +if((self__.__hash == null)){ +self__.__hash = cljs.core.hash(self__.uuid); +} else { +} + +return self__.__hash; +}); + +cljs.core.UUID.prototype.cljs$core$IComparable$_compare$arity$2 = (function (_,other){ +var self__ = this; +var ___$1 = this; +var G__3255 = self__.uuid; +var G__3256 = other.uuid; +return goog.array.defaultCompare(G__3255,G__3256); +}); + +cljs.core.UUID.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$uuid,cljs.core.with_meta(cljs.core.cst$sym$__hash,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.core.UUID.cljs$lang$type = true; + +cljs.core.UUID.cljs$lang$ctorStr = "cljs.core/UUID"; + +cljs.core.UUID.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/UUID"); +}); + +/** + * Positional factory function for cljs.core/UUID. + */ +cljs.core.__GT_UUID = (function cljs$core$__GT_UUID(uuid,__hash){ +return (new cljs.core.UUID(uuid,__hash)); +}); + +cljs.core.uuid = (function cljs$core$uuid(s){ +if(typeof s === 'string'){ +} else { +throw (new Error("Assert failed: (string? s)")); +} + +return (new cljs.core.UUID(s.toLowerCase(),null)); +}); +cljs.core.random_uuid = (function cljs$core$random_uuid(){ +var hex = (function cljs$core$random_uuid_$_hex(){ +return cljs.core.rand_int((16)).toString((16)); +}); +var rhex = ((8) | ((3) & cljs.core.rand_int((16)))).toString((16)); +return cljs.core.uuid([cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),"-",cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),"-","4",cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),"-",cljs.core.str.cljs$core$IFn$_invoke$arity$1(rhex),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),"-",cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(hex())].join('')); +}); +cljs.core.uuid_QMARK_ = (function cljs$core$uuid_QMARK_(x){ +if(!((x == null))){ +if(((false) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IUUID$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +}); +cljs.core.pr_writer_ex_info = (function cljs$core$pr_writer_ex_info(obj,writer,opts){ +cljs.core._write(writer,"#error {:message "); + +cljs.core.pr_writer(obj.message,writer,opts); + +if(cljs.core.truth_(obj.data)){ +cljs.core._write(writer,", :data "); + +cljs.core.pr_writer(obj.data,writer,opts); +} else { +} + +if(cljs.core.truth_(obj.cause)){ +cljs.core._write(writer,", :cause "); + +cljs.core.pr_writer(obj.cause,writer,opts); +} else { +} + +return cljs.core._write(writer,"}"); +}); +/** + * @constructor + */ +cljs.core.ExceptionInfo = (function cljs$core$ExceptionInfo(message,data,cause){ +var e = (new Error(message)); +var this$ = this; +this$.message = message; + +this$.data = data; + +this$.cause = cause; + +this$.name = e.name; + +this$.description = e.description; + +this$.number = e.number; + +this$.fileName = e.fileName; + +this$.lineNumber = e.lineNumber; + +this$.columnNumber = e.columnNumber; + +this$.stack = e.stack; + +return this$; +}); +cljs.core.ExceptionInfo.prototype.__proto__ = Error.prototype; +cljs.core.ExceptionInfo.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.core.ExceptionInfo.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (obj,writer,opts){ +var obj__$1 = this; +return cljs.core.pr_writer_ex_info(obj__$1,writer,opts); +}); +cljs.core.ExceptionInfo.prototype.toString = (function (){ +var this$ = this; +return cljs.core.pr_str_STAR_(this$); +}); +/** + * Create an instance of ExceptionInfo, an Error type that carries a + * map of additional data. + */ +cljs.core.ex_info = (function cljs$core$ex_info(var_args){ +var G__3259 = arguments.length; +switch (G__3259) { +case 2: +return cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2 = (function (msg,data){ +return cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3(msg,data,null); +}); + +cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3 = (function (msg,data,cause){ +return (new cljs.core.ExceptionInfo(msg,data,cause)); +}); + +cljs.core.ex_info.cljs$lang$maxFixedArity = 3; + +/** + * Returns exception data (a map) if ex is an ExceptionInfo. + * Otherwise returns nil. + */ +cljs.core.ex_data = (function cljs$core$ex_data(ex){ +if((ex instanceof cljs.core.ExceptionInfo)){ +return ex.data; +} else { +return null; +} +}); +/** + * Returns the message attached to the given Error / ExceptionInfo object. + * For non-Errors returns nil. + */ +cljs.core.ex_message = (function cljs$core$ex_message(ex){ +if((ex instanceof Error)){ +return ex.message; +} else { +return null; +} +}); +/** + * Returns exception cause (an Error / ExceptionInfo) if ex is an + * ExceptionInfo. + * Otherwise returns nil. + */ +cljs.core.ex_cause = (function cljs$core$ex_cause(ex){ +if((ex instanceof cljs.core.ExceptionInfo)){ +return ex.cause; +} else { +return null; +} +}); +/** + * Returns an JavaScript compatible comparator based upon pred. + */ +cljs.core.comparator = (function cljs$core$comparator(pred){ +return (function (x,y){ +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$2 ? pred.cljs$core$IFn$_invoke$arity$2(x,y) : pred.call(null,x,y)))){ +return (-1); +} else { +if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$2 ? pred.cljs$core$IFn$_invoke$arity$2(y,x) : pred.call(null,y,x)))){ +return (1); +} else { +return (0); + +} +} +}); +}); +/** + * Returns true if x names a special form + */ +cljs.core.special_symbol_QMARK_ = (function cljs$core$special_symbol_QMARK_(x){ +return cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 24, [cljs.core.cst$sym$_AMPERSAND_,null,cljs.core.cst$sym$case_STAR_,null,cljs.core.cst$sym$defrecord_STAR_,null,cljs.core.cst$sym$try,null,cljs.core.cst$sym$ns_STAR_,null,cljs.core.cst$sym$finally,null,cljs.core.cst$sym$loop_STAR_,null,cljs.core.cst$sym$do,null,cljs.core.cst$sym$letfn_STAR_,null,cljs.core.cst$sym$if,null,cljs.core.cst$sym$new,null,cljs.core.cst$sym$ns,null,cljs.core.cst$sym$deftype_STAR_,null,cljs.core.cst$sym$let_STAR_,null,cljs.core.cst$sym$js_STAR_,null,cljs.core.cst$sym$fn_STAR_,null,cljs.core.cst$sym$recur,null,cljs.core.cst$sym$set_BANG_,null,cljs.core.cst$sym$_DOT_,null,cljs.core.cst$sym$var,null,cljs.core.cst$sym$quote,null,cljs.core.cst$sym$catch,null,cljs.core.cst$sym$throw,null,cljs.core.cst$sym$def,null], null), null),x); +}); +/** + * test [v] finds fn at key :test in var metadata and calls it, + * presuming failure will throw exception + */ +cljs.core.test = (function cljs$core$test(v){ +var f = v.cljs$lang$test; +if(cljs.core.truth_(f)){ +(f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); + +return cljs.core.cst$kw$ok; +} else { +return cljs.core.cst$kw$no_DASH_test; +} +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.IPrintWithWriter} + * @implements {cljs.core.ILookup} +*/ +cljs.core.TaggedLiteral = (function (tag,form){ +this.tag = tag; +this.form = form; +this.cljs$lang$protocol_mask$partition0$ = 2153775360; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.TaggedLiteral.prototype.toString = (function (){ +var self__ = this; +var coll = this; +return cljs.core.pr_str_STAR_(coll); +}); + +cljs.core.TaggedLiteral.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (this$,other){ +var self__ = this; +var this$__$1 = this; +return (((other instanceof cljs.core.TaggedLiteral)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.tag,other.tag)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.form,other.form))); +}); + +cljs.core.TaggedLiteral.prototype.cljs$core$IHash$_hash$arity$1 = (function (this$){ +var self__ = this; +var this$__$1 = this; +return (((31) * cljs.core.hash(self__.tag)) + cljs.core.hash(self__.form)); +}); + +cljs.core.TaggedLiteral.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (this$,v){ +var self__ = this; +var this$__$1 = this; +return this$__$1.cljs$core$ILookup$_lookup$arity$3(null,v,null); +}); + +cljs.core.TaggedLiteral.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (this$,v,not_found){ +var self__ = this; +var this$__$1 = this; +var G__3261 = v; +var G__3261__$1 = (((G__3261 instanceof cljs.core.Keyword))?G__3261.fqn:null); +switch (G__3261__$1) { +case "tag": +return self__.tag; + +break; +case "form": +return self__.form; + +break; +default: +return not_found; + +} +}); + +cljs.core.TaggedLiteral.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (o,writer,opts){ +var self__ = this; +var o__$1 = this; +cljs.core._write(writer,["#",cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.tag)," "].join('')); + +return cljs.core.pr_writer(self__.form,writer,opts); +}); + +cljs.core.TaggedLiteral.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$tag,cljs.core.cst$sym$form], null); +}); + +cljs.core.TaggedLiteral.cljs$lang$type = true; + +cljs.core.TaggedLiteral.cljs$lang$ctorStr = "cljs.core/TaggedLiteral"; + +cljs.core.TaggedLiteral.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/TaggedLiteral"); +}); + +/** + * Positional factory function for cljs.core/TaggedLiteral. + */ +cljs.core.__GT_TaggedLiteral = (function cljs$core$__GT_TaggedLiteral(tag,form){ +return (new cljs.core.TaggedLiteral(tag,form)); +}); + +/** + * Return true if the value is the data representation of a tagged literal + */ +cljs.core.tagged_literal_QMARK_ = (function cljs$core$tagged_literal_QMARK_(value){ +return (value instanceof cljs.core.TaggedLiteral); +}); +/** + * Construct a data representation of a tagged literal from a + * tag symbol and a form. + */ +cljs.core.tagged_literal = (function cljs$core$tagged_literal(tag,form){ +if((tag instanceof cljs.core.Symbol)){ +} else { +throw (new Error("Assert failed: (symbol? tag)")); +} + +return (new cljs.core.TaggedLiteral(tag,form)); +}); +/** + * @type {*} + */ +cljs.core.js_reserved_arr = ["arguments","abstract","await","boolean","break","byte","case","catch","char","class","const","continue","debugger","default","delete","do","double","else","enum","export","extends","final","finally","float","for","function","goto","if","implements","import","in","instanceof","int","interface","let","long","native","new","package","private","protected","public","return","short","static","super","switch","synchronized","this","throw","throws","transient","try","typeof","var","void","volatile","while","with","yield","methods","null","constructor"]; +/** + * @type {null|Object} + */ +cljs.core.js_reserved = null; +cljs.core.js_reserved_QMARK_ = (function cljs$core$js_reserved_QMARK_(x){ +if((cljs.core.js_reserved == null)){ +cljs.core.js_reserved = cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__3263_SHARP_,p2__3264_SHARP_){ +goog.object.set(p1__3263_SHARP_,p2__3264_SHARP_,true); + +return p1__3263_SHARP_; +}),({}),cljs.core.js_reserved_arr); +} else { +} + +return cljs.core.js_reserved.hasOwnProperty(x); +}); +cljs.core.demunge_pattern = (function cljs$core$demunge_pattern(){ +if(cljs.core.truth_(cljs.core.DEMUNGE_PATTERN)){ +} else { +cljs.core.DEMUNGE_PATTERN = (function (){var ks = cljs.core.sort.cljs$core$IFn$_invoke$arity$2((function (a,b){ +return (b.length - a.length); +}),cljs.core.js_keys(cljs.core.DEMUNGE_MAP)); +var ks__$1 = ks; +var ret = ""; +while(true){ +if(cljs.core.seq(ks__$1)){ +var G__3266 = cljs.core.next(ks__$1); +var G__3267 = [cljs.core.str.cljs$core$IFn$_invoke$arity$1((function (){var G__3265 = ret; +if(!((ret === ""))){ +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__3265),"|"].join(''); +} else { +return G__3265; +} +})()),cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(ks__$1))].join(''); +ks__$1 = G__3266; +ret = G__3267; +continue; +} else { +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(ret),"|\\$"].join(''); +} +break; +} +})(); +} + +return cljs.core.DEMUNGE_PATTERN; +}); +cljs.core.munge_str = (function cljs$core$munge_str(name){ +var sb = (new goog.string.StringBuffer()); +var i_3268 = (0); +while(true){ +if((i_3268 < name.length)){ +var c_3269 = name.charAt(i_3268); +var sub_3270 = goog.object.get(cljs.core.CHAR_MAP,c_3269); +if(!((sub_3270 == null))){ +sb.append(sub_3270); +} else { +sb.append(c_3269); +} + +var G__3271 = (i_3268 + (1)); +i_3268 = G__3271; +continue; +} else { +} +break; +} + +return sb.toString(); +}); +cljs.core.munge = (function cljs$core$munge(name){ +var name_SINGLEQUOTE_ = cljs.core.munge_str([cljs.core.str.cljs$core$IFn$_invoke$arity$1(name)].join('')); +var name_SINGLEQUOTE___$1 = (((name_SINGLEQUOTE_ === ".."))?"_DOT__DOT_":(cljs.core.truth_(cljs.core.js_reserved_QMARK_(name_SINGLEQUOTE_))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(name_SINGLEQUOTE_),"$"].join(''):name_SINGLEQUOTE_ +)); +if((name instanceof cljs.core.Symbol)){ +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(name_SINGLEQUOTE___$1); +} else { +return name_SINGLEQUOTE___$1; +} +}); +cljs.core.demunge_str = (function cljs$core$demunge_str(munged_name){ +var r = (new RegExp(cljs.core.demunge_pattern(),"g")); +var munged_name__$1 = (cljs.core.truth_(goog.string.endsWith(munged_name,"$"))?munged_name.substring((0),(munged_name.length - (1))):munged_name); +var ret = ""; +var last_match_end = (0); +while(true){ +var temp__5455__auto__ = r.exec(munged_name__$1); +if(cljs.core.truth_(temp__5455__auto__)){ +var match = temp__5455__auto__; +var vec__3272 = match; +var x = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__3272,(0),null); +var G__3275 = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(ret),cljs.core.str.cljs$core$IFn$_invoke$arity$1(munged_name__$1.substring(last_match_end,(r.lastIndex - x.length))),cljs.core.str.cljs$core$IFn$_invoke$arity$1((((x === "$"))?"/":goog.object.get(cljs.core.DEMUNGE_MAP,x)))].join(''); +var G__3276 = r.lastIndex; +ret = G__3275; +last_match_end = G__3276; +continue; +} else { +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(ret),cljs.core.str.cljs$core$IFn$_invoke$arity$1(munged_name__$1.substring(last_match_end,munged_name__$1.length))].join(''); +} +break; +} +}); +cljs.core.demunge = (function cljs$core$demunge(name){ +var G__3278 = (function (){var name_SINGLEQUOTE_ = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(name)].join(''); +if((name_SINGLEQUOTE_ === "_DOT__DOT_")){ +return ".."; +} else { +return cljs.core.demunge_str(name_SINGLEQUOTE_); +} +})(); +var fexpr__3277 = (((name instanceof cljs.core.Symbol))?cljs.core.symbol:cljs.core.str); +return (fexpr__3277.cljs$core$IFn$_invoke$arity$1 ? fexpr__3277.cljs$core$IFn$_invoke$arity$1(G__3278) : fexpr__3277.call(null,G__3278)); +}); +if((typeof cljs !== 'undefined') && (typeof cljs.core !== 'undefined') && (typeof cljs.core.tapset !== 'undefined')){ +} else { +/** + * @type {*} + */ +cljs.core.tapset = null; +} +cljs.core.maybe_init_tapset = (function cljs$core$maybe_init_tapset(){ +if((cljs.core.tapset == null)){ +return cljs.core.tapset = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentHashSet.EMPTY); +} else { +return null; +} +}); +/** + * Adds f, a fn of one argument, to the tap set. This function will be called with + * anything sent via tap>. Remember f in order to remove-tap + */ +cljs.core.add_tap = (function cljs$core$add_tap(f){ +cljs.core.maybe_init_tapset(); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(cljs.core.tapset,cljs.core.conj,f); + +return null; +}); +/** + * Remove f from the tap set. + */ +cljs.core.remove_tap = (function cljs$core$remove_tap(f){ +cljs.core.maybe_init_tapset(); + +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$3(cljs.core.tapset,cljs.core.disj,f); + +return null; +}); +/** + * Sends x to any taps. Returns the result of *exec-tap-fn*, a Boolean value. + */ +cljs.core.tap_GT_ = (function cljs$core$tap_GT_(x){ +cljs.core.maybe_init_tapset(); + +return (cljs.core._STAR_exec_tap_fn_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.core._STAR_exec_tap_fn_STAR_.cljs$core$IFn$_invoke$arity$1((function (){ +var seq__3279 = cljs.core.seq(cljs.core.deref(cljs.core.tapset)); +var chunk__3280 = null; +var count__3281 = (0); +var i__3282 = (0); +while(true){ +if((i__3282 < count__3281)){ +var tap = chunk__3280.cljs$core$IIndexed$_nth$arity$2(null,i__3282); +try{(tap.cljs$core$IFn$_invoke$arity$1 ? tap.cljs$core$IFn$_invoke$arity$1(x) : tap.call(null,x)); +}catch (e3283){if((e3283 instanceof Error)){ +var ex_3285 = e3283; +} else { +throw e3283; + +} +} + +var G__3286 = seq__3279; +var G__3287 = chunk__3280; +var G__3288 = count__3281; +var G__3289 = (i__3282 + (1)); +seq__3279 = G__3286; +chunk__3280 = G__3287; +count__3281 = G__3288; +i__3282 = G__3289; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__3279); +if(temp__5457__auto__){ +var seq__3279__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__3279__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__3279__$1); +var G__3290 = cljs.core.chunk_rest(seq__3279__$1); +var G__3291 = c__4338__auto__; +var G__3292 = cljs.core.count(c__4338__auto__); +var G__3293 = (0); +seq__3279 = G__3290; +chunk__3280 = G__3291; +count__3281 = G__3292; +i__3282 = G__3293; +continue; +} else { +var tap = cljs.core.first(seq__3279__$1); +try{(tap.cljs$core$IFn$_invoke$arity$1 ? tap.cljs$core$IFn$_invoke$arity$1(x) : tap.call(null,x)); +}catch (e3284){if((e3284 instanceof Error)){ +var ex_3294 = e3284; +} else { +throw e3284; + +} +} + +var G__3295 = cljs.core.next(seq__3279__$1); +var G__3296 = null; +var G__3297 = (0); +var G__3298 = (0); +seq__3279 = G__3295; +chunk__3280 = G__3296; +count__3281 = G__3297; +i__3282 = G__3298; +continue; +} +} else { +return null; +} +} +break; +} +})) : cljs.core._STAR_exec_tap_fn_STAR_.call(null,(function (){ +var seq__3279 = cljs.core.seq(cljs.core.deref(cljs.core.tapset)); +var chunk__3280 = null; +var count__3281 = (0); +var i__3282 = (0); +while(true){ +if((i__3282 < count__3281)){ +var tap = chunk__3280.cljs$core$IIndexed$_nth$arity$2(null,i__3282); +try{(tap.cljs$core$IFn$_invoke$arity$1 ? tap.cljs$core$IFn$_invoke$arity$1(x) : tap.call(null,x)); +}catch (e3283){if((e3283 instanceof Error)){ +var ex_3299 = e3283; +} else { +throw e3283; + +} +} + +var G__3300 = seq__3279; +var G__3301 = chunk__3280; +var G__3302 = count__3281; +var G__3303 = (i__3282 + (1)); +seq__3279 = G__3300; +chunk__3280 = G__3301; +count__3281 = G__3302; +i__3282 = G__3303; +continue; +} else { +var temp__5457__auto__ = cljs.core.seq(seq__3279); +if(temp__5457__auto__){ +var seq__3279__$1 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(seq__3279__$1)){ +var c__4338__auto__ = cljs.core.chunk_first(seq__3279__$1); +var G__3304 = cljs.core.chunk_rest(seq__3279__$1); +var G__3305 = c__4338__auto__; +var G__3306 = cljs.core.count(c__4338__auto__); +var G__3307 = (0); +seq__3279 = G__3304; +chunk__3280 = G__3305; +count__3281 = G__3306; +i__3282 = G__3307; +continue; +} else { +var tap = cljs.core.first(seq__3279__$1); +try{(tap.cljs$core$IFn$_invoke$arity$1 ? tap.cljs$core$IFn$_invoke$arity$1(x) : tap.call(null,x)); +}catch (e3284){if((e3284 instanceof Error)){ +var ex_3308 = e3284; +} else { +throw e3284; + +} +} + +var G__3309 = cljs.core.next(seq__3279__$1); +var G__3310 = null; +var G__3311 = (0); +var G__3312 = (0); +seq__3279 = G__3309; +chunk__3280 = G__3310; +count__3281 = G__3311; +i__3282 = G__3312; +continue; +} +} else { +return null; +} +} +break; +} +}))); +}); +/** + * Bootstrap only. + */ +cljs.core.ns_lookup = (function cljs$core$ns_lookup(ns_obj,k){ +return (function (){ +return goog.object.get(ns_obj,k); +}); +}); + +/** +* @constructor + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} +*/ +cljs.core.Namespace = (function (obj,name){ +this.obj = obj; +this.name = name; +this.cljs$lang$protocol_mask$partition0$ = 6291456; +this.cljs$lang$protocol_mask$partition1$ = 0; +}); +cljs.core.Namespace.prototype.findInternedVar = (function (sym){ +var self__ = this; +var this$ = this; +var k = cljs.core.munge([cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym)].join('')); +if(goog.object.containsKey(self__.obj,k)){ +var var_sym = cljs.core.symbol.cljs$core$IFn$_invoke$arity$2([cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.name)].join(''),[cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym)].join('')); +var var_meta = new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$ns,this$], null); +return (new cljs.core.Var(cljs.core.ns_lookup(self__.obj,k),var_sym,var_meta)); +} else { +return null; +} +}); + +cljs.core.Namespace.prototype.getName = (function (){ +var self__ = this; +var _ = this; +return self__.name; +}); + +cljs.core.Namespace.prototype.toString = (function (){ +var self__ = this; +var _ = this; +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.name)].join(''); +}); + +cljs.core.Namespace.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (_,other){ +var self__ = this; +var ___$1 = this; +if((other instanceof cljs.core.Namespace)){ +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(self__.name,other.name); +} else { +return false; +} +}); + +cljs.core.Namespace.prototype.cljs$core$IHash$_hash$arity$1 = (function (_){ +var self__ = this; +var ___$1 = this; +return cljs.core.hash(self__.name); +}); + +cljs.core.Namespace.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$obj,cljs.core.cst$sym$name], null); +}); + +cljs.core.Namespace.cljs$lang$type = true; + +cljs.core.Namespace.cljs$lang$ctorStr = "cljs.core/Namespace"; + +cljs.core.Namespace.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.core/Namespace"); +}); + +/** + * Positional factory function for cljs.core/Namespace. + */ +cljs.core.__GT_Namespace = (function cljs$core$__GT_Namespace(obj,name){ +return (new cljs.core.Namespace(obj,name)); +}); + +/** + * Bootstrap only. + * @type {*} + */ +cljs.core.NS_CACHE = null; +/** + * Bootstrap only. + */ +cljs.core.find_ns_obj_STAR_ = (function cljs$core$find_ns_obj_STAR_(ctxt,xs){ +while(true){ +if((ctxt == null)){ +return null; +} else { +if((xs == null)){ +return ctxt; +} else { +var G__3315 = (function (){var G__3313 = ctxt; +var G__3314 = cljs.core.first(xs); +return goog.object.get(G__3313,G__3314); +})(); +var G__3316 = cljs.core.next(xs); +ctxt = G__3315; +xs = G__3316; +continue; + +} +} +break; +} +}); +/** + * Bootstrap only. + */ +cljs.core.find_ns_obj = (function cljs$core$find_ns_obj(ns){ +var munged_ns = cljs.core.munge([cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns)].join('')); +var segs = munged_ns.split("."); +var G__3317 = cljs.core._STAR_target_STAR_; +switch (G__3317) { +case "nodejs": +if(COMPILED){ +return cljs.core.find_ns_obj_STAR_((function (){try{var ctxt = eval(cljs.core.first(segs)); +if(cljs.core.truth_((function (){var and__3925__auto__ = ctxt; +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.object_QMARK_(ctxt); +} else { +return and__3925__auto__; +} +})())){ +return ctxt; +} else { +return null; +} +}catch (e3318){if((e3318 instanceof ReferenceError)){ +var e = e3318; +return null; +} else { +throw e3318; + +} +}})(),cljs.core.next(segs)); +} else { +return cljs.core.find_ns_obj_STAR_(goog.global,segs); +} + +break; +case "default": +case "webworker": +return cljs.core.find_ns_obj_STAR_(goog.global,segs); + +break; +default: +throw (new Error(["find-ns-obj not supported for target ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core._STAR_target_STAR_)].join(''))); + +} +}); +/** + * Returns a map of the intern mappings for the namespace. + * Bootstrap only. + */ +cljs.core.ns_interns_STAR_ = (function cljs$core$ns_interns_STAR_(sym){ +var ns_obj = cljs.core.find_ns_obj(sym); +var ns = (new cljs.core.Namespace(ns_obj,sym)); +var step = ((function (ns_obj,ns){ +return (function cljs$core$ns_interns_STAR__$_step(ret,k){ +var var_sym = cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.demunge(k)); +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(ret,var_sym,(new cljs.core.Var(((function (var_sym,ns_obj,ns){ +return (function (){ +return goog.object.get(ns_obj,k); +});})(var_sym,ns_obj,ns)) +,cljs.core.symbol.cljs$core$IFn$_invoke$arity$2([cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym)].join(''),[cljs.core.str.cljs$core$IFn$_invoke$arity$1(var_sym)].join('')),new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$ns,ns], null)))); +});})(ns_obj,ns)) +; +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(step,cljs.core.PersistentArrayMap.EMPTY,cljs.core.js_keys(ns_obj)); +}); +/** + * Create a new namespace named by the symbol. Bootstrap only. + */ +cljs.core.create_ns = (function cljs$core$create_ns(var_args){ +var G__3321 = arguments.length; +switch (G__3321) { +case 1: +return cljs.core.create_ns.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.core.create_ns.cljs$core$IFn$_invoke$arity$1 = (function (sym){ +return cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2(sym,cljs.core.find_ns_obj(sym)); +}); + +cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2 = (function (sym,ns_obj){ +return (new cljs.core.Namespace(ns_obj,sym)); +}); + +cljs.core.create_ns.cljs$lang$maxFixedArity = 2; + +/** + * Returns the namespace named by the symbol or nil if it doesn't exist. + * Bootstrap only. + */ +cljs.core.find_ns = (function cljs$core$find_ns(ns){ +if((cljs.core.NS_CACHE == null)){ +cljs.core.NS_CACHE = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +} else { +} + +var the_ns = cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.NS_CACHE),ns); +if(!((the_ns == null))){ +return the_ns; +} else { +var ns_obj = cljs.core.find_ns_obj(ns); +if((ns_obj == null)){ +return null; +} else { +var new_ns = cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2(ns,ns_obj); +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.NS_CACHE,cljs.core.assoc,ns,new_ns); + +return new_ns; +} +} +}); +/** + * Returns the macros namespace named by the symbol or nil if it doesn't exist. + * Bootstrap only. + */ +cljs.core.find_macros_ns = (function cljs$core$find_macros_ns(ns){ +if((cljs.core.NS_CACHE == null)){ +cljs.core.NS_CACHE = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +} else { +} + +var ns_str = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns)].join(''); +var ns__$1 = ((!(goog.string.contains(ns_str,"$macros")))?cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns_str),"$macros"].join('')):ns); +var the_ns = cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(cljs.core.NS_CACHE),ns__$1); +if(!((the_ns == null))){ +return the_ns; +} else { +var ns_obj = cljs.core.find_ns_obj(ns__$1); +if((ns_obj == null)){ +return null; +} else { +var new_ns = cljs.core.create_ns.cljs$core$IFn$_invoke$arity$2(ns__$1,ns_obj); +cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(cljs.core.NS_CACHE,cljs.core.assoc,ns__$1,new_ns); + +return new_ns; +} +} +}); +/** + * Returns the name of the namespace, a Namespace object. + * Bootstrap only. + */ +cljs.core.ns_name = (function cljs$core$ns_name(ns_obj){ +return ns_obj.name; +}); +/** + * Returns true x is a goog.Uri instance. + */ +cljs.core.uri_QMARK_ = (function cljs$core$uri_QMARK_(x){ +return (x instanceof goog.Uri); +}); +cljs.core.maybe_enable_print_BANG_ = (function cljs$core$maybe_enable_print_BANG_(){ +if((typeof console !== 'undefined')){ +return cljs.core.enable_console_print_BANG_(); +} else { +if((cljs.core._STAR_target_STAR_ === "nashorn")){ +var system = Java.type("java.lang.System"); +cljs.core._STAR_print_newline_STAR_ = false; + +cljs.core.set_print_fn_BANG_(((function (system){ +return (function (){ +var xs = arguments; +var s = goog.array.clone(xs).join(""); +return system.out.println(s); +});})(system)) +); + +return cljs.core.set_print_err_fn_BANG_(((function (system){ +return (function (){ +var xs = arguments; +var s = goog.array.clone(xs).join(""); +return system.error.println(s); +});})(system)) +); +} else { +return null; +} +} +}); +cljs.core.maybe_enable_print_BANG_(); +if((typeof cljs !== 'undefined') && (typeof cljs.core !== 'undefined') && (typeof cljs.core._STAR_eval_STAR_ !== 'undefined')){ +} else { +/** + * Runtime environments may provide a way to evaluate ClojureScript + * forms. Whatever function *eval* is bound to will be passed any forms which + * should be evaluated. + */ +cljs.core._STAR_eval_STAR_ = (function cljs$core$_STAR_eval_STAR_(_){ +throw (new Error("cljs.core/*eval* not bound")); +}); +} +/** + * Evaluates the form data structure (not text!) and returns the result. + * Delegates to cljs.core/*eval*. Intended for use in self-hosted ClojureScript, + * which sets up an implementation of cljs.core/*eval* for that environment. + */ +cljs.core.eval = (function cljs$core$eval(form){ +return (cljs.core._STAR_eval_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.core._STAR_eval_STAR_.cljs$core$IFn$_invoke$arity$1(form) : cljs.core._STAR_eval_STAR_.call(null,form)); +}); diff --git a/js/cljs/core/constants.js b/js/cljs/core/constants.js new file mode 100644 index 0000000..8f8fcc4 --- /dev/null +++ b/js/cljs/core/constants.js @@ -0,0 +1,366 @@ +goog.provide('cljs.core.constants'); +goog.require('cljs.core'); +cljs.core.cst$sym$form = new cljs.core.Symbol(null,"form","form",16469056,null); +cljs.core.cst$kw$dyn_DASH_v = new cljs.core.Keyword(null,"dyn-v","dyn-v",949994592); +cljs.core.cst$sym$tag = new cljs.core.Symbol(null,"tag","tag",350170304,null); +cljs.core.cst$sym$_AMPERSAND_ = new cljs.core.Symbol(null,"&","&",-2144855648,null); +cljs.core.cst$kw$unnamed = new cljs.core.Keyword(null,"unnamed","unnamed",-26044928); +cljs.core.cst$sym$uuid = new cljs.core.Symbol(null,"uuid","uuid",-504564192,null); +cljs.core.cst$kw$path = new cljs.core.Keyword(null,"path","path",-188191168); +cljs.core.cst$kw$features = new cljs.core.Keyword(null,"features","features",-1146962336); +cljs.core.cst$kw$add_DASH_event = new cljs.core.Keyword(null,"add-event","add-event",938429088); +cljs.core.cst$sym$case_STAR_ = new cljs.core.Symbol(null,"case*","case*",-1938255072,null); +cljs.core.cst$kw$ex_DASH_kind = new cljs.core.Keyword(null,"ex-kind","ex-kind",1581199296); +cljs.core.cst$kw$yield = new cljs.core.Keyword(null,"yield","yield",177875009); +cljs.core.cst$sym$end = new cljs.core.Symbol(null,"end","end",1372345569,null); +cljs.core.cst$kw$tags = new cljs.core.Keyword(null,"tags","tags",1771418977); +cljs.core.cst$sym$defrecord_STAR_ = new cljs.core.Symbol(null,"defrecord*","defrecord*",-1936366207,null); +cljs.core.cst$sym$base = new cljs.core.Symbol(null,"base","base",1825810849,null); +cljs.core.cst$sym$obj = new cljs.core.Symbol(null,"obj","obj",-1672671807,null); +cljs.core.cst$sym$post_DASH_event_DASH_callback_DASH_fns = new cljs.core.Symbol(null,"post-event-callback-fns","post-event-callback-fns",-297038335,null); +cljs.core.cst$sym$fqn = new cljs.core.Symbol(null,"fqn","fqn",-1749334463,null); +cljs.core.cst$sym$first = new cljs.core.Symbol(null,"first","first",996428481,null); +cljs.core.cst$kw$reader_DASH_error = new cljs.core.Keyword(null,"reader-error","reader-error",1610253121); +cljs.core.cst$kw$paused = new cljs.core.Keyword(null,"paused","paused",-1710376127); +cljs.core.cst$sym$try = new cljs.core.Symbol(null,"try","try",-1273693247,null); +cljs.core.cst$sym$has_DASH_nil_QMARK_ = new cljs.core.Symbol(null,"has-nil?","has-nil?",825886722,null); +cljs.core.cst$kw$errors = new cljs.core.Keyword(null,"errors","errors",-908790718); +cljs.core.cst$kw$on_DASH_set = new cljs.core.Keyword(null,"on-set","on-set",-140953470); +cljs.core.cst$sym$caught = new cljs.core.Symbol(null,"caught","caught",2084008322,null); +cljs.core.cst$kw$block = new cljs.core.Keyword(null,"block","block",664686210); +cljs.core.cst$sym$rear = new cljs.core.Symbol(null,"rear","rear",-900164830,null); +cljs.core.cst$sym$hierarchy = new cljs.core.Symbol(null,"hierarchy","hierarchy",587061186,null); +cljs.core.cst$sym$iter = new cljs.core.Symbol(null,"iter","iter",-1346195486,null); +cljs.core.cst$sym$clojure$core_SLASH_list = new cljs.core.Symbol("clojure.core","list","clojure.core/list",-1119203325,null); +cljs.core.cst$sym$watching = new cljs.core.Symbol(null,"watching","watching",1947648227,null); +cljs.core.cst$kw$cljsLegacyRender = new cljs.core.Keyword(null,"cljsLegacyRender","cljsLegacyRender",-1527295613); +cljs.core.cst$sym$step = new cljs.core.Symbol(null,"step","step",-1365547645,null); +cljs.core.cst$kw$sub_SLASH_run = new cljs.core.Keyword("sub","run","sub/run",-1821315581); +cljs.core.cst$sym$boolean = new cljs.core.Symbol(null,"boolean","boolean",-278886877,null); +cljs.core.cst$sym$update_DASH_count = new cljs.core.Symbol(null,"update-count","update-count",-411982269,null); +cljs.core.cst$sym$reaction = new cljs.core.Symbol(null,"reaction","reaction",2131401315,null); +cljs.core.cst$sym$method_DASH_table = new cljs.core.Symbol(null,"method-table","method-table",-1878263165,null); +cljs.core.cst$sym$chunk = new cljs.core.Symbol(null,"chunk","chunk",449371907,null); +cljs.core.cst$kw$idle = new cljs.core.Keyword(null,"idle","idle",-2007156861); +cljs.core.cst$sym$callback = new cljs.core.Symbol(null,"callback","callback",935395299,null); +cljs.core.cst$kw$cause = new cljs.core.Keyword(null,"cause","cause",231901252); +cljs.core.cst$kw$app_DASH_db_DASH_after = new cljs.core.Keyword(null,"app-db-after","app-db-after",1477492964); +cljs.core.cst$kw$current_DASH_state = new cljs.core.Keyword(null,"current-state","current-state",1048284452); +cljs.core.cst$sym$i = new cljs.core.Symbol(null,"i","i",253690212,null); +cljs.core.cst$kw$new_DASH_state = new cljs.core.Keyword(null,"new-state","new-state",-490349212); +cljs.core.cst$sym$rest = new cljs.core.Symbol(null,"rest","rest",398835108,null); +cljs.core.cst$kw$namespaced_DASH_map = new cljs.core.Keyword(null,"namespaced-map","namespaced-map",1235665380); +cljs.core.cst$kw$group = new cljs.core.Keyword(null,"group","group",582596132); +cljs.core.cst$kw$meta = new cljs.core.Keyword(null,"meta","meta",1499536964); +cljs.core.cst$sym$s_DASH_pos = new cljs.core.Symbol(null,"s-pos","s-pos",-540562492,null); +cljs.core.cst$kw$dup = new cljs.core.Keyword(null,"dup","dup",556298533); +cljs.core.cst$kw$key = new cljs.core.Keyword(null,"key","key",-1516042587); +cljs.core.cst$kw$fsm_DASH_state = new cljs.core.Keyword(null,"fsm-state","fsm-state",1656310533); +cljs.core.cst$sym$comp = new cljs.core.Symbol(null,"comp","comp",-1462482139,null); +cljs.core.cst$sym$cljs$core_SLASH_array_DASH_map = new cljs.core.Symbol("cljs.core","array-map","cljs.core/array-map",-1519210683,null); +cljs.core.cst$sym$dispatch_DASH_fn = new cljs.core.Symbol(null,"dispatch-fn","dispatch-fn",-1401088155,null); +cljs.core.cst$sym$buffer = new cljs.core.Symbol(null,"buffer","buffer",-2037140571,null); +cljs.core.cst$sym$prev_DASH_column = new cljs.core.Symbol(null,"prev-column","prev-column",324083974,null); +cljs.core.cst$kw$reader_DASH_exception = new cljs.core.Keyword(null,"reader-exception","reader-exception",-1938323098); +cljs.core.cst$kw$else = new cljs.core.Keyword(null,"else","else",-1508377146); +cljs.core.cst$kw$invalid_DASH_namespaces = new cljs.core.Keyword(null,"invalid-namespaces","invalid-namespaces",-935340538); +cljs.core.cst$kw$_LT__DASH_ = new cljs.core.Keyword(null,"<-","<-",760412998); +cljs.core.cst$sym$left = new cljs.core.Symbol(null,"left","left",1241415590,null); +cljs.core.cst$sym$ns_STAR_ = new cljs.core.Symbol(null,"ns*","ns*",1840949383,null); +cljs.core.cst$kw$offset = new cljs.core.Keyword(null,"offset","offset",296498311); +cljs.core.cst$sym$path = new cljs.core.Symbol(null,"path","path",1452340359,null); +cljs.core.cst$kw$cljs$core_SLASH_none = new cljs.core.Keyword("cljs.core","none","cljs.core/none",926646439); +cljs.core.cst$sym$shift = new cljs.core.Symbol(null,"shift","shift",-1657295705,null); +cljs.core.cst$sym$cljs$core_SLASH_hash_DASH_map = new cljs.core.Symbol("cljs.core","hash-map","cljs.core/hash-map",303385767,null); +cljs.core.cst$sym$iters = new cljs.core.Symbol(null,"iters","iters",719353031,null); +cljs.core.cst$kw$db = new cljs.core.Keyword(null,"db","db",993250759); +cljs.core.cst$kw$unknown_DASH_block_DASH_type = new cljs.core.Keyword(null,"unknown-block-type","unknown-block-type",-507846201); +cljs.core.cst$kw$fx_DASH_handler = new cljs.core.Keyword(null,"fx-handler","fx-handler",-549783097); +cljs.core.cst$kw$sub = new cljs.core.Keyword(null,"sub","sub",-2093760025); +cljs.core.cst$sym$cljs$core_SLASH_apply = new cljs.core.Symbol("cljs.core","apply","cljs.core/apply",1757277831,null); +cljs.core.cst$kw$re_DASH_frame$std_DASH_interceptors_SLASH_not_DASH_found = new cljs.core.Keyword("re-frame.std-interceptors","not-found","re-frame.std-interceptors/not-found",-1614827865); +cljs.core.cst$kw$queue = new cljs.core.Keyword(null,"queue","queue",1455835879); +cljs.core.cst$kw$displayName = new cljs.core.Keyword(null,"displayName","displayName",-809144601); +cljs.core.cst$sym$args = new cljs.core.Symbol(null,"args","args",-1338879193,null); +cljs.core.cst$sym$xform = new cljs.core.Symbol(null,"xform","xform",-85179481,null); +cljs.core.cst$kw$validator = new cljs.core.Keyword(null,"validator","validator",-1966190681); +cljs.core.cst$sym$finally = new cljs.core.Symbol(null,"finally","finally",-1065347064,null); +cljs.core.cst$kw$sub_SLASH_create = new cljs.core.Keyword("sub","create","sub/create",-1301317560); +cljs.core.cst$kw$default = new cljs.core.Keyword(null,"default","default",-1987822328); +cljs.core.cst$kw$sequential = new cljs.core.Keyword(null,"sequential","sequential",-1082983960); +cljs.core.cst$sym$prefer_DASH_table = new cljs.core.Symbol(null,"prefer-table","prefer-table",462168584,null); +cljs.core.cst$sym$loop_STAR_ = new cljs.core.Symbol(null,"loop*","loop*",615029416,null); +cljs.core.cst$sym$watches = new cljs.core.Symbol(null,"watches","watches",1367433992,null); +cljs.core.cst$kw$ns = new cljs.core.Keyword(null,"ns","ns",441598760); +cljs.core.cst$kw$symbol = new cljs.core.Keyword(null,"symbol","symbol",-1038572696); +cljs.core.cst$kw$warn = new cljs.core.Keyword(null,"warn","warn",-436710552); +cljs.core.cst$kw$name = new cljs.core.Keyword(null,"name","name",1843675177); +cljs.core.cst$sym$NaN = new cljs.core.Symbol(null,"NaN","NaN",666918153,null); +cljs.core.cst$sym$rdr = new cljs.core.Symbol(null,"rdr","rdr",190007785,null); +cljs.core.cst$sym$bitmap = new cljs.core.Symbol(null,"bitmap","bitmap",501334601,null); +cljs.core.cst$sym$_seq = new cljs.core.Symbol(null,"_seq","_seq",-449557847,null); +cljs.core.cst$sym$nil_DASH_val = new cljs.core.Symbol(null,"nil-val","nil-val",-513933559,null); +cljs.core.cst$kw$value = new cljs.core.Keyword(null,"value","value",305978217); +cljs.core.cst$kw$child_DASH_of = new cljs.core.Keyword(null,"child-of","child-of",-903376662); +cljs.core.cst$sym$let = new cljs.core.Symbol(null,"let","let",358118826,null); +cljs.core.cst$kw$file = new cljs.core.Keyword(null,"file","file",-1269645878); +cljs.core.cst$sym$cljs$core_SLASH_concat = new cljs.core.Symbol("cljs.core","concat","cljs.core/concat",-1133584918,null); +cljs.core.cst$kw$re_DASH_frame$router_SLASH_fsm_DASH_trigger = new cljs.core.Keyword("re-frame.router","fsm-trigger","re-frame.router/fsm-trigger",1379787274); +cljs.core.cst$sym$v = new cljs.core.Symbol(null,"v","v",1661996586,null); +cljs.core.cst$kw$operation = new cljs.core.Keyword(null,"operation","operation",-1267664310); +cljs.core.cst$kw$valid_DASH_hooks = new cljs.core.Keyword(null,"valid-hooks","valid-hooks",-1178341686); +cljs.core.cst$kw$do_DASH_fx = new cljs.core.Keyword(null,"do-fx","do-fx",1194163050); +cljs.core.cst$kw$end_DASH_column = new cljs.core.Keyword(null,"end-column","end-column",1425389514); +cljs.core.cst$sym$riter = new cljs.core.Symbol(null,"riter","riter",-237834262,null); +cljs.core.cst$sym$__hash = new cljs.core.Symbol(null,"__hash","__hash",-1328796629,null); +cljs.core.cst$sym$meta = new cljs.core.Symbol(null,"meta","meta",-1154898805,null); +cljs.core.cst$sym$_meta = new cljs.core.Symbol(null,"_meta","_meta",-1716892533,null); +cljs.core.cst$kw$start = new cljs.core.Keyword(null,"start","start",-355208981); +cljs.core.cst$kw$app_DASH_db_DASH_before = new cljs.core.Keyword(null,"app-db-before","app-db-before",-1442902645); +cljs.core.cst$sym$afn = new cljs.core.Symbol(null,"afn","afn",216963467,null); +cljs.core.cst$sym$tree = new cljs.core.Symbol(null,"tree","tree",1444219499,null); +cljs.core.cst$sym$fn = new cljs.core.Symbol(null,"fn","fn",465265323,null); +cljs.core.cst$sym$front = new cljs.core.Symbol(null,"front","front",117022539,null); +cljs.core.cst$sym$buf = new cljs.core.Symbol(null,"buf","buf",1426618187,null); +cljs.core.cst$kw$component_DASH_did_DASH_update = new cljs.core.Keyword(null,"component-did-update","component-did-update",-1468549173); +cljs.core.cst$sym$next_DASH_entry = new cljs.core.Symbol(null,"next-entry","next-entry",1091342476,null); +cljs.core.cst$kw$read_DASH_cond = new cljs.core.Keyword(null,"read-cond","read-cond",1056899244); +cljs.core.cst$kw$val = new cljs.core.Keyword(null,"val","val",128701612); +cljs.core.cst$sym$key = new cljs.core.Symbol(null,"key","key",124488940,null); +cljs.core.cst$kw$dispatch_DASH_n = new cljs.core.Keyword(null,"dispatch-n","dispatch-n",-504469236); +cljs.core.cst$sym$_next = new cljs.core.Symbol(null,"_next","_next",101877036,null); +cljs.core.cst$sym$fsm_DASH_state = new cljs.core.Symbol(null,"fsm-state","fsm-state",-998125236,null); +cljs.core.cst$kw$type = new cljs.core.Keyword(null,"type","type",1174270348); +cljs.core.cst$kw$unknown_DASH_view = new cljs.core.Keyword(null,"unknown-view","unknown-view",-324262388); +cljs.core.cst$sym$root_DASH_iter = new cljs.core.Symbol(null,"root-iter","root-iter",1974672108,null); +cljs.core.cst$sym$do = new cljs.core.Symbol(null,"do","do",1686842252,null); +cljs.core.cst$sym$vec = new cljs.core.Symbol(null,"vec","vec",982683596,null); +cljs.core.cst$kw$duration = new cljs.core.Keyword(null,"duration","duration",1444101068); +cljs.core.cst$kw$debug = new cljs.core.Keyword(null,"debug","debug",-1608172596); +cljs.core.cst$sym$when = new cljs.core.Symbol(null,"when","when",1064114221,null); +cljs.core.cst$kw$query_DASH_v = new cljs.core.Keyword(null,"query-v","query-v",-1514170131); +cljs.core.cst$kw$preserve = new cljs.core.Keyword(null,"preserve","preserve",1276846509); +cljs.core.cst$kw$fallback_DASH_impl = new cljs.core.Keyword(null,"fallback-impl","fallback-impl",-1501286995); +cljs.core.cst$kw$keyword_DASH_fn = new cljs.core.Keyword(null,"keyword-fn","keyword-fn",-64566675); +cljs.core.cst$sym$Inf = new cljs.core.Symbol(null,"Inf","Inf",647172781,null); +cljs.core.cst$kw$source = new cljs.core.Keyword(null,"source","source",-433931539); +cljs.core.cst$kw$flush_DASH_on_DASH_newline = new cljs.core.Keyword(null,"flush-on-newline","flush-on-newline",-151457939); +cljs.core.cst$kw$env = new cljs.core.Keyword(null,"env","env",-1815813235); +cljs.core.cst$sym$default_DASH_dispatch_DASH_val = new cljs.core.Symbol(null,"default-dispatch-val","default-dispatch-val",-1231201266,null); +cljs.core.cst$kw$componentWillUnmount = new cljs.core.Keyword(null,"componentWillUnmount","componentWillUnmount",1573788814); +cljs.core.cst$kw$no_DASH_test = new cljs.core.Keyword(null,"no-test","no-test",-1679482642); +cljs.core.cst$kw$string = new cljs.core.Keyword(null,"string","string",-1989541586); +cljs.core.cst$sym$queue = new cljs.core.Symbol(null,"queue","queue",-1198599890,null); +cljs.core.cst$kw$vector = new cljs.core.Keyword(null,"vector","vector",1902966158); +cljs.core.cst$sym$validator = new cljs.core.Symbol(null,"validator","validator",-325659154,null); +cljs.core.cst$kw$illegal_DASH_argument = new cljs.core.Keyword(null,"illegal-argument","illegal-argument",-1845493170); +cljs.core.cst$sym$letfn_STAR_ = new cljs.core.Symbol(null,"letfn*","letfn*",-110097810,null); +cljs.core.cst$kw$deregister_DASH_event_DASH_handler = new cljs.core.Keyword(null,"deregister-event-handler","deregister-event-handler",-1096518994); +cljs.core.cst$sym$if = new cljs.core.Symbol(null,"if","if",1181717262,null); +cljs.core.cst$sym$readable = new cljs.core.Symbol(null,"readable","readable",2113054478,null); +cljs.core.cst$sym$cljs$core_SLASH_with_DASH_meta = new cljs.core.Symbol("cljs.core","with-meta","cljs.core/with-meta",749126446,null); +cljs.core.cst$sym$arr = new cljs.core.Symbol(null,"arr","arr",2115492975,null); +cljs.core.cst$sym$new = new cljs.core.Symbol(null,"new","new",-444906321,null); +cljs.core.cst$kw$strable = new cljs.core.Keyword(null,"strable","strable",1877668047); +cljs.core.cst$kw$descendants = new cljs.core.Keyword(null,"descendants","descendants",1824886031); +cljs.core.cst$kw$unknown_DASH_reference_DASH_type = new cljs.core.Keyword(null,"unknown-reference-type","unknown-reference-type",-472552113); +cljs.core.cst$kw$allow = new cljs.core.Keyword(null,"allow","allow",-1857325745); +cljs.core.cst$sym$ns = new cljs.core.Symbol(null,"ns","ns",2082130287,null); +cljs.core.cst$kw$running = new cljs.core.Keyword(null,"running","running",1554969103); +cljs.core.cst$kw$sym = new cljs.core.Keyword(null,"sym","sym",-1444860305); +cljs.core.cst$kw$column = new cljs.core.Keyword(null,"column","column",2078222095); +cljs.core.cst$sym$completed = new cljs.core.Symbol(null,"completed","completed",1154475024,null); +cljs.core.cst$kw$shouldComponentUpdate = new cljs.core.Keyword(null,"shouldComponentUpdate","shouldComponentUpdate",1795750960); +cljs.core.cst$kw$ancestors = new cljs.core.Keyword(null,"ancestors","ancestors",-776045424); +cljs.core.cst$kw$invalid_DASH_hooks = new cljs.core.Keyword(null,"invalid-hooks","invalid-hooks",926439600); +cljs.core.cst$kw$flush_DASH_dom = new cljs.core.Keyword(null,"flush-dom","flush-dom",-933676816); +cljs.core.cst$kw$style = new cljs.core.Keyword(null,"style","style",-496642736); +cljs.core.cst$sym$value = new cljs.core.Symbol(null,"value","value",1946509744,null); +cljs.core.cst$sym$name = new cljs.core.Symbol(null,"name","name",-810760592,null); +cljs.core.cst$kw$trim_DASH_v = new cljs.core.Keyword(null,"trim-v","trim-v",-1274938640); +cljs.core.cst$sym$frames = new cljs.core.Symbol(null,"frames","frames",-888748272,null); +cljs.core.cst$kw$readably = new cljs.core.Keyword(null,"readably","readably",1129599760); +cljs.core.cst$sym$meta9267 = new cljs.core.Symbol(null,"meta9267","meta9267",-292538576,null); +cljs.core.cst$sym$pfn = new cljs.core.Symbol(null,"pfn","pfn",-513383568,null); +cljs.core.cst$kw$more_DASH_marker = new cljs.core.Keyword(null,"more-marker","more-marker",-14717935); +cljs.core.cst$kw$dispatch = new cljs.core.Keyword(null,"dispatch","dispatch",1319337009); +cljs.core.cst$sym$fields = new cljs.core.Symbol(null,"fields","fields",-291534703,null); +cljs.core.cst$sym$scheduled_QMARK_ = new cljs.core.Symbol(null,"scheduled?","scheduled?",579986609,null); +cljs.core.cst$sym$method_DASH_cache = new cljs.core.Symbol(null,"method-cache","method-cache",1230193905,null); +cljs.core.cst$sym$dirty_QMARK_ = new cljs.core.Symbol(null,"dirty?","dirty?",-419314319,null); +cljs.core.cst$kw$reagentRender = new cljs.core.Keyword(null,"reagentRender","reagentRender",-358306383); +cljs.core.cst$sym$edit = new cljs.core.Symbol(null,"edit","edit",-1302639,null); +cljs.core.cst$kw$_LT__GT_ = new cljs.core.Keyword(null,"<>","<>",1280186386); +cljs.core.cst$kw$event_SLASH_handler = new cljs.core.Keyword("event","handler","event/handler",-295903150); +cljs.core.cst$sym$editable_QMARK_ = new cljs.core.Symbol(null,"editable?","editable?",-164945806,null); +cljs.core.cst$sym$base_DASH_count = new cljs.core.Symbol(null,"base-count","base-count",-1180647182,null); +cljs.core.cst$kw$no_DASH_cache = new cljs.core.Keyword(null,"no-cache","no-cache",1588056370); +cljs.core.cst$kw$render = new cljs.core.Keyword(null,"render","render",-1408033454); +cljs.core.cst$kw$illegal_DASH_state = new cljs.core.Keyword(null,"illegal-state","illegal-state",-1519851182); +cljs.core.cst$kw$db_DASH_handler = new cljs.core.Keyword(null,"db-handler","db-handler",579530098); +cljs.core.cst$sym$clojure$core_SLASH_unquote_DASH_splicing = new cljs.core.Symbol("clojure.core","unquote-splicing","clojure.core/unquote-splicing",-552003150,null); +cljs.core.cst$sym$collision_DASH_hash = new cljs.core.Symbol(null,"collision-hash","collision-hash",-35831342,null); +cljs.core.cst$sym$deftype_STAR_ = new cljs.core.Symbol(null,"deftype*","deftype*",962659890,null); +cljs.core.cst$kw$event = new cljs.core.Keyword(null,"event","event",301435442); +cljs.core.cst$sym$let_STAR_ = new cljs.core.Symbol(null,"let*","let*",1920721458,null); +cljs.core.cst$kw$after = new cljs.core.Keyword(null,"after","after",594996914); +cljs.core.cst$sym$start = new cljs.core.Symbol(null,"start","start",1285322546,null); +cljs.core.cst$kw$splicing_QMARK_ = new cljs.core.Keyword(null,"splicing?","splicing?",-428596366); +cljs.core.cst$sym$sourceIter = new cljs.core.Symbol(null,"sourceIter","sourceIter",1068220306,null); +cljs.core.cst$sym$coll = new cljs.core.Symbol(null,"coll","coll",-1006698606,null); +cljs.core.cst$kw$components = new cljs.core.Keyword(null,"components","components",-1073188942); +cljs.core.cst$sym$not_DASH_native = new cljs.core.Symbol(null,"not-native","not-native",-236392494,null); +cljs.core.cst$sym$js_STAR_ = new cljs.core.Symbol(null,"js*","js*",-1134233646,null); +cljs.core.cst$kw$reagent_DASH_render = new cljs.core.Keyword(null,"reagent-render","reagent-render",-985383853); +cljs.core.cst$sym$strobj = new cljs.core.Symbol(null,"strobj","strobj",1088091283,null); +cljs.core.cst$kw$line = new cljs.core.Keyword(null,"line","line",212345235); +cljs.core.cst$sym$_rest = new cljs.core.Symbol(null,"_rest","_rest",-2100466189,null); +cljs.core.cst$kw$list = new cljs.core.Keyword(null,"list","list",765357683); +cljs.core.cst$sym$fn_STAR_ = new cljs.core.Symbol(null,"fn*","fn*",-752876845,null); +cljs.core.cst$sym$val = new cljs.core.Symbol(null,"val","val",1769233139,null); +cljs.core.cst$kw$on_DASH_write = new cljs.core.Keyword(null,"on-write","on-write",31519475); +cljs.core.cst$kw$keyword = new cljs.core.Keyword(null,"keyword","keyword",811389747); +cljs.core.cst$sym$ascending_QMARK_ = new cljs.core.Symbol(null,"ascending?","ascending?",-1938452653,null); +cljs.core.cst$sym$recur = new cljs.core.Symbol(null,"recur","recur",1202958259,null); +cljs.core.cst$sym$xf = new cljs.core.Symbol(null,"xf","xf",2042434515,null); +cljs.core.cst$sym$ci = new cljs.core.Symbol(null,"ci","ci",2049808339,null); +cljs.core.cst$kw$event_SLASH_do_DASH_fx = new cljs.core.Keyword("event","do-fx","event/do-fx",1357330452); +cljs.core.cst$kw$print_DASH_length = new cljs.core.Keyword(null,"print-length","print-length",1931866356); +cljs.core.cst$kw$col = new cljs.core.Keyword(null,"col","col",-1959363084); +cljs.core.cst$kw$id = new cljs.core.Keyword(null,"id","id",-1388402092); +cljs.core.cst$sym$ratom = new cljs.core.Symbol(null,"ratom","ratom",1514010260,null); +cljs.core.cst$kw$class = new cljs.core.Keyword(null,"class","class",-2030961996); +cljs.core.cst$sym$state = new cljs.core.Symbol(null,"state","state",-348086572,null); +cljs.core.cst$kw$effects = new cljs.core.Keyword(null,"effects","effects",-282369292); +cljs.core.cst$kw$ok = new cljs.core.Keyword(null,"ok","ok",967785236); +cljs.core.cst$sym$vals = new cljs.core.Symbol(null,"vals","vals",-1886377036,null); +cljs.core.cst$sym$meta1501 = new cljs.core.Symbol(null,"meta1501","meta1501",804497396,null); +cljs.core.cst$sym$all = new cljs.core.Symbol(null,"all","all",-1762306027,null); +cljs.core.cst$sym$clojure$core_SLASH_deref = new cljs.core.Symbol("clojure.core","deref","clojure.core/deref",188719157,null); +cljs.core.cst$kw$cljs$core_SLASH_halt = new cljs.core.Keyword("cljs.core","halt","cljs.core/halt",-1049036715); +cljs.core.cst$kw$opts = new cljs.core.Keyword(null,"opts","opts",155075701); +cljs.core.cst$kw$nil = new cljs.core.Keyword(null,"nil","nil",99600501); +cljs.core.cst$sym$cached_DASH_hierarchy = new cljs.core.Symbol(null,"cached-hierarchy","cached-hierarchy",-1085460203,null); +cljs.core.cst$kw$auto_DASH_run = new cljs.core.Keyword(null,"auto-run","auto-run",1958400437); +cljs.core.cst$sym$s = new cljs.core.Symbol(null,"s","s",-948495851,null); +cljs.core.cst$kw$parents = new cljs.core.Keyword(null,"parents","parents",-2027538891); +cljs.core.cst$sym$cnt = new cljs.core.Symbol(null,"cnt","cnt",1924510325,null); +cljs.core.cst$sym$_SLASH_ = new cljs.core.Symbol(null,"/","/",-1371932971,null); +cljs.core.cst$kw$run_DASH_queue = new cljs.core.Keyword(null,"run-queue","run-queue",-1701798027); +cljs.core.cst$sym$node = new cljs.core.Symbol(null,"node","node",-2073234571,null); +cljs.core.cst$kw$component_DASH_will_DASH_unmount = new cljs.core.Keyword(null,"component-will-unmount","component-will-unmount",-2058314698); +cljs.core.cst$sym$sym = new cljs.core.Symbol(null,"sym","sym",195671222,null); +cljs.core.cst$sym$column = new cljs.core.Symbol(null,"column","column",-576213674,null); +cljs.core.cst$sym$sb = new cljs.core.Symbol(null,"sb","sb",-1249746442,null); +cljs.core.cst$kw$stack = new cljs.core.Keyword(null,"stack","stack",-793405930); +cljs.core.cst$sym$clojure$core_SLASH_unquote = new cljs.core.Symbol("clojure.core","unquote","clojure.core/unquote",843087510,null); +cljs.core.cst$sym$seed = new cljs.core.Symbol(null,"seed","seed",1709144854,null); +cljs.core.cst$kw$end_DASH_line = new cljs.core.Keyword(null,"end-line","end-line",1837326455); +cljs.core.cst$kw$unknown_DASH_key = new cljs.core.Keyword(null,"unknown-key","unknown-key",255305911); +cljs.core.cst$sym$prev_DASH_seed = new cljs.core.Symbol(null,"prev-seed","prev-seed",2126381367,null); +cljs.core.cst$sym$buf_DASH_pos = new cljs.core.Symbol(null,"buf-pos","buf-pos",-807229033,null); +cljs.core.cst$kw$display_DASH_name = new cljs.core.Keyword(null,"display-name","display-name",694513143); +cljs.core.cst$kw$scheduled = new cljs.core.Keyword(null,"scheduled","scheduled",553898551); +cljs.core.cst$sym$cljs$core_SLASH_vec = new cljs.core.Symbol("cljs.core","vec","cljs.core/vec",307622519,null); +cljs.core.cst$sym$_DASH_Inf = new cljs.core.Symbol(null,"-Inf","-Inf",-2123243689,null); +cljs.core.cst$sym$_hash = new cljs.core.Symbol(null,"_hash","_hash",-2130838312,null); +cljs.core.cst$kw$on_DASH_dispose = new cljs.core.Keyword(null,"on-dispose","on-dispose",2105306360); +cljs.core.cst$kw$cached_QMARK_ = new cljs.core.Keyword(null,"cached?","cached?",86081880); +cljs.core.cst$kw$sub_SLASH_dispose = new cljs.core.Keyword("sub","dispose","sub/dispose",365440536); +cljs.core.cst$sym$cljs$core_SLASH_sequence = new cljs.core.Symbol("cljs.core","sequence","cljs.core/sequence",1908459032,null); +cljs.core.cst$kw$pause = new cljs.core.Keyword(null,"pause","pause",-2095325672); +cljs.core.cst$kw$error = new cljs.core.Keyword(null,"error","error",-978969032); +cljs.core.cst$kw$regex = new cljs.core.Keyword(null,"regex","regex",939488856); +cljs.core.cst$kw$componentFunction = new cljs.core.Keyword(null,"componentFunction","componentFunction",825866104); +cljs.core.cst$kw$exception = new cljs.core.Keyword(null,"exception","exception",-335277064); +cljs.core.cst$sym$keys = new cljs.core.Symbol(null,"keys","keys",-1586012071,null); +cljs.core.cst$kw$coeffects = new cljs.core.Keyword(null,"coeffects","coeffects",497912985); +cljs.core.cst$kw$input_DASH_signals = new cljs.core.Keyword(null,"input-signals","input-signals",563633497); +cljs.core.cst$sym$set_BANG_ = new cljs.core.Symbol(null,"set!","set!",250714521,null); +cljs.core.cst$kw$unsupported_DASH_operation = new cljs.core.Keyword(null,"unsupported-operation","unsupported-operation",1890540953); +cljs.core.cst$sym$splicing_QMARK_ = new cljs.core.Symbol(null,"splicing?","splicing?",1211935161,null); +cljs.core.cst$kw$form = new cljs.core.Keyword(null,"form","form",-1624062471); +cljs.core.cst$kw$tag = new cljs.core.Keyword(null,"tag","tag",-1290361223); +cljs.core.cst$sym$tree_DASH_map = new cljs.core.Symbol(null,"tree-map","tree-map",1373073049,null); +cljs.core.cst$kw$interceptors = new cljs.core.Keyword(null,"interceptors","interceptors",-1546782951); +cljs.core.cst$sym$_DOT_ = new cljs.core.Symbol(null,".",".",1975675962,null); +cljs.core.cst$kw$re_DASH_frame_DASH_path_SLASH_db_DASH_store = new cljs.core.Keyword("re-frame-path","db-store","re-frame-path/db-store",655758490); +cljs.core.cst$sym$var = new cljs.core.Symbol(null,"var","var",870848730,null); +cljs.core.cst$kw$mutable = new cljs.core.Keyword(null,"mutable","mutable",875778266); +cljs.core.cst$sym$quote = new cljs.core.Symbol(null,"quote","quote",1377916282,null); +cljs.core.cst$kw$set = new cljs.core.Keyword(null,"set","set",304602554); +cljs.core.cst$sym$line_DASH_start_QMARK_ = new cljs.core.Symbol(null,"line-start?","line-start?",1357012474,null); +cljs.core.cst$sym$root = new cljs.core.Symbol(null,"root","root",1191874074,null); +cljs.core.cst$sym$multi = new cljs.core.Symbol(null,"multi","multi",1450238522,null); +cljs.core.cst$kw$end = new cljs.core.Keyword(null,"end","end",-268185958); +cljs.core.cst$sym$str = new cljs.core.Symbol(null,"str","str",-1564826950,null); +cljs.core.cst$sym$next = new cljs.core.Symbol(null,"next","next",1522830042,null); +cljs.core.cst$kw$on_DASH_changes = new cljs.core.Keyword(null,"on-changes","on-changes",1345912602); +cljs.core.cst$sym$nodes = new cljs.core.Symbol(null,"nodes","nodes",-459054278,null); +cljs.core.cst$sym$seen = new cljs.core.Symbol(null,"seen","seen",1121531738,null); +cljs.core.cst$sym$hash_DASH_map = new cljs.core.Symbol(null,"hash-map","hash-map",-439030950,null); +cljs.core.cst$sym$line = new cljs.core.Symbol(null,"line","line",1852876762,null); +cljs.core.cst$kw$groupEnd = new cljs.core.Keyword(null,"groupEnd","groupEnd",-337721382); +cljs.core.cst$kw$ctx_DASH_handler = new cljs.core.Keyword(null,"ctx-handler","ctx-handler",-1777672230); +cljs.core.cst$kw$atom = new cljs.core.Keyword(null,"atom","atom",-397043653); +cljs.core.cst$kw$trigger = new cljs.core.Keyword(null,"trigger","trigger",103466139); +cljs.core.cst$kw$unknown_DASH_component = new cljs.core.Keyword(null,"unknown-component","unknown-component",-530928453); +cljs.core.cst$kw$eof = new cljs.core.Keyword(null,"eof","eof",-489063237); +cljs.core.cst$kw$autobind = new cljs.core.Keyword(null,"autobind","autobind",-570650245); +cljs.core.cst$kw$hierarchy = new cljs.core.Keyword(null,"hierarchy","hierarchy",-1053470341); +cljs.core.cst$sym$catch = new cljs.core.Symbol(null,"catch","catch",-1616370245,null); +cljs.core.cst$kw$cofx = new cljs.core.Keyword(null,"cofx","cofx",2013202907); +cljs.core.cst$sym$s_DASH_len = new cljs.core.Symbol(null,"s-len","s-len",1869978331,null); +cljs.core.cst$kw$alt_DASH_impl = new cljs.core.Keyword(null,"alt-impl","alt-impl",670969595); +cljs.core.cst$kw$resume = new cljs.core.Keyword(null,"resume","resume",-118572261); +cljs.core.cst$sym$ext_DASH_map_DASH_iter = new cljs.core.Symbol(null,"ext-map-iter","ext-map-iter",-1215982757,null); +cljs.core.cst$kw$ms = new cljs.core.Keyword(null,"ms","ms",-1152709733); +cljs.core.cst$sym$tail = new cljs.core.Symbol(null,"tail","tail",494507963,null); +cljs.core.cst$kw$enrich = new cljs.core.Keyword(null,"enrich","enrich",-2108921925); +cljs.core.cst$kw$reaction = new cljs.core.Keyword(null,"reaction","reaction",490869788); +cljs.core.cst$sym$file_DASH_name = new cljs.core.Symbol(null,"file-name","file-name",-13685732,null); +cljs.core.cst$sym$record = new cljs.core.Symbol(null,"record","record",861424668,null); +cljs.core.cst$kw$fx = new cljs.core.Keyword(null,"fx","fx",-1237829572); +cljs.core.cst$sym$meta10806 = new cljs.core.Symbol(null,"meta10806","meta10806",539595900,null); +cljs.core.cst$sym$changed = new cljs.core.Symbol(null,"changed","changed",-2083710852,null); +cljs.core.cst$sym$mseq = new cljs.core.Symbol(null,"mseq","mseq",1602647196,null); +cljs.core.cst$sym$count = new cljs.core.Symbol(null,"count","count",-514511684,null); +cljs.core.cst$kw$before = new cljs.core.Keyword(null,"before","before",-1633692388); +cljs.core.cst$kw$op_DASH_type = new cljs.core.Keyword(null,"op-type","op-type",-1636141668); +cljs.core.cst$kw$keywordize_DASH_keys = new cljs.core.Keyword(null,"keywordize-keys","keywordize-keys",1310784252); +cljs.core.cst$sym$current = new cljs.core.Symbol(null,"current","current",552492924,null); +cljs.core.cst$sym$off = new cljs.core.Symbol(null,"off","off",-2047994980,null); +cljs.core.cst$kw$log = new cljs.core.Keyword(null,"log","log",-1595516004); +cljs.core.cst$sym$auto_DASH_run = new cljs.core.Symbol(null,"auto-run","auto-run",-696035332,null); +cljs.core.cst$kw$unsupported_DASH_type = new cljs.core.Keyword(null,"unsupported-type","unsupported-type",-734728196); +cljs.core.cst$sym$stack = new cljs.core.Symbol(null,"stack","stack",847125597,null); +cljs.core.cst$kw$re_DASH_frame$std_DASH_interceptors_SLASH_untrimmed_DASH_event = new cljs.core.Keyword("re-frame.std-interceptors","untrimmed-event","re-frame.std-interceptors/untrimmed-event",-840935075); +cljs.core.cst$sym$cljs$core_SLASH_hash_DASH_set = new cljs.core.Symbol("cljs.core","hash-set","cljs.core/hash-set",1130426749,null); +cljs.core.cst$sym$transient_DASH_map = new cljs.core.Symbol(null,"transient-map","transient-map",351764893,null); +cljs.core.cst$kw$character = new cljs.core.Keyword(null,"character","character",380652989); +cljs.core.cst$kw$map = new cljs.core.Keyword(null,"map","map",1371690461); +cljs.core.cst$sym$cljs$core_SLASH_list = new cljs.core.Symbol("cljs.core","list","cljs.core/list",-1331406371,null); +cljs.core.cst$kw$eofthrow = new cljs.core.Keyword(null,"eofthrow","eofthrow",-334166531); +cljs.core.cst$kw$finish_DASH_run = new cljs.core.Keyword(null,"finish-run","finish-run",753148477); +cljs.core.cst$sym$prev = new cljs.core.Symbol(null,"prev","prev",43462301,null); +cljs.core.cst$sym$len = new cljs.core.Symbol(null,"len","len",-1230778691,null); +cljs.core.cst$kw$componentWillMount = new cljs.core.Keyword(null,"componentWillMount","componentWillMount",-285327619); +cljs.core.cst$kw$test = new cljs.core.Keyword(null,"test","test",577538877); +cljs.core.cst$sym$right = new cljs.core.Symbol(null,"right","right",1187949694,null); +cljs.core.cst$sym$buf_DASH_len = new cljs.core.Symbol(null,"buf-len","buf-len",404510846,null); +cljs.core.cst$kw$runtime_DASH_exception = new cljs.core.Keyword(null,"runtime-exception","runtime-exception",-1495664514); +cljs.core.cst$sym$throw = new cljs.core.Symbol(null,"throw","throw",595905694,null); +cljs.core.cst$kw$none = new cljs.core.Keyword(null,"none","none",1333468478); +cljs.core.cst$kw$buffer = new cljs.core.Keyword(null,"buffer","buffer",617295198); +cljs.core.cst$kw$invalid_DASH_extension_DASH_keys = new cljs.core.Keyword(null,"invalid-extension-keys","invalid-extension-keys",-164289122); +cljs.core.cst$sym$fseq = new cljs.core.Symbol(null,"fseq","fseq",-1466412450,null); +cljs.core.cst$sym$nocache_QMARK_ = new cljs.core.Symbol(null,"nocache?","nocache?",-1065670978,null); +cljs.core.cst$kw$dispatch_DASH_later = new cljs.core.Keyword(null,"dispatch-later","dispatch-later",291951390); +cljs.core.cst$kw$message = new cljs.core.Keyword(null,"message","message",-406056002); +cljs.core.cst$kw$view = new cljs.core.Keyword(null,"view","view",1247994814); +cljs.core.cst$kw$cljs$core_SLASH_not_DASH_found = new cljs.core.Keyword("cljs.core","not-found","cljs.core/not-found",-1572889185); +cljs.core.cst$sym$more = new cljs.core.Symbol(null,"more","more",-418290273,null); +cljs.core.cst$sym$def = new cljs.core.Symbol(null,"def","def",597100991,null); +cljs.core.cst$kw$data = new cljs.core.Keyword(null,"data","data",-232669377); +cljs.core.cst$sym$f = new cljs.core.Symbol(null,"f","f",43394975,null); +cljs.core.cst$sym$next_DASH_iter = new cljs.core.Symbol(null,"next-iter","next-iter",1526626239,null); diff --git a/js/cljs/nodejs.cljs b/js/cljs/nodejs.cljs new file mode 100644 index 0000000..ca58788 --- /dev/null +++ b/js/cljs/nodejs.cljs @@ -0,0 +1,27 @@ +; Copyright (c) Rich Hickey. All rights reserved. +; The use and distribution terms for this software are covered by the +; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +; which can be found in the file epl-v10.html at the root of this distribution. +; By using this software in any fashion, you are agreeing to be bound by +; the terms of this license. +; You must not remove this notice, or any other, from this software. + +; Projects compiled with :target :nodejs can 'require' this namespace +; to get the nodejs globals loaded into cljs.nodejs and get +; ClojureScript's 'print' set up correctly. +(ns cljs.nodejs + (:refer-clojure :exclude [require])) + +; Define namespaced references to Node's externed globals: +(def require (js* "require")) +(def process (js* "process")) + +(defn enable-util-print! [] + (set! *print-newline* false) + (set-print-fn! + (fn [& args] + (.apply (.-log js/console) js/console (into-array args)))) + (set-print-err-fn! + (fn [& args] + (.apply (.-error js/console) js/console (into-array args)))) + nil) diff --git a/js/cljs/nodejscli.cljs b/js/cljs/nodejscli.cljs new file mode 100644 index 0000000..256a4fa --- /dev/null +++ b/js/cljs/nodejscli.cljs @@ -0,0 +1,22 @@ +; Copyright (c) Rich Hickey. All rights reserved. +; The use and distribution terms for this software are covered by the +; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +; which can be found in the file epl-v10.html at the root of this distribution. +; By using this software in any fashion, you are agreeing to be bound by +; the terms of this license. +; You must not remove this notice, or any other, from this software. + +; Projects compiled with :target :nodejs have this file appended. Its +; job is to make sure cljs.nodejs is loaded and that the *main-cli-fn* +; is called with the script's command-line arguments. +(ns cljs.nodejscli + (:require [cljs.nodejs :as nodejs] + [goog.object :as gobj])) + +;; need to set goog.global if COMPILED +(when ^boolean js/COMPILED + (set! goog/global js/global)) + +;; Call the user's main function +(when (fn? cljs.core/*main-cli-fn*) + (apply cljs.core/*main-cli-fn* (drop 2 (gobj/get js/process "argv")))) diff --git a/js/cljs/tools/reader.cljs b/js/cljs/tools/reader.cljs new file mode 100644 index 0000000..49910da --- /dev/null +++ b/js/cljs/tools/reader.cljs @@ -0,0 +1,944 @@ +;; Copyright (c) Nicola Mometto, Rich Hickey & contributors. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "A clojure reader in clojure" + :author "Bronsa"} + cljs.tools.reader + (:refer-clojure :exclude [read read-line read-string char + default-data-readers *default-data-reader-fn* + *data-readers* *suppress-read*]) + (:require-macros [cljs.tools.reader.reader-types :refer [log-source]]) + (:require [cljs.tools.reader.reader-types :refer + [read-char unread peek-char indexing-reader? + get-line-number get-column-number get-file-name + string-push-back-reader]] + [cljs.tools.reader.impl.utils :refer + [char ex-info? whitespace? numeric? desugar-meta next-id namespace-keys second' + ReaderConditional reader-conditional reader-conditional?]] + [cljs.tools.reader.impl.commons :refer + [number-literal? read-past match-number parse-symbol read-comment throwing-reader]] + [cljs.tools.reader.impl.errors :as err] + [goog.array :as garray] + [goog.string :as gstring]) + (:import goog.string.StringBuffer)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; helpers +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(declare ^:private read* + macros dispatch-macros + ^:dynamic *data-readers* + ^:dynamic *default-data-reader-fn* + ^:dynamic *suppress-read* + default-data-readers) + +(defn- ^boolean macro-terminating? [ch] + (case ch + (\" \; \@ \^ \` \~ \( \) \[ \] \{ \} \\) true + false)) + +(def sb (StringBuffer.)) + +(defn- read-token + "Read in a single logical token from the reader" + [^not-native rdr kind initch] + (if (nil? initch) + (err/throw-eof-at-start rdr kind) + (do + (.clear sb) + (loop [ch initch] + (if (or (whitespace? ch) + (macro-terminating? ch) + (nil? ch)) + (do + (when-not (nil? ch) + (unread rdr ch)) + (.toString sb)) + (do + (.append sb ch) + (recur (read-char rdr)))))))) + +(declare read-tagged) + +(defn- read-dispatch + [^not-native rdr _ opts pending-forms] + (if-let [ch (read-char rdr)] + (if-let [dm (dispatch-macros ch)] + (dm rdr ch opts pending-forms) + (read-tagged (doto rdr (unread ch)) ch opts pending-forms)) ;; ctor reader is implemented as a tagged literal + (err/throw-eof-at-dispatch rdr))) + +(defn- read-unmatched-delimiter + [rdr ch opts pending-forms] + (err/throw-unmatch-delimiter rdr ch)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; readers +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defn read-regex + [^not-native rdr ch opts pending-forms] + (let [sb (StringBuffer.)] + (loop [ch (read-char rdr)] + (if (identical? \" ch) + (re-pattern (str sb)) + (if (nil? ch) + (err/throw-eof-reading rdr :regex sb) + (do + (.append sb ch ) + (when (identical? \\ ch) + (let [ch (read-char rdr)] + (if (nil? ch) + (err/throw-eof-reading rdr :regex sb)) + (.append sb ch))) + (recur (read-char rdr)))))))) + +(defn- char-code [ch base] + (let [code (js/parseInt ch base)] + (if (js/isNaN code) + -1 + code))) + +(defn- read-unicode-char + ([token offset length base] + (let [l (+ offset length)] + (when-not (== (count token) l) + (err/throw-invalid-unicode-literal nil token)) + (loop [i offset uc 0] + (if (== i l) + (js/String.fromCharCode uc) + (let [d (char-code (nth token i) base)] + (if (== d -1) + (err/throw-invalid-unicode-digit-in-token nil (nth token i) token) + (recur (inc i) (+ d (* uc base))))))))) + + ([^not-native rdr initch base length exact?] + (loop [i 1 uc (char-code initch base)] + (if (== uc -1) + (err/throw-invalid-unicode-digit rdr initch) + (if-not (== i length) + (let [ch (peek-char rdr)] + (if (or (whitespace? ch) + (macros ch) + (nil? ch)) + (if exact? + (err/throw-invalid-unicode-len rdr i length) + (js/String.fromCharCode uc)) + (let [d (char-code ch base)] + (read-char rdr) + (if (== d -1) + (err/throw-invalid-unicode-digit rdr ch) + (recur (inc i) (+ d (* uc base))))))) + (js/String.fromCharCode uc)))))) + +(def ^:private ^:const upper-limit (.charCodeAt \uD7ff 0)) +(def ^:private ^:const lower-limit (.charCodeAt \uE000 0)) + +(defn- valid-octal? [token base] + (<= (js/parseInt token base) 0377)) + +(defn- read-char* + "Read in a character literal" + [^not-native rdr backslash opts pending-forms] + (let [ch (read-char rdr)] + (if-not (nil? ch) + (let [token (if (or (macro-terminating? ch) + (whitespace? ch)) + (str ch) + (read-token rdr :character ch)) + token-len (. token -length)] + (cond + + (== 1 token-len) (.charAt token 0) ;;; no char type - so can't ensure/cache char + + (= token "newline") \newline + (= token "space") \space + (= token "tab") \tab + (= token "backspace") \backspace + (= token "formfeed") \formfeed + (= token "return") \return + + (gstring/startsWith token "u") + (let [c (read-unicode-char token 1 4 16) + ic (.charCodeAt c 0)] + (if (and (> ic upper-limit) + (< ic lower-limit)) + (err/throw-invalid-character-literal rdr (.toString ic 16)) + c)) + + (gstring/startsWith token "o") + (let [len (dec token-len)] + (if (> len 3) + (err/throw-invalid-octal-len rdr token) + (let [offset 1 + base 8 + uc (read-unicode-char token offset len base)] + (if-not (valid-octal? (subs token offset) base) + (err/throw-bad-octal-number rdr) + uc)))) + + :else (err/throw-unsupported-character rdr token))) + (err/throw-eof-in-character rdr)))) + +(defn- starting-line-col-info [^not-native rdr] + (when (indexing-reader? rdr) + [(get-line-number rdr) (int (dec (get-column-number rdr)))])) + +(defn- ending-line-col-info [^not-native rdr] + (when (indexing-reader? rdr) + [(get-line-number rdr) (get-column-number rdr)])) + +(defonce ^:private READ_EOF (js/Object.)) +(defonce ^:private READ_FINISHED (js/Object.)) + +(def ^:dynamic *read-delim* false) + +(defn- read-delimited-internal [kind delim rdr opts pending-forms] + (let [[start-line start-column] (starting-line-col-info rdr) + delim (char delim)] + (loop [a (transient [])] + (let [form (read* rdr false READ_EOF delim opts pending-forms)] + (if (identical? form READ_FINISHED) + (persistent! a) + (if (identical? form READ_EOF) + (err/throw-eof-delimited rdr kind start-line start-column (count a)) + (recur (conj! a form)))))))) + +(defn- read-delimited + "Reads and returns a collection ended with delim" + [kind delim rdr opts pending-forms] + (binding [*read-delim* true] + (read-delimited-internal kind delim rdr opts pending-forms))) + +(defn- read-list + "Read in a list, including its location if the reader is an indexing reader" + [rdr _ opts pending-forms] + (let [[start-line start-column] (starting-line-col-info rdr) + the-list (read-delimited :list \) rdr opts pending-forms) + [end-line end-column] (ending-line-col-info rdr)] + (with-meta (if (empty? the-list) + '() + (apply list the-list)) + (when start-line + (merge + (when-let [file (get-file-name rdr)] + {:file file}) + {:line start-line + :column start-column + :end-line end-line + :end-column end-column}))))) + +(defn- read-vector + "Read in a vector, including its location if the reader is an indexing reader" + [rdr _ opts pending-forms] + (let [[start-line start-column] (starting-line-col-info rdr) + the-vector (read-delimited :vector \] rdr opts pending-forms) + [end-line end-column] (ending-line-col-info rdr)] + (with-meta the-vector + (when start-line + (merge + (when-let [file (get-file-name rdr)] + {:file file}) + {:line start-line + :column start-column + :end-line end-line + :end-column end-column}))))) + +(defn- read-map + "Read in a map, including its location if the reader is an indexing reader" + [rdr _ opts pending-forms] + (let [[start-line start-column] (starting-line-col-info rdr) + the-map (read-delimited :map \} rdr opts pending-forms) + map-count (count the-map) + ks (take-nth 2 the-map) + key-set (set ks) + [end-line end-column] (ending-line-col-info rdr)] + (when (odd? map-count) + (err/throw-odd-map rdr start-line start-column the-map)) + (when-not (= (count key-set) (count ks)) + (err/throw-dup-keys rdr :map ks)) + (with-meta + (if (<= map-count (* 2 (.-HASHMAP-THRESHOLD cljs.core/PersistentArrayMap))) + (.fromArray cljs.core/PersistentArrayMap (to-array the-map) true true) + (.fromArray cljs.core/PersistentHashMap (to-array the-map) true)) + (when start-line + (merge + (when-let [file (get-file-name rdr)] + {:file file}) + {:line start-line + :column start-column + :end-line end-line + :end-column end-column}))))) + +(defn- read-number + [^not-native rdr initch] + (loop [sb (doto (StringBuffer.) (.append initch)) + ch (read-char rdr)] + (if (or (whitespace? ch) (macros ch) (nil? ch)) + (let [s (str sb)] + (unread rdr ch) + (or (match-number s) + (err/throw-invalid-number rdr s))) + (recur (doto sb (.append ch)) (read-char rdr))))) + +(defn- escape-char [sb ^not-native rdr] + (let [ch (read-char rdr)] + (case ch + \t "\t" + \r "\r" + \n "\n" + \\ "\\" + \" "\"" + \b "\b" + \f "\f" + \u (let [ch (read-char rdr)] + (if (== -1 (js/parseInt (int ch) 16)) + (err/throw-invalid-unicode-escape rdr ch) + (read-unicode-char rdr ch 16 4 true))) + (if (numeric? ch) + (let [ch (read-unicode-char rdr ch 8 3 false)] + (if (> (int ch) 0377) + (err/throw-bad-octal-number rdr) + ch)) + (err/throw-bad-escape-char rdr ch))))) + +(defn- read-string* + [^not-native reader _ opts pending-forms] + (loop [sb (StringBuffer.) + ch (read-char reader)] + (if (nil? ch) + (err/throw-eof-reading reader :string \" sb) + (case ch + \\ (recur (doto sb (.append (escape-char sb reader))) + (read-char reader)) + \" (str sb) + (recur (doto sb (.append ch)) (read-char reader)))))) + +(defn- loc-info [rdr line column] + (when-not (nil? line) + (let [file (get-file-name rdr) + filem (when-not (nil? file) {:file file}) + [end-line end-column] (ending-line-col-info rdr) + lcm {:line line + :column column + :end-line end-line + :end-column end-column}] + (merge filem lcm)))) + +(defn- read-symbol + [rdr initch] + (let [[line column] (starting-line-col-info rdr) + token (read-token rdr :symbol initch)] + (when-not (nil? token) + (case token + + ;; special symbols + "nil" nil + "true" true + "false" false + "/" '/ + + (let [^not-native p (parse-symbol token)] + (if-not (nil? p) + (let [^not-native sym (symbol (-nth p 0) (-nth p 1))] + (-with-meta sym (loc-info rdr line column))) + (err/throw-invalid rdr :symbol token))))))) + +(def ^:dynamic *alias-map* + "Map from ns alias to ns, if non-nil, it will be used to resolve read-time + ns aliases. + + Defaults to nil" + nil) + +(defn- resolve-alias [sym] + (get *alias-map* sym)) + +(defn- resolve-ns [sym] + (or (resolve-alias sym) + (when-let [ns (find-ns sym)] + (symbol (ns-name ns))))) + +(defn- read-keyword + [^not-native reader initch opts pending-forms] + (let [ch (read-char reader)] + (if-not (whitespace? ch) + (let [token (read-token reader :keyword ch) + ^not-native s (parse-symbol token)] + (if-not (nil? s) + (let [ns (-nth s 0) + name (-nth s 1)] + (if (identical? \: (.charAt token 0)) + (if-not (nil? ns) + (if-let [ns (resolve-alias (symbol (subs ns 1)))] + (keyword (str ns) name) + (err/throw-invalid reader :keyword (str \: token))) + (if-let [ns *ns*] + (keyword (str ns) (subs name 1)) + (err/reader-error reader "Invalid token: :" token))) + (keyword ns name))) + (err/throw-invalid reader :keyword (str \: token)))) + (err/throw-single-colon reader)))) + +(defn- wrapping-reader + "Returns a function which wraps a reader in a call to sym" + [sym] + (fn [rdr _ opts pending-forms] + (list sym (read* rdr true nil opts pending-forms)))) + +(defn- read-meta + "Read metadata and return the following object with the metadata applied" + [rdr _ opts pending-forms] + (log-source rdr + (let [[line column] (starting-line-col-info rdr) + m (desugar-meta (read* rdr true nil opts pending-forms))] + (when-not (map? m) + (err/throw-bad-metadata rdr m)) + (let [o (read* rdr true nil opts pending-forms)] + (if (implements? IMeta o) + (let [m (if (and line (seq? o)) + (assoc m :line line :column column) + m)] + (if (implements? IWithMeta o) + (with-meta o (merge (meta o) m)) + (reset-meta! o m))) + (err/throw-bad-metadata-target rdr o)))))) + +(defn- read-set + [rdr _ opts pending-forms] + (let [[start-line start-column] (starting-line-col-info rdr) + ;; subtract 1 from start-column so it includes the # in the leading #{ + start-column (if start-column (int (dec start-column))) + coll (read-delimited :set \} rdr opts pending-forms) + the-set (set coll) + [end-line end-column] (ending-line-col-info rdr)] + (when-not (= (count coll) (count the-set)) + (err/reader-error rdr (err/throw-dup-keys rdr :set coll))) + (with-meta the-set + (when start-line + (merge + (when-let [file (get-file-name rdr)] + {:file file}) + {:line start-line + :column start-column + :end-line end-line + :end-column end-column}))))) + +(defn- read-discard + "Read and discard the first object from rdr" + [rdr _ opts pending-forms] + (doto rdr + (read* true nil opts pending-forms))) + +(defn- read-symbolic-value + [rdr _ opts pending-forms] + (let [sym (read* rdr true nil opts pending-forms)] + (case sym + + NaN js/Number.NaN + -Inf js/Number.NEGATIVE_INFINITY + Inf js/Number.POSITIVE_INFINITY + + (err/reader-error rdr (str "Invalid token: ##" sym))))) + +(def ^:private RESERVED_FEATURES #{:else :none}) + +(defn- has-feature? + [rdr feature opts] + (if (keyword? feature) + (or (= :default feature) (contains? (get opts :features) feature)) + (err/reader-error rdr "Feature should be a keyword: " feature))) + +(defn- check-eof-error + [form rdr first-line] + (when (identical? form READ_EOF) + (err/throw-eof-error rdr (and (< first-line 0) first-line)))) + +(defn- check-reserved-features + [rdr form] + (when (get RESERVED_FEATURES form) + (err/reader-error rdr "Feature name " form " is reserved"))) + +(defn- check-invalid-read-cond + [form rdr first-line] + (when (identical? form READ_FINISHED) + (if (< first-line 0) + (err/reader-error rdr "read-cond requires an even number of forms") + (err/reader-error rdr "read-cond starting on line " first-line " requires an even number of forms")))) + +(defn- read-suppress + "Read next form and suppress. Return nil or READ_FINISHED." + [first-line rdr opts pending-forms] + (binding [*suppress-read* true] + (let [form (read* rdr false READ_EOF \) opts pending-forms)] + (check-eof-error form rdr first-line) + (when (identical? form READ_FINISHED) + READ_FINISHED)))) + +(defonce ^:private NO_MATCH (js/Object.)) + +(defn- match-feature + "Read next feature. If matched, read next form and return. + Otherwise, read and skip next form, returning READ_FINISHED or nil." + [first-line rdr opts pending-forms] + (let [feature (read* rdr false READ_EOF \) opts pending-forms)] + (check-eof-error feature rdr first-line) + (if (= feature READ_FINISHED) + READ_FINISHED + (do + (check-reserved-features rdr feature) + (if (has-feature? rdr feature opts) + ;; feature matched, read selected form + (doto (read* rdr false READ_EOF \) opts pending-forms) + (check-eof-error rdr first-line) + (check-invalid-read-cond rdr first-line)) + ;; feature not matched, ignore next form + (or (read-suppress first-line rdr opts pending-forms) + NO_MATCH)))))) + +(defn- read-cond-delimited + [rdr splicing opts pending-forms] + (let [first-line (if (indexing-reader? rdr) (get-line-number rdr) -1) + result (loop [matched NO_MATCH + finished nil] + (cond + ;; still looking for match, read feature+form + (identical? matched NO_MATCH) + (let [match (match-feature first-line rdr opts pending-forms)] + (if (identical? match READ_FINISHED) + READ_FINISHED + (recur match nil))) + + ;; found match, just read and ignore the rest + (not (identical? finished READ_FINISHED)) + (recur matched (read-suppress first-line rdr opts pending-forms)) + + :else + matched))] + (if (identical? result READ_FINISHED) + rdr + (if splicing + (do + (if (implements? ISequential result) + (do + (garray/insertArrayAt pending-forms (to-array result) 0) + rdr) + (err/reader-error rdr "Spliced form list in read-cond-splicing must implement ISequential"))) + result)))) + +(defn- read-cond + [^not-native rdr _ opts pending-forms] + (when (not (and opts (#{:allow :preserve} (:read-cond opts)))) + (throw (ex-info "Conditional read not allowed" + {:type :runtime-exception}))) + (if-let [ch (read-char rdr)] + (let [splicing (= ch \@) + ch (if splicing (read-char rdr) ch)] + (when splicing + (when-not *read-delim* + (err/reader-error rdr "cond-splice not in list"))) + (if-let [ch (if (whitespace? ch) (read-past whitespace? rdr) ch)] + (if (not= ch \() + (throw (ex-info "read-cond body must be a list" + {:type :runtime-exception})) + (binding [*suppress-read* (or *suppress-read* (= :preserve (:read-cond opts)))] + (if *suppress-read* + (reader-conditional (read-list rdr ch opts pending-forms) splicing) + (read-cond-delimited rdr splicing opts pending-forms)))) + (err/throw-eof-in-character rdr))) + (err/throw-eof-in-character rdr))) + +(def ^:private ^:dynamic arg-env nil) + +(defn- garg + "Get a symbol for an anonymous ?argument?" + [n] + (symbol (str (if (== -1 n) "rest" (str "p" n)) + "__" (next-id) "#"))) + +(defn- read-fn + [rdr _ opts pending-forms] + (if arg-env + (throw (ex-info "Nested #()s are not allowed" {:type :illegal-state}))) + (binding [arg-env (sorted-map)] + (let [form (read* (doto rdr (unread \()) true nil opts pending-forms) ;; this sets bindings + rargs (rseq arg-env) + args (if rargs + (let [higharg (key (first rargs))] + (let [args (loop [i 1 args (transient [])] + (if (> i higharg) + (persistent! args) + (recur (inc i) (conj! args (or (get arg-env i) + (garg i)))))) + args (if (arg-env -1) + (conj args '& (arg-env -1)) + args)] + args)) + [])] + (list 'fn* args form)))) + +(defn- register-arg + "Registers an argument to the arg-env" + [n] + (if arg-env + (if-let [ret (arg-env n)] + ret + (let [g (garg n)] + (set! arg-env (assoc arg-env n g)) + g)) + (throw (ex-info "Arg literal not in #()" + {:type :illegal-state})))) ;; should never hit this + +(declare read-symbol) + +(defn- read-arg + [^not-native rdr pct opts pending-forms] + (if (nil? arg-env) + (read-symbol rdr pct) + (let [ch (peek-char rdr)] + (cond + (or (whitespace? ch) + (macro-terminating? ch) + (nil? ch)) + (register-arg 1) + + (= ch \&) + (do (read-char rdr) + (register-arg -1)) + + :else + (let [n (read* rdr true nil opts pending-forms)] + (if-not (integer? n) + (throw (ex-info "Arg literal must be %, %& or %integer" + {:type :illegal-state})) + (register-arg n))))))) + +(def ^:private ^:dynamic gensym-env nil) + +(defn- read-unquote + [^not-native rdr comma opts pending-forms] + (if-let [ch (peek-char rdr)] + (if (= \@ ch) + ((wrapping-reader 'clojure.core/unquote-splicing) (doto rdr read-char) \@ opts pending-forms) + ((wrapping-reader 'clojure.core/unquote) rdr \~ opts pending-forms)))) + +(declare syntax-quote*) + +(defn- unquote-splicing? [form] + (and (seq? form) + (= (first form) 'clojure.core/unquote-splicing))) + +(defn- unquote? [form] + (and (seq? form) + (= (first form) 'clojure.core/unquote))) + +(defn- expand-list + "Expand a list by resolving its syntax quotes and unquotes" + [s] + (loop [s (seq s) r (transient [])] + (if s + (let [item (first s) + ret (conj! r + (cond + (unquote? item) (list 'clojure.core/list (second item)) + (unquote-splicing? item) (second item) + :else (list 'clojure.core/list (syntax-quote* item))))] + (recur (next s) ret)) + (seq (persistent! r))))) + +(defn- flatten-map + "Flatten a map into a seq of alternate keys and values" + [form] + (loop [s (seq form) key-vals (transient [])] + (if s + (let [e (first s)] + (recur (next s) (-> key-vals + (conj! (key e)) + (conj! (val e))))) + (seq (persistent! key-vals))))) + +(defn- register-gensym [sym] + (if-not gensym-env + (throw (ex-info "Gensym literal not in syntax-quote" + {:type :illegal-state}))) + (or (get gensym-env sym) + (let [gs (symbol (str (subs (name sym) + 0 (dec (count (name sym)))) + "__" (next-id) "__auto__"))] + (set! gensym-env (assoc gensym-env sym gs)) + gs))) + +(defn- add-meta [form ret] + (if (and (implements? IWithMeta form) + (seq (dissoc (meta form) :line :column :end-line :end-column :file :source))) + (list 'cljs.core/with-meta ret (syntax-quote* (meta form))) + ret)) + +(defn- syntax-quote-coll [type coll] + (let [res (list 'cljs.core/sequence + (cons 'cljs.core/concat + (expand-list coll)))] + (if type + (list 'cljs.core/apply type res) + res))) + +(defn map-func + "Decide which map type to use, array-map if less than 16 elements" + [coll] + (if (>= (count coll) 16) + 'cljs.core/hash-map + 'cljs.core/array-map)) + +(defn bool? [x] + (or (instance? js/Boolean x) + (true? x) + (false? x))) + +(defn ^:dynamic resolve-symbol + "Resolve a symbol s into its fully qualified namespace version" + [s] + (throw (ex-info "resolve-symbol is not implemented" {:sym s}))) + +(defn- syntax-quote* [form] + (->> + (cond + (special-symbol? form) (list 'quote form) + + (symbol? form) + (list 'quote + (if (and (not (namespace form)) + (gstring/endsWith (name form) "#")) + (register-gensym form) + (let [sym (str form)] + (if (gstring/endsWith sym ".") + (let [csym (symbol (subs sym 0 (dec (count sym))))] + (symbol (str (resolve-symbol csym) "."))) + (resolve-symbol form))))) + + (unquote? form) (second form) + (unquote-splicing? form) (throw (ex-info "unquote-splice not in list" + {:type :illegal-state})) + + (coll? form) + (cond + + (implements? IRecord form) form + (map? form) (syntax-quote-coll (map-func form) (flatten-map form)) + (vector? form) (list 'cljs.core/vec (syntax-quote-coll nil form)) + (set? form) (syntax-quote-coll 'cljs.core/hash-set form) + (or (seq? form) (list? form)) + (let [seq (seq form)] + (if seq + (syntax-quote-coll nil seq) + '(cljs.core/list))) + + :else (throw (ex-info "Unknown Collection type" + {:type :unsupported-operation}))) + + (or (keyword? form) + (number? form) + (string? form) + (nil? form) + (bool? form) + (instance? js/RegExp form)) + form + + :else (list 'quote form)) + (add-meta form))) + +(defn- read-syntax-quote + [rdr backquote opts pending-forms] + (binding [gensym-env {}] + (-> (read* rdr true nil opts pending-forms) + syntax-quote*))) + +(defn- read-namespaced-map + [rdr _ opts pending-forms] + (let [token (read-token rdr :namespaced-map (read-char rdr))] + (if-let [ns (cond + (= token ":") + (ns-name *ns*) + + (= \: (first token)) + (some-> token (subs 1) parse-symbol second' symbol resolve-ns) + + :else + (some-> token parse-symbol second'))] + + (let [ch (read-past whitespace? rdr)] + (if (identical? ch \{) + (let [items (read-delimited :namespaced-map \} rdr opts pending-forms)] + (when (odd? (count items)) + (err/throw-odd-map rdr nil nil items)) + (let [keys (namespace-keys (str ns) (take-nth 2 items)) + vals (take-nth 2 (rest items))] + (when-not (= (count (set keys)) (count keys)) + (err/throw-dup-keys rdr :namespaced-map keys)) + (zipmap keys vals))) + (err/throw-ns-map-no-map rdr token))) + (err/throw-bad-ns rdr token)))) + +(defn- macros [ch] + (case ch + \" read-string* + \: read-keyword + \; read-comment + \' (wrapping-reader 'quote) + \@ (wrapping-reader 'clojure.core/deref) + \^ read-meta + \` read-syntax-quote + \~ read-unquote + \( read-list + \) read-unmatched-delimiter + \[ read-vector + \] read-unmatched-delimiter + \{ read-map + \} read-unmatched-delimiter + \\ read-char* + \% read-arg + \# read-dispatch + nil)) + +(defn- dispatch-macros [ch] + (case ch + \^ read-meta ;; deprecated + \' (wrapping-reader 'var) + \( read-fn + \{ read-set + \< (throwing-reader "Unreadable form") + \= (throwing-reader "read-eval not supported") + \" read-regex + \! read-comment + \_ read-discard + \? read-cond + \: read-namespaced-map + \# read-symbolic-value + nil)) + +(defn- read-tagged [^not-native rdr initch opts pending-forms] + (let [tag (read* rdr true nil opts pending-forms)] + (if-not (symbol? tag) + (err/throw-bad-reader-tag rdr tag)) + (if *suppress-read* + (tagged-literal tag (read* rdr true nil opts pending-forms)) + (if-let [f (or (*data-readers* tag) + (default-data-readers tag))] + (f (read* rdr true nil opts pending-forms)) + (if-let [f *default-data-reader-fn*] + (f tag (read* rdr true nil opts pending-forms)) + (err/throw-unknown-reader-tag rdr tag)))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Public API +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(def ^:dynamic *data-readers* + "Map from reader tag symbols to data reader Vars. + Reader tags without namespace qualifiers are reserved for Clojure. + This light version of tools.reader has no implementation for default + reader tags such as #inst and #uuid." + {}) + +(def ^:dynamic *default-data-reader-fn* + "When no data reader is found for a tag and *default-data-reader-fn* + is non-nil, it will be called with two arguments, the tag and the value. + If *default-data-reader-fn* is nil (the default value), an exception + will be thrown for the unknown tag." + nil) + +(def ^:dynamic *suppress-read* false) + +(def default-data-readers + "Default map of data reader functions provided by Clojure. + May be overridden by binding *data-readers*" + {}) + +(defn- read*-internal + [^not-native reader ^boolean eof-error? sentinel return-on opts pending-forms] + (loop [] + (log-source reader + (if-not ^boolean (garray/isEmpty pending-forms) + (let [form (aget pending-forms 0)] + (garray/removeAt pending-forms 0) + form) + (let [ch (read-char reader)] + (cond + (whitespace? ch) (recur) + (nil? ch) (if eof-error? (err/throw-eof-error reader nil) sentinel) + (identical? ch return-on) READ_FINISHED + (number-literal? reader ch) (read-number reader ch) + :else (let [f (macros ch)] + (if-not (nil? f) + (let [res (f reader ch opts pending-forms)] + (if (identical? res reader) + (recur) + res)) + (read-symbol reader ch))))))))) + +(defn- read* + ([reader eof-error? sentinel opts pending-forms] + (read* reader eof-error? sentinel nil opts pending-forms)) + ([^not-native reader eof-error? sentinel return-on opts pending-forms] + (try + (read*-internal reader eof-error? sentinel return-on opts pending-forms) + (catch js/Error e + (if (ex-info? e) + (let [d (ex-data e)] + (if (= :reader-exception (:type d)) + (throw e) + (throw (ex-info (.-message e) + (merge {:type :reader-exception} + d + (if (indexing-reader? reader) + {:line (get-line-number reader) + :column (get-column-number reader) + :file (get-file-name reader)})) + e)))) + (throw (ex-info (.-message e) + (merge {:type :reader-exception} + (if (indexing-reader? reader) + {:line (get-line-number reader) + :column (get-column-number reader) + :file (get-file-name reader)})) + e))))))) + +(defn read + "Reads the first object from an IPushbackReader. + Returns the object read. If EOF, throws if eof-error? is true. + Otherwise returns sentinel. If no stream is providen, *in* will be used. + + Opts is a persistent map with valid keys: + :read-cond - :allow to process reader conditionals, or + :preserve to keep all branches + :features - persistent set of feature keywords for reader conditionals + :eof - on eof, return value unless :eofthrow, then throw. + if not specified, will throw + + To read data structures only, use clojure.tools.reader.edn/read + + Note that the function signature of clojure.tools.reader/read and + clojure.tools.reader.edn/read is not the same for eof-handling" + {:arglists '([] [reader] [opts reader] [reader eof-error? eof-value])} + ([reader] (read reader true nil)) + ([{eof :eof :as opts :or {eof :eofthrow}} reader] (read* reader (= eof :eofthrow) eof nil opts (to-array []))) + ([reader eof-error? sentinel] (read* reader eof-error? sentinel nil {} (to-array [])))) + +(defn read-string + "Reads one object from the string s. + Returns nil when s is nil or empty. + + To read data structures only, use clojure.tools.reader.edn/read-string + + Note that the function signature of clojure.tools.reader/read-string and + clojure.tools.reader.edn/read-string is not the same for eof-handling" + ([s] + (read-string {} s)) + ([opts s] + (when (and s (not (identical? s ""))) + (read opts (string-push-back-reader s))))) diff --git a/js/cljs/tools/reader.cljs.cache.json b/js/cljs/tools/reader.cljs.cache.json new file mode 100644 index 0000000..0e85ffd --- /dev/null +++ b/js/cljs/tools/reader.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$parseInt",["^ "],"~$isNaN",["^ "],"~$Error",["^ "],"~$String",["^ ","~$fromCharCode",["^ "]],"~$Object",["^ "],"~$Number",["^ ","~$NaN",["^ "],"~$NEGATIVE_INFINITY",["^ "],"~$POSITIVE_INFINITY",["^ "]],"~$Boolean",["^ "],"~$RegExp",["^ "]],"~:use-macros",["^ ","~$log-source","~$cljs.tools.reader.reader-types"],"~:excludes",["~#set",["~$char","~$*suppress-read*","~$*default-data-reader-fn*","~$read","~$default-data-readers","~$*data-readers*","~$read-line","~$read-string"]],"~:name","~$cljs.tools.reader","~:imports",["^ ","~$StringBuffer","~$goog.string.StringBuffer"],"~:requires",["^ ","~$cljs.tools.reader.impl.commons","^R","~$gstring","~$goog.string","^T","^T","~$cljs.tools.reader.impl.errors","^U","~$garray","~$goog.array","^A","^A","~$err","^U","^O","^P","~$cljs.tools.reader.impl.utils","^Y","^W","^W"],"~:cljs.spec/speced-vars",[],"~:uses",["^ ","~$match-number","^R","~$reader-conditional","^Y","~$whitespace?","^Y","~$read-comment","^R","^D","^Y","~$numeric?","^Y","~$ReaderConditional","^Y","~$unread","^A","~$peek-char","^A","~$parse-symbol","^R","~$second'","^Y","~$desugar-meta","^Y","~$next-id","^Y","~$number-literal?","^R","~$read-past","^R","~$indexing-reader?","^A","~$read-char","^A","~$get-column-number","^A","~$ex-info?","^Y","~$get-file-name","^A","~$reader-conditional?","^Y","~$throwing-reader","^R","~$string-push-back-reader","^A","~$namespace-keys","^Y","~$get-line-number","^A"],"~:defs",["^ ","~$NO_MATCH",["^ ","^L","~$cljs.tools.reader/NO_MATCH","~:file","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","~:line",484,"~:column",1,"~:end-line",484,"~:end-column",28,"~:private",true,"~:meta",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",484,"^1M",20,"^1N",484,"^1O",28,"^1P",true],"~:tag","~$object"],"~$READ_EOF",["^ ","^L","~$cljs.tools.reader/READ_EOF","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",197,"^1M",1,"^1N",197,"^1O",28,"^1P",true,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",197,"^1M",20,"^1N",197,"^1O",28,"^1P",true],"^1R","^1S"],"~$unquote-splicing?",["^ ","~:protocol-inline",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",633,"^1M",8,"^1N",633,"^1O",25,"^1P",true,"~:arglists",["~#list",["~$quote",["^1Y",[["~$form"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/unquote-splicing?","~:variadic",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",25,"~:method-params",["^1Y",[["^1["]]],"~:protocol-impl",null,"~:arglists-meta",["^1Y",[null,null]],"^1M",1,"^1L",633,"^1N",633,"~:max-fixed-arity",1,"~:fn-var",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]]],"~$read-symbolic-value",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",439,"^1M",8,"^1N",439,"^1O",27,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$rdr","~$_","~$opts","~$pending-forms"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-symbolic-value","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",27,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",439,"^1N",439,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"~$read-tagged",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",824,"^1M",8,"^1N",824,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$initch","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-tagged","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["^28","^2=","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",824,"^1N",824,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2=","^29","^2:"]]]]]],"~$starting-line-col-info",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",189,"^1M",8,"^1N",189,"^1O",30,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/starting-line-col-info","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",30,"^22",["^1Y",[["^28"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",189,"^1N",189,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28"]]]]]],"~$wrapping-reader",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",389,"^1M",8,"^1N",389,"^1O",23,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$sym"]]]]],"~:doc","Returns a function which wraps a reader in a call to sym"],"^1P",true,"^L","~$cljs.tools.reader/wrapping-reader","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",23,"^22",["^1Y",[["^2B"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",389,"^1N",389,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]],"^2C","Returns a function which wraps a reader in a call to sym"],"~$resolve-alias",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",360,"^1M",8,"^1N",360,"^1O",21,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/resolve-alias","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",21,"^22",["^1Y",[["^2B"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",360,"^1N",360,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]]],"~$read-meta",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",395,"^1M",8,"^1N",395,"^1O",17,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read metadata and return the following object with the metadata applied"],"^1P",true,"^L","~$cljs.tools.reader/read-meta","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",17,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",395,"^1N",395,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read metadata and return the following object with the metadata applied"],"~$read-unicode-char",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",108,"^1M",8,"^1N",108,"^1O",25,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$token","~$offset","~$length","~$base"],["^28","^2=","^2M","^2L","~$exact?"]]]]],"~:top-fn",["^ ","^21",false,"^25",5,"^22",["^1Y",[["^2J","^2K","^2L","^2M"],["^28","^2=","^2M","^2L","^2N"]]],"^1X",["^1Y",[["^2J","^2K","^2L","^2M"],["^28","^2=","^2M","^2L","^2N"]]],"^24",["^1Y",[null,null]]]],"^1P",true,"^L","~$cljs.tools.reader/read-unicode-char","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",25,"^2O",["^ ","^21",false,"^25",5,"^22",["^1Y",[["^2J","^2K","^2L","^2M"],["^28","^2=","^2M","^2L","^2N"]]],"^1X",["^1Y",[["^2J","^2K","^2L","^2M"],["^28","^2=","^2M","^2L","^2N"]]],"^24",["^1Y",[null,null]]],"^22",["^1Y",[["^2J","^2K","^2L","^2M"],["^28","^2=","^2M","^2L","^2N"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",108,"^1N",108,"^25",5,"^26",true,"^1X",["^1Y",[["^2J","^2K","^2L","^2M"],["^28","^2=","^2M","^2L","^2N"]]]],"~$char-code",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",102,"^1M",8,"^1N",102,"^1O",17,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$ch","^2M"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/char-code","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",17,"^22",["^1Y",[["^2R","^2M"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",102,"^1N",102,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R","^2M"]]]]]],"~$read-unmatched-delimiter",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",77,"^1M",8,"^1N",77,"^1O",32,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2R","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-unmatched-delimiter","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",32,"^22",["^1Y",[["^28","^2R","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",77,"^1N",77,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2R","^29","^2:"]]]]]],"~$read-fn",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",565,"^1M",8,"^1N",565,"^1O",15,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-fn","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",15,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",565,"^1N",565,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"~$syntax-quote*",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",708,"^1M",8,"^1N",708,"^1O",21,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]]],"^1P",true,"^L","~$cljs.tools.reader/syntax-quote*","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",21,"^22",["^1Y",[["^1["]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",708,"^1N",708,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]]],"~$bool?",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",698,"^1M",7,"^1N",698,"^1O",12,"^1X",["^1Y",["^1Z",["^1Y",[["~$x"]]]]]],"^L","~$cljs.tools.reader/bool?","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",12,"^22",["^1Y",[["~$x"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",698,"^1N",698,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$x"]]]]]],"~$arg-env",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",557,"^1M",26,"^1N",557,"^1O",33,"~:dynamic",true,"^1P",true],"^1P",true,"^L","~$cljs.tools.reader/arg-env","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",33,"^1M",1,"^31",true,"^1L",557,"^1N",557,"^1R","~$clj-nil"],"~$read-suppress",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",475,"^1M",8,"^1N",475,"^1O",21,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$first-line","^28","^29","^2:"]]]]],"^2C","Read next form and suppress. Return nil or READ_FINISHED."],"^1P",true,"^L","~$cljs.tools.reader/read-suppress","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",21,"^22",["^1Y",[["^35","^28","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",475,"^1N",475,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^35","^28","^29","^2:"]]]]],"^2C","Read next form and suppress. Return nil or READ_FINISHED."],"^E",["^ ","^L","~$cljs.tools.reader/*suppress-read*","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",855,"^1M",1,"^1N",855,"^1O",31,"^31",true,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",855,"^1M",16,"^1N",855,"^1O",31,"^31",true],"^1R","~$boolean"],"~$flatten-map",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",655,"^1M",8,"^1N",655,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]],"^2C","Flatten a map into a seq of alternate keys and values"],"^1P",true,"^L","~$cljs.tools.reader/flatten-map","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["^1["]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",655,"^1N",655,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]],"^2C","Flatten a map into a seq of alternate keys and values"],"^F",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",848,"^1M",16,"^1N",848,"^1O",40,"^31",true],"^L","~$cljs.tools.reader/*default-data-reader-fn*","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",40,"^1M",1,"^31",true,"^1L",848,"^1N",848,"^1R","^33","^2C","When no data reader is found for a tag and *default-data-reader-fn*\n is non-nil, it will be called with two arguments, the tag and the value.\n If *default-data-reader-fn* is nil (the default value), an exception\n will be thrown for the unknown tag."],"^G",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",911,"^1M",7,"^1N",911,"^1O",11,"^1X",["^1Y",["^1Z",["^1Y",[[],["~$reader"],["^29","^3<"],["^3<","~$eof-error?","~$eof-value"]]]]],"^2C","Reads the first object from an IPushbackReader.\n Returns the object read. If EOF, throws if eof-error? is true.\n Otherwise returns sentinel. If no stream is providen, *in* will be used.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n To read data structures only, use clojure.tools.reader.edn/read\n\n Note that the function signature of clojure.tools.reader/read and\n clojure.tools.reader.edn/read is not the same for eof-handling","^2O",["^ ","^21",false,"^25",3,"^22",["^1Y",[["^3<"],[["^ ","~$eof","~:eof","~:as","^29","~:or",["^ ","^3?","~:eofthrow"]],"^3<"],["^3<","^3=","~$sentinel"]]],"^1X",["^1Y",[["^3<"],[["^ ","^3?","^3@","^3A","^29","^3B",["^ ","^3?","^3C"]],"^3<"],["^3<","^3=","^3D"]]],"^24",["^1Y",[null,null,null]]]],"^L","~$cljs.tools.reader/read","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",11,"^2O",["^ ","^21",false,"^25",3,"^22",["^1Y",[["^3<"],[["^ ","^3?","^3@","^3A","^29","^3B",["^ ","^3?","^3C"]],"^3<"],["^3<","^3=","^3D"]]],"^1X",["^1Y",[["^3<"],[["^ ","^3?","^3@","^3A","^29","^3B",["^ ","^3?","^3C"]],"^3<"],["^3<","^3=","^3D"]]],"^24",["^1Y",[null,null,null]]],"^22",["^1Y",[["^3<"],[["^ ","^3?","^3@","^3A","^29","^3B",["^ ","^3?","^3C"]],"^3<"],["^3<","^3=","^3D"]]],"^23",null,"^24",["^1Y",[null,null,null]],"^1M",1,"^1L",911,"^1N",911,"^25",3,"^26",true,"^1X",["^1Y",[["^3<"],[["^ ","^3?","^3@","^3A","^29","^3B",["^ ","^3?","^3C"]],"^3<"],["^3<","^3=","^3D"]]],"^2C","Reads the first object from an IPushbackReader.\n Returns the object read. If EOF, throws if eof-error? is true.\n Otherwise returns sentinel. If no stream is providen, *in* will be used.\n\n Opts is a persistent map with valid keys:\n :read-cond - :allow to process reader conditionals, or\n :preserve to keep all branches\n :features - persistent set of feature keywords for reader conditionals\n :eof - on eof, return value unless :eofthrow, then throw.\n if not specified, will throw\n\n To read data structures only, use clojure.tools.reader.edn/read\n\n Note that the function signature of clojure.tools.reader/read and\n clojure.tools.reader.edn/read is not the same for eof-handling"],"~$read-set",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",413,"^1M",8,"^1N",413,"^1O",16,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-set","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",16,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",413,"^1N",413,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"~$read-symbol",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",334,"^1M",8,"^1N",334,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2="]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-symbol","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["^28","^2="]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",334,"^1N",334,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2="]]]]]],"~$read-unquote",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",624,"^1M",8,"^1N",624,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$comma","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-unquote","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["^28","^3K","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",624,"^1N",624,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^3K","^29","^2:"]]]]]],"~$read-map",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",253,"^1M",8,"^1N",253,"^1O",16,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read in a map, including its location if the reader is an indexing reader"],"^1P",true,"^L","~$cljs.tools.reader/read-map","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",16,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",253,"^1N",253,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read in a map, including its location if the reader is an indexing reader"],"~$read*-internal",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",862,"^1M",8,"^1N",862,"^1O",22,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","^3=","^3D","~$return-on","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read*-internal","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",22,"^22",["^1Y",[["^3<","^3=","^3D","^3P","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",862,"^1N",862,"^25",6,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","^3=","^3D","^3P","^29","^2:"]]]]]],"~$unquote?",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",637,"^1M",8,"^1N",637,"^1O",16,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]]],"^1P",true,"^L","~$cljs.tools.reader/unquote?","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",16,"^22",["^1Y",[["^1["]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",637,"^1N",637,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1["]]]]]],"^H",["^ ","^L","~$cljs.tools.reader/default-data-readers","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",857,"^1M",1,"^1N",857,"^1O",26,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",857,"^1M",6,"^1N",857,"^1O",26],"^2C","Default map of data reader functions provided by Clojure.\n May be overridden by binding *data-readers*","^1R","~$cljs.core/IMap"],"~$macros",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",787,"^1M",8,"^1N",787,"^1O",14,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/macros","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",14,"^22",["^1Y",[["^2R"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",787,"^1N",787,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R"]]]]]],"~$read-arg",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",600,"^1M",8,"^1N",600,"^1O",16,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$pct","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-arg","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",16,"^22",["^1Y",[["^28","^3Y","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",600,"^1N",600,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^3Y","^29","^2:"]]]]]],"~$match-feature",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",486,"^1M",8,"^1N",486,"^1O",21,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^35","^28","^29","^2:"]]]]],"^2C","Read next feature. If matched, read next form and return.\n Otherwise, read and skip next form, returning READ_FINISHED or nil."],"^1P",true,"^L","~$cljs.tools.reader/match-feature","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",21,"^22",["^1Y",[["^35","^28","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",486,"^1N",486,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^35","^28","^29","^2:"]]]]],"^2C","Read next feature. If matched, read next form and return.\n Otherwise, read and skip next form, returning READ_FINISHED or nil."],"~$read-namespaced-map",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",761,"^1M",8,"^1N",761,"^1O",27,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-namespaced-map","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",27,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",761,"^1N",761,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"~$read-syntax-quote",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",755,"^1M",8,"^1N",755,"^1O",25,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$backquote","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-syntax-quote","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",25,"^22",["^1Y",[["^28","^44","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",755,"^1N",755,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^44","^29","^2:"]]]]]],"~$READ_FINISHED",["^ ","^L","~$cljs.tools.reader/READ_FINISHED","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",198,"^1M",1,"^1N",198,"^1O",33,"^1P",true,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",198,"^1M",20,"^1N",198,"^1O",33,"^1P",true],"^1R","^1S"],"~$read-list",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",219,"^1M",8,"^1N",219,"^1O",17,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read in a list, including its location if the reader is an indexing reader"],"^1P",true,"^L","~$cljs.tools.reader/read-list","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",17,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",219,"^1N",219,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read in a list, including its location if the reader is an indexing reader"],"~$read-cond-delimited",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",505,"^1M",8,"^1N",505,"^1O",27,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$splicing","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-cond-delimited","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",27,"^22",["^1Y",[["^28","^4;","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",505,"^1N",505,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^4;","^29","^2:"]]]]]],"~$RESERVED_FEATURES",["^ ","^L","~$cljs.tools.reader/RESERVED_FEATURES","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",450,"^1M",1,"^1N",450,"^1O",33,"^1P",true,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",450,"^1M",16,"^1N",450,"^1O",33,"^1P",true],"^1R","~$cljs.core/ISet"],"~$dispatch-macros",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",808,"^1M",8,"^1N",808,"^1O",23,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/dispatch-macros","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",23,"^22",["^1Y",[["^2R"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",808,"^1N",808,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R"]]]]]],"~$read*",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",884,"^1M",8,"^1N",884,"^1O",13,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]]]],"^2O",["^ ","^21",false,"^25",6,"^22",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]],"^1X",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]],"^24",["^1Y",[null,null]]]],"^1P",true,"^L","~$cljs.tools.reader/read*","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",13,"^2O",["^ ","^21",false,"^25",6,"^22",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]],"^1X",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]],"^24",["^1Y",[null,null]]],"^22",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",884,"^1N",884,"^25",6,"^26",true,"^1X",["^1Y",[["^3<","^3=","^3D","^29","^2:"],["^3<","^3=","^3D","^3P","^29","^2:"]]]],"^I",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",841,"^1M",16,"^1N",841,"^1O",30,"^31",true],"^L","~$cljs.tools.reader/*data-readers*","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",30,"^1M",1,"^31",true,"^1L",841,"^1N",841,"^1R","^3U","^2C","Map from reader tag symbols to data reader Vars.\n Reader tags without namespace qualifiers are reserved for Clojure.\n This light version of tools.reader has no implementation for default\n reader tags such as #inst and #uuid."],"~$syntax-quote-coll",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",683,"^1M",8,"^1N",683,"^1O",25,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$type","~$coll"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/syntax-quote-coll","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",25,"^22",["^1Y",[["^4F","^4G"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",683,"^1N",683,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^4F","^4G"]]]]]],"~$*read-delim*",["^ ","^L","~$cljs.tools.reader/*read-delim*","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",200,"^1M",1,"^1N",200,"^1O",28,"^31",true,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",200,"^1M",16,"^1N",200,"^1O",28,"^31",true],"^1R","^38"],"~$resolve-symbol",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",703,"^1M",17,"^1N",703,"^1O",31,"^31",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$s"]]]]],"^2C","Resolve a symbol s into its fully qualified namespace version"],"^L","~$cljs.tools.reader/resolve-symbol","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",31,"^22",["^1Y",[["~$s"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^31",true,"^1L",703,"^1N",703,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$s"]]]]],"^2C","Resolve a symbol s into its fully qualified namespace version"],"~$read-delimited",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",213,"^1M",8,"^1N",213,"^1O",22,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$kind","~$delim","^28","^29","^2:"]]]]],"^2C","Reads and returns a collection ended with delim"],"^1P",true,"^L","~$cljs.tools.reader/read-delimited","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",22,"^22",["^1Y",[["^4N","^4O","^28","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",213,"^1N",213,"^25",5,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^4N","^4O","^28","^29","^2:"]]]]],"^2C","Reads and returns a collection ended with delim"],"~$read-token",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",48,"^1M",8,"^1N",48,"^1O",18,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^4N","^2="]]]]],"^2C","Read in a single logical token from the reader"],"^1P",true,"^L","~$cljs.tools.reader/read-token","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",18,"^22",["^1Y",[["^28","^4N","^2="]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",48,"^1N",48,"^25",3,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^4N","^2="]]]]],"^2C","Read in a single logical token from the reader"],"~$read-cond",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",535,"^1M",8,"^1N",535,"^1O",17,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-cond","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",17,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",535,"^1N",535,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"~$upper-limit",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",140,"^1M",24,"^1N",140,"^1O",35,"~:const",true,"^1P",true],"^1P",true,"^L","~$cljs.tools.reader/upper-limit","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",35,"^1M",1,"^4V",true,"^1L",140,"^1N",140,"^1R","~$any"],"~$loc-info",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",323,"^1M",8,"^1N",323,"^1O",16,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$line","~$column"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/loc-info","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",16,"^22",["^1Y",[["^28","^4Z","^4["]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",323,"^1N",323,"^25",3,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^4Z","^4["]]]]]],"~$gensym-env",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",622,"^1M",26,"^1N",622,"^1O",36,"^31",true,"^1P",true],"^1P",true,"^L","~$cljs.tools.reader/gensym-env","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",36,"^1M",1,"^31",true,"^1L",622,"^1N",622,"^1R","^33"],"~$*alias-map*",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",353,"^1M",16,"^1N",353,"^1O",27,"^31",true],"^L","~$cljs.tools.reader/*alias-map*","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",27,"^1M",1,"^31",true,"^1L",353,"^1N",353,"^1R","^33","^2C","Map from ns alias to ns, if non-nil, it will be used to resolve read-time\n ns aliases.\n\n Defaults to nil"],"~$read-regex",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",85,"^1M",7,"^1N",85,"^1O",17,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2R","^29","^2:"]]]]]],"^L","~$cljs.tools.reader/read-regex","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",17,"^22",["^1Y",[["^28","^2R","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",85,"^1N",85,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2R","^29","^2:"]]]]]],"~$sb",["^ ","^L","~$cljs.tools.reader/sb","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",46,"^1M",1,"^1N",46,"^1O",8,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",46,"^1M",6,"^1N",46,"^1O",8],"^1R","~$goog/string.StringBuffer"],"~$read-dispatch",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",69,"^1M",8,"^1N",69,"^1O",21,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-dispatch","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",21,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",69,"^1N",69,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]]],"~$check-eof-error",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",458,"^1M",8,"^1N",458,"^1O",23,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1[","^28","^35"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/check-eof-error","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",23,"^22",["^1Y",[["^1[","^28","^35"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",458,"^1N",458,"^25",3,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1[","^28","^35"]]]]]],"~$check-invalid-read-cond",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",468,"^1M",8,"^1N",468,"^1O",31,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1[","^28","^35"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/check-invalid-read-cond","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",31,"^22",["^1Y",[["^1[","^28","^35"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",468,"^1N",468,"^25",3,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1[","^28","^35"]]]]]],"^K",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",932,"^1M",7,"^1N",932,"^1O",18,"^1X",["^1Y",["^1Z",["^1Y",[["~$s"],["^29","~$s"]]]]],"^2C","Reads one object from the string s.\n Returns nil when s is nil or empty.\n\n To read data structures only, use clojure.tools.reader.edn/read-string\n\n Note that the function signature of clojure.tools.reader/read-string and\n clojure.tools.reader.edn/read-string is not the same for eof-handling","^2O",["^ ","^21",false,"^25",2,"^22",["^1Y",[["~$s"],["^29","~$s"]]],"^1X",["^1Y",[["~$s"],["^29","~$s"]]],"^24",["^1Y",[null,null]]]],"^L","~$cljs.tools.reader/read-string","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",18,"^2O",["^ ","^21",false,"^25",2,"^22",["^1Y",[["~$s"],["^29","~$s"]]],"^1X",["^1Y",[["~$s"],["^29","~$s"]]],"^24",["^1Y",[null,null]]],"^22",["^1Y",[["~$s"],["^29","~$s"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",932,"^1N",932,"^25",2,"^26",true,"^1X",["^1Y",[["~$s"],["^29","~$s"]]],"^2C","Reads one object from the string s.\n Returns nil when s is nil or empty.\n\n To read data structures only, use clojure.tools.reader.edn/read-string\n\n Note that the function signature of clojure.tools.reader/read-string and\n clojure.tools.reader.edn/read-string is not the same for eof-handling"],"~$check-reserved-features",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",463,"^1M",8,"^1N",463,"^1O",31,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^1["]]]]]],"^1P",true,"^L","~$cljs.tools.reader/check-reserved-features","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",31,"^22",["^1Y",[["^28","^1["]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",463,"^1N",463,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^1["]]]]]],"~$has-feature?",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",452,"^1M",8,"^1N",452,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$feature","^29"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/has-feature?","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["^28","^5D","^29"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",452,"^1N",452,"^25",3,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^5D","^29"]]]]]],"~$valid-octal?",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",143,"^1M",8,"^1N",143,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2J","^2M"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/valid-octal?","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["^2J","^2M"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",143,"^1N",143,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2J","^2M"]]]]]],"~$escape-char",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",290,"^1M",8,"^1N",290,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^57","^28"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/escape-char","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["^57","^28"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",290,"^1N",290,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^57","^28"]]]]]],"~$read-char*",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",146,"^1M",8,"^1N",146,"^1O",18,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$backslash","^29","^2:"]]]]],"^2C","Read in a character literal"],"^1P",true,"^L","~$cljs.tools.reader/read-char*","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",18,"^22",["^1Y",[["^28","^5K","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",146,"^1N",146,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^5K","^29","^2:"]]]]],"^2C","Read in a character literal"],"~$resolve-ns",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",363,"^1M",8,"^1N",363,"^1O",18,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/resolve-ns","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",18,"^22",["^1Y",[["^2B"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",363,"^1N",363,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]]],"~$read-delimited-internal",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",202,"^1M",8,"^1N",202,"^1O",31,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^4N","^4O","^28","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-delimited-internal","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",31,"^22",["^1Y",[["^4N","^4O","^28","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",202,"^1N",202,"^25",5,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^4N","^4O","^28","^29","^2:"]]]]]],"~$read-string*",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",311,"^1M",8,"^1N",311,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","~$_","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-string*","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["^3<","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",311,"^1N",311,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","~$_","^29","^2:"]]]]]],"~$macro-terminating?",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",41,"^1M",17,"^1N",41,"^1O",35,"^1R","^38","^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/macro-terminating?","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",35,"^22",["^1Y",[["^2R"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",41,"~:ret-tag","^38","^1N",41,"^25",1,"^1R","^38","^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2R"]]]]]],"~$map-func",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",691,"^1M",7,"^1N",691,"^1O",15,"^1X",["^1Y",["^1Z",["^1Y",[["^4G"]]]]],"^2C","Decide which map type to use, array-map if less than 16 elements"],"^L","~$cljs.tools.reader/map-func","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",15,"^22",["^1Y",[["^4G"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",691,"^1N",691,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^4G"]]]]],"^2C","Decide which map type to use, array-map if less than 16 elements"],"~$lower-limit",["^ ","^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",141,"^1M",24,"^1N",141,"^1O",35,"^4V",true,"^1P",true],"^1P",true,"^L","~$cljs.tools.reader/lower-limit","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",35,"^1M",1,"^4V",true,"^1L",141,"^1N",141,"^1R","^4X"],"~$ending-line-col-info",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",193,"^1M",8,"^1N",193,"^1O",28,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/ending-line-col-info","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",28,"^22",["^1Y",[["^28"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",193,"^1N",193,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28"]]]]]],"~$register-arg",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",586,"^1M",8,"^1N",586,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$n"]]]]],"^2C","Registers an argument to the arg-env"],"^1P",true,"^L","~$cljs.tools.reader/register-arg","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["~$n"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",586,"^1N",586,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$n"]]]]],"^2C","Registers an argument to the arg-env"],"~$read-keyword",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",368,"^1M",8,"^1N",368,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","^2=","^29","^2:"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-keyword","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["^3<","^2=","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",368,"^1N",368,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^3<","^2=","^29","^2:"]]]]]],"~$read-discard",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",433,"^1M",8,"^1N",433,"^1O",20,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read and discard the first object from rdr"],"^1P",true,"^L","~$cljs.tools.reader/read-discard","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",20,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",433,"^1N",433,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read and discard the first object from rdr"],"~$garg",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",559,"^1M",8,"^1N",559,"^1O",12,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$n"]]]]],"^2C","Get a symbol for an anonymous ?argument?"],"^1P",true,"^L","~$cljs.tools.reader/garg","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",12,"^22",["^1Y",[["~$n"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",559,"^1N",559,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$n"]]]]],"^2C","Get a symbol for an anonymous ?argument?"],"~$read-vector",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",237,"^1M",8,"^1N",237,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read in a vector, including its location if the reader is an indexing reader"],"^1P",true,"^L","~$cljs.tools.reader/read-vector","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["^28","~$_","^29","^2:"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",237,"^1N",237,"^25",4,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","~$_","^29","^2:"]]]]],"^2C","Read in a vector, including its location if the reader is an indexing reader"],"~$read-number",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",279,"^1M",8,"^1N",279,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2="]]]]]],"^1P",true,"^L","~$cljs.tools.reader/read-number","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["^28","^2="]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",279,"^1N",279,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^28","^2="]]]]]],"~$add-meta",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",677,"^1M",8,"^1N",677,"^1O",16,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1[","~$ret"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/add-meta","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",16,"^22",["^1Y",[["^1[","^6="]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",677,"^1N",677,"^25",2,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^1[","^6="]]]]]],"~$register-gensym",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",666,"^1M",8,"^1N",666,"^1O",23,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]]],"^1P",true,"^L","~$cljs.tools.reader/register-gensym","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",23,"^22",["^1Y",[["^2B"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",666,"^1N",666,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["^2B"]]]]]],"~$expand-list",["^ ","^1W",null,"^1Q",["^ ","^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1L",641,"^1M",8,"^1N",641,"^1O",19,"^1P",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$s"]]]]],"^2C","Expand a list by resolving its syntax quotes and unquotes"],"^1P",true,"^L","~$cljs.tools.reader/expand-list","^21",false,"^1K","/home/julien/.cljs/.aot_cache/1.10.329/289B404/cljs/tools/reader.cljs","^1O",19,"^22",["^1Y",[["~$s"]]],"^23",null,"^24",["^1Y",[null,null]],"^1M",1,"^1L",641,"^1N",641,"^25",1,"^26",true,"^1X",["^1Y",["^1Z",["^1Y",[["~$s"]]]]],"^2C","Expand a list by resolving its syntax quotes and unquotes"]],"~:cljs.spec/registry-ref",[],"~:require-macros",["^ ","^A","^A"],"~:cljs.analyzer/constants",["^ ","~:seen",["^C",["~$&","~:features","~$clojure.core/list","~:namespaced-map","~$cljs.core/array-map","~:reader-exception","~:else","~$cljs.core/hash-map","~$cljs.core/apply","~:default","~:symbol","^:","^1K","~$cljs.core/concat","^1O","~:read-cond","~:type","~:preserve","~$Inf","~:source","~:string","~:vector","~$cljs.core/with-meta","~:allow","~:sym","^1M","~:illegal-state","~$clojure.core/unquote-splicing","^1L","~:list","~$fn*","~:keyword","~$clojure.core/deref","~$/","~$clojure.core/unquote","^1N","~$cljs.core/vec","~$-Inf","~$cljs.core/sequence","~:regex","~:unsupported-operation","~$var","^1Z","~:set","^3@","~$cljs.core/hash-set","~:character","~:map","~$cljs.core/list","^3C","~:runtime-exception","~:none"]],"~:order",["^7:","^7?","^6L","^72","^1K","^1L","^1M","^1N","^1O","^6X","^7@","^6W","^6P","~$/","^74","^7=","^:","^78","^6U","^7C","^6O","^6G","^6T","^6Z","^6R","^6S","^7B","^70","~$&","^73","^71","^76","^6H","^6V","^6Y","^79","^6Q","^6N","^6M","^6J","^6[","^1Z","^77","^7>","^7A","^7;","^6I","^75","^7<","^6K","^3@","^3C"]],"^2C","A clojure reader in clojure"] \ No newline at end of file diff --git a/js/cljs/tools/reader.js b/js/cljs/tools/reader.js new file mode 100644 index 0000000..b5dfbb5 --- /dev/null +++ b/js/cljs/tools/reader.js @@ -0,0 +1,1782 @@ +// Compiled by ClojureScript 1.10.329 {:static-fns true, :optimize-constants true, :target :nodejs} +goog.provide('cljs.tools.reader'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +goog.require('cljs.tools.reader.reader_types'); +goog.require('cljs.tools.reader.impl.utils'); +goog.require('cljs.tools.reader.impl.commons'); +goog.require('cljs.tools.reader.impl.errors'); +goog.require('goog.array'); +goog.require('goog.string'); +goog.require('goog.string.StringBuffer'); + + + + + + +cljs.tools.reader.macro_terminating_QMARK_ = (function cljs$tools$reader$macro_terminating_QMARK_(ch){ +var G__1952 = ch; +switch (G__1952) { +case "\"": +case ";": +case "@": +case "^": +case "`": +case "~": +case "(": +case ")": +case "[": +case "]": +case "{": +case "}": +case "\\": +return true; + +break; +default: +return false; + +} +}); +cljs.tools.reader.sb = (new goog.string.StringBuffer()); +/** + * Read in a single logical token from the reader + */ +cljs.tools.reader.read_token = (function cljs$tools$reader$read_token(rdr,kind,initch){ +if((initch == null)){ +return cljs.tools.reader.impl.errors.throw_eof_at_start(rdr,kind); +} else { +cljs.tools.reader.sb.clear(); + +var ch = initch; +while(true){ +if(((cljs.tools.reader.impl.utils.whitespace_QMARK_(ch)) || (cljs.tools.reader.macro_terminating_QMARK_(ch)) || ((ch == null)))){ +if((ch == null)){ +} else { +rdr.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2(null,ch); +} + +return cljs.tools.reader.sb.toString(); +} else { +cljs.tools.reader.sb.append(ch); + +var G__1954 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +ch = G__1954; +continue; +} +break; +} +} +}); +cljs.tools.reader.read_dispatch = (function cljs$tools$reader$read_dispatch(rdr,_,opts,pending_forms){ +var temp__5455__auto__ = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(cljs.core.truth_(temp__5455__auto__)){ +var ch = temp__5455__auto__; +var temp__5455__auto____$1 = (cljs.tools.reader.dispatch_macros.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.dispatch_macros.cljs$core$IFn$_invoke$arity$1(ch) : cljs.tools.reader.dispatch_macros.call(null,ch)); +if(cljs.core.truth_(temp__5455__auto____$1)){ +var dm = temp__5455__auto____$1; +return (dm.cljs$core$IFn$_invoke$arity$4 ? dm.cljs$core$IFn$_invoke$arity$4(rdr,ch,opts,pending_forms) : dm.call(null,rdr,ch,opts,pending_forms)); +} else { +var G__1955 = (function (){var G__1959 = rdr; +G__1959.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2(null,ch); + +return G__1959; +})(); +var G__1956 = ch; +var G__1957 = opts; +var G__1958 = pending_forms; +return (cljs.tools.reader.read_tagged.cljs$core$IFn$_invoke$arity$4 ? cljs.tools.reader.read_tagged.cljs$core$IFn$_invoke$arity$4(G__1955,G__1956,G__1957,G__1958) : cljs.tools.reader.read_tagged.call(null,G__1955,G__1956,G__1957,G__1958)); +} +} else { +return cljs.tools.reader.impl.errors.throw_eof_at_dispatch(rdr); +} +}); +cljs.tools.reader.read_unmatched_delimiter = (function cljs$tools$reader$read_unmatched_delimiter(rdr,ch,opts,pending_forms){ +return cljs.tools.reader.impl.errors.throw_unmatch_delimiter(rdr,ch); +}); +cljs.tools.reader.read_regex = (function cljs$tools$reader$read_regex(rdr,ch,opts,pending_forms){ +var sb = (new goog.string.StringBuffer()); +var ch__$1 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +while(true){ +if(("\"" === ch__$1)){ +return cljs.core.re_pattern([cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)].join('')); +} else { +if((ch__$1 == null)){ +return cljs.tools.reader.impl.errors.throw_eof_reading.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.cst$kw$regex,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([sb], 0)); +} else { +sb.append(ch__$1); + +if(("\\" === ch__$1)){ +var ch_1960__$2 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if((ch_1960__$2 == null)){ +cljs.tools.reader.impl.errors.throw_eof_reading.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.cst$kw$regex,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([sb], 0)); +} else { +} + +sb.append(ch_1960__$2); +} else { +} + +var G__1961 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +ch__$1 = G__1961; +continue; +} +} +break; +} +}); +cljs.tools.reader.char_code = (function cljs$tools$reader$char_code(ch,base){ +var code = parseInt(ch,base); +if(cljs.core.truth_(isNaN(code))){ +return (-1); +} else { +return code; +} +}); +cljs.tools.reader.read_unicode_char = (function cljs$tools$reader$read_unicode_char(var_args){ +var G__1963 = arguments.length; +switch (G__1963) { +case 4: +return cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$4 = (function (token,offset,length,base){ +var l = (offset + length); +if((cljs.core.count(token) === l)){ +} else { +cljs.tools.reader.impl.errors.throw_invalid_unicode_literal(null,token); +} + +var i = offset; +var uc = (0); +while(true){ +if((i === l)){ +return String.fromCharCode(uc); +} else { +var d = cljs.tools.reader.char_code(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(token,i),base); +if((d === (-1))){ +return cljs.tools.reader.impl.errors.throw_invalid_unicode_digit_in_token(null,cljs.core.nth.cljs$core$IFn$_invoke$arity$2(token,i),token); +} else { +var G__1965 = (i + (1)); +var G__1966 = (d + (uc * base)); +i = G__1965; +uc = G__1966; +continue; +} +} +break; +} +}); + +cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$5 = (function (rdr,initch,base,length,exact_QMARK_){ +var i = (1); +var uc = cljs.tools.reader.char_code(initch,base); +while(true){ +if((uc === (-1))){ +return cljs.tools.reader.impl.errors.throw_invalid_unicode_digit(rdr,initch); +} else { +if(!((i === length))){ +var ch = rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null); +if(cljs.core.truth_((function (){var or__3936__auto__ = cljs.tools.reader.impl.utils.whitespace_QMARK_(ch); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (cljs.tools.reader.macros.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.macros.cljs$core$IFn$_invoke$arity$1(ch) : cljs.tools.reader.macros.call(null,ch)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +return (ch == null); +} +} +})())){ +if(cljs.core.truth_(exact_QMARK_)){ +return cljs.tools.reader.impl.errors.throw_invalid_unicode_len(rdr,i,length); +} else { +return String.fromCharCode(uc); +} +} else { +var d = cljs.tools.reader.char_code(ch,base); +rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); + +if((d === (-1))){ +return cljs.tools.reader.impl.errors.throw_invalid_unicode_digit(rdr,ch); +} else { +var G__1967 = (i + (1)); +var G__1968 = (d + (uc * base)); +i = G__1967; +uc = G__1968; +continue; +} +} +} else { +return String.fromCharCode(uc); +} +} +break; +} +}); + +cljs.tools.reader.read_unicode_char.cljs$lang$maxFixedArity = 5; + +cljs.tools.reader.upper_limit = "\uD7FF".charCodeAt((0)); +cljs.tools.reader.lower_limit = "\uE000".charCodeAt((0)); +cljs.tools.reader.valid_octal_QMARK_ = (function cljs$tools$reader$valid_octal_QMARK_(token,base){ +return (parseInt(token,base) <= (255)); +}); +/** + * Read in a character literal + */ +cljs.tools.reader.read_char_STAR_ = (function cljs$tools$reader$read_char_STAR_(rdr,backslash,opts,pending_forms){ +var ch = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(!((ch == null))){ +var token = ((((cljs.tools.reader.macro_terminating_QMARK_(ch)) || (cljs.tools.reader.impl.utils.whitespace_QMARK_(ch))))?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(ch)].join(''):cljs.tools.reader.read_token(rdr,cljs.core.cst$kw$character,ch)); +var token_len = token.length; +if(((1) === token_len)){ +return token.charAt((0)); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,"newline")){ +return "\n"; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,"space")){ +return " "; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,"tab")){ +return "\t"; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,"backspace")){ +return "\b"; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,"formfeed")){ +return "\f"; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,"return")){ +return "\r"; +} else { +if(cljs.core.truth_(goog.string.startsWith(token,"u"))){ +var c = cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$4(token,(1),(4),(16)); +var ic = c.charCodeAt((0)); +if((((ic > cljs.tools.reader.upper_limit)) && ((ic < cljs.tools.reader.lower_limit)))){ +return cljs.tools.reader.impl.errors.throw_invalid_character_literal(rdr,ic.toString((16))); +} else { +return c; +} +} else { +if(cljs.core.truth_(goog.string.startsWith(token,"o"))){ +var len = (token_len - (1)); +if((len > (3))){ +return cljs.tools.reader.impl.errors.throw_invalid_octal_len(rdr,token); +} else { +var offset = (1); +var base = (8); +var uc = cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$4(token,offset,len,base); +if(cljs.core.not(cljs.tools.reader.valid_octal_QMARK_(cljs.core.subs.cljs$core$IFn$_invoke$arity$2(token,offset),base))){ +return cljs.tools.reader.impl.errors.throw_bad_octal_number(rdr); +} else { +return uc; +} +} +} else { +return cljs.tools.reader.impl.errors.throw_unsupported_character(rdr,token); + +} +} +} +} +} +} +} +} +} +} else { +return cljs.tools.reader.impl.errors.throw_eof_in_character(rdr); +} +}); +cljs.tools.reader.starting_line_col_info = (function cljs$tools$reader$starting_line_col_info(rdr){ +if(cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(rdr))){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [rdr.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1(null),((rdr.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1(null) - (1)) | (0))], null); +} else { +return null; +} +}); +cljs.tools.reader.ending_line_col_info = (function cljs$tools$reader$ending_line_col_info(rdr){ +if(cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(rdr))){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [rdr.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1(null),rdr.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1(null)], null); +} else { +return null; +} +}); +if((typeof cljs !== 'undefined') && (typeof cljs.tools !== 'undefined') && (typeof cljs.tools.reader !== 'undefined') && (typeof cljs.tools.reader.READ_EOF !== 'undefined')){ +} else { +cljs.tools.reader.READ_EOF = (new Object()); +} +if((typeof cljs !== 'undefined') && (typeof cljs.tools !== 'undefined') && (typeof cljs.tools.reader !== 'undefined') && (typeof cljs.tools.reader.READ_FINISHED !== 'undefined')){ +} else { +cljs.tools.reader.READ_FINISHED = (new Object()); +} +cljs.tools.reader._STAR_read_delim_STAR_ = false; +cljs.tools.reader.read_delimited_internal = (function cljs$tools$reader$read_delimited_internal(kind,delim,rdr,opts,pending_forms){ +var vec__1969 = cljs.tools.reader.starting_line_col_info(rdr); +var start_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1969,(0),null); +var start_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1969,(1),null); +var delim__$1 = cljs.tools.reader.impl.utils.char$(delim); +var a = cljs.core.transient$(cljs.core.PersistentVector.EMPTY); +while(true){ +var form = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(rdr,false,cljs.tools.reader.READ_EOF,delim__$1,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,false,cljs.tools.reader.READ_EOF,delim__$1,opts,pending_forms)); +if((form === cljs.tools.reader.READ_FINISHED)){ +return cljs.core.persistent_BANG_(a); +} else { +if((form === cljs.tools.reader.READ_EOF)){ +return cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$core$IFn$_invoke$arity$5(rdr,kind,start_line,start_column,cljs.core.count(a)); +} else { +var G__1972 = cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(a,form); +a = G__1972; +continue; +} +} +break; +} +}); +/** + * Reads and returns a collection ended with delim + */ +cljs.tools.reader.read_delimited = (function cljs$tools$reader$read_delimited(kind,delim,rdr,opts,pending_forms){ +var _STAR_read_delim_STAR_1973 = cljs.tools.reader._STAR_read_delim_STAR_; +cljs.tools.reader._STAR_read_delim_STAR_ = true; + +try{return cljs.tools.reader.read_delimited_internal(kind,delim,rdr,opts,pending_forms); +}finally {cljs.tools.reader._STAR_read_delim_STAR_ = _STAR_read_delim_STAR_1973; +}}); +/** + * Read in a list, including its location if the reader is an indexing reader + */ +cljs.tools.reader.read_list = (function cljs$tools$reader$read_list(rdr,_,opts,pending_forms){ +var vec__1974 = cljs.tools.reader.starting_line_col_info(rdr); +var start_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1974,(0),null); +var start_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1974,(1),null); +var the_list = cljs.tools.reader.read_delimited(cljs.core.cst$kw$list,")",rdr,opts,pending_forms); +var vec__1977 = cljs.tools.reader.ending_line_col_info(rdr); +var end_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1977,(0),null); +var end_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1977,(1),null); +return cljs.core.with_meta(((cljs.core.empty_QMARK_(the_list))?cljs.core.List.EMPTY:cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.list,the_list)),(cljs.core.truth_(start_line)?cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var temp__5457__auto__ = cljs.tools.reader.reader_types.get_file_name(rdr); +if(cljs.core.truth_(temp__5457__auto__)){ +var file = temp__5457__auto__; +return new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$file,file], null); +} else { +return null; +} +})(),new cljs.core.PersistentArrayMap(null, 4, [cljs.core.cst$kw$line,start_line,cljs.core.cst$kw$column,start_column,cljs.core.cst$kw$end_DASH_line,end_line,cljs.core.cst$kw$end_DASH_column,end_column], null)], 0)):null)); +}); +/** + * Read in a vector, including its location if the reader is an indexing reader + */ +cljs.tools.reader.read_vector = (function cljs$tools$reader$read_vector(rdr,_,opts,pending_forms){ +var vec__1980 = cljs.tools.reader.starting_line_col_info(rdr); +var start_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1980,(0),null); +var start_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1980,(1),null); +var the_vector = cljs.tools.reader.read_delimited(cljs.core.cst$kw$vector,"]",rdr,opts,pending_forms); +var vec__1983 = cljs.tools.reader.ending_line_col_info(rdr); +var end_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1983,(0),null); +var end_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1983,(1),null); +return cljs.core.with_meta(the_vector,(cljs.core.truth_(start_line)?cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var temp__5457__auto__ = cljs.tools.reader.reader_types.get_file_name(rdr); +if(cljs.core.truth_(temp__5457__auto__)){ +var file = temp__5457__auto__; +return new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$file,file], null); +} else { +return null; +} +})(),new cljs.core.PersistentArrayMap(null, 4, [cljs.core.cst$kw$line,start_line,cljs.core.cst$kw$column,start_column,cljs.core.cst$kw$end_DASH_line,end_line,cljs.core.cst$kw$end_DASH_column,end_column], null)], 0)):null)); +}); +/** + * Read in a map, including its location if the reader is an indexing reader + */ +cljs.tools.reader.read_map = (function cljs$tools$reader$read_map(rdr,_,opts,pending_forms){ +var vec__1986 = cljs.tools.reader.starting_line_col_info(rdr); +var start_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1986,(0),null); +var start_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1986,(1),null); +var the_map = cljs.tools.reader.read_delimited(cljs.core.cst$kw$map,"}",rdr,opts,pending_forms); +var map_count = cljs.core.count(the_map); +var ks = cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),the_map); +var key_set = cljs.core.set(ks); +var vec__1989 = cljs.tools.reader.ending_line_col_info(rdr); +var end_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1989,(0),null); +var end_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1989,(1),null); +if(cljs.core.odd_QMARK_(map_count)){ +cljs.tools.reader.impl.errors.throw_odd_map(rdr,start_line,start_column,the_map); +} else { +} + +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(key_set),cljs.core.count(ks))){ +} else { +cljs.tools.reader.impl.errors.throw_dup_keys(rdr,cljs.core.cst$kw$map,ks); +} + +return cljs.core.with_meta((((map_count <= ((2) * cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)))?cljs.core.PersistentArrayMap.fromArray(cljs.core.to_array(the_map),true,true):cljs.core.PersistentHashMap.fromArray(cljs.core.to_array(the_map),true)),(cljs.core.truth_(start_line)?cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var temp__5457__auto__ = cljs.tools.reader.reader_types.get_file_name(rdr); +if(cljs.core.truth_(temp__5457__auto__)){ +var file = temp__5457__auto__; +return new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$file,file], null); +} else { +return null; +} +})(),new cljs.core.PersistentArrayMap(null, 4, [cljs.core.cst$kw$line,start_line,cljs.core.cst$kw$column,start_column,cljs.core.cst$kw$end_DASH_line,end_line,cljs.core.cst$kw$end_DASH_column,end_column], null)], 0)):null)); +}); +cljs.tools.reader.read_number = (function cljs$tools$reader$read_number(rdr,initch){ +var sb = (function (){var G__1992 = (new goog.string.StringBuffer()); +G__1992.append(initch); + +return G__1992; +})(); +var ch = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +while(true){ +if(cljs.core.truth_((function (){var or__3936__auto__ = cljs.tools.reader.impl.utils.whitespace_QMARK_(ch); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = (cljs.tools.reader.macros.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.macros.cljs$core$IFn$_invoke$arity$1(ch) : cljs.tools.reader.macros.call(null,ch)); +if(cljs.core.truth_(or__3936__auto____$1)){ +return or__3936__auto____$1; +} else { +return (ch == null); +} +} +})())){ +var s = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)].join(''); +rdr.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2(null,ch); + +var or__3936__auto__ = cljs.tools.reader.impl.commons.match_number(s); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.tools.reader.impl.errors.throw_invalid_number(rdr,s); +} +} else { +var G__1994 = (function (){var G__1993 = sb; +G__1993.append(ch); + +return G__1993; +})(); +var G__1995 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +sb = G__1994; +ch = G__1995; +continue; +} +break; +} +}); +cljs.tools.reader.escape_char = (function cljs$tools$reader$escape_char(sb,rdr){ +var ch = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +var G__1996 = ch; +switch (G__1996) { +case "t": +return "\t"; + +break; +case "r": +return "\r"; + +break; +case "n": +return "\n"; + +break; +case "\\": +return "\\"; + +break; +case "\"": +return "\""; + +break; +case "b": +return "\b"; + +break; +case "f": +return "\f"; + +break; +case "u": +var ch__$1 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(((-1) === parseInt((ch__$1 | (0)),(16)))){ +return cljs.tools.reader.impl.errors.throw_invalid_unicode_escape(rdr,ch__$1); +} else { +return cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$5(rdr,ch__$1,(16),(4),true); +} + +break; +default: +if(cljs.tools.reader.impl.utils.numeric_QMARK_(ch)){ +var ch__$1 = cljs.tools.reader.read_unicode_char.cljs$core$IFn$_invoke$arity$5(rdr,ch,(8),(3),false); +if(((ch__$1 | (0)) > (255))){ +return cljs.tools.reader.impl.errors.throw_bad_octal_number(rdr); +} else { +return ch__$1; +} +} else { +return cljs.tools.reader.impl.errors.throw_bad_escape_char(rdr,ch); +} + +} +}); +cljs.tools.reader.read_string_STAR_ = (function cljs$tools$reader$read_string_STAR_(reader,_,opts,pending_forms){ +var sb = (new goog.string.StringBuffer()); +var ch = reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +while(true){ +if((ch == null)){ +return cljs.tools.reader.impl.errors.throw_eof_reading.cljs$core$IFn$_invoke$arity$variadic(reader,cljs.core.cst$kw$string,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["\"",sb], 0)); +} else { +var G__1998 = ch; +switch (G__1998) { +case "\\": +var G__2002 = (function (){var G__1999 = sb; +G__1999.append(cljs.tools.reader.escape_char(sb,reader)); + +return G__1999; +})(); +var G__2003 = reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +sb = G__2002; +ch = G__2003; +continue; + +break; +case "\"": +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb)].join(''); + +break; +default: +var G__2004 = (function (){var G__2000 = sb; +G__2000.append(ch); + +return G__2000; +})(); +var G__2005 = reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +sb = G__2004; +ch = G__2005; +continue; + +} +} +break; +} +}); +cljs.tools.reader.loc_info = (function cljs$tools$reader$loc_info(rdr,line,column){ +if((line == null)){ +return null; +} else { +var file = cljs.tools.reader.reader_types.get_file_name(rdr); +var filem = (((file == null))?null:new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$file,file], null)); +var vec__2006 = cljs.tools.reader.ending_line_col_info(rdr); +var end_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2006,(0),null); +var end_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2006,(1),null); +var lcm = new cljs.core.PersistentArrayMap(null, 4, [cljs.core.cst$kw$line,line,cljs.core.cst$kw$column,column,cljs.core.cst$kw$end_DASH_line,end_line,cljs.core.cst$kw$end_DASH_column,end_column], null); +return cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([filem,lcm], 0)); +} +}); +cljs.tools.reader.read_symbol = (function cljs$tools$reader$read_symbol(rdr,initch){ +var vec__2009 = cljs.tools.reader.starting_line_col_info(rdr); +var line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2009,(0),null); +var column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2009,(1),null); +var token = cljs.tools.reader.read_token(rdr,cljs.core.cst$kw$symbol,initch); +if((token == null)){ +return null; +} else { +var G__2012 = token; +switch (G__2012) { +case "nil": +return null; + +break; +case "true": +return true; + +break; +case "false": +return false; + +break; +case "/": +return cljs.core.cst$sym$_SLASH_; + +break; +default: +var p = cljs.tools.reader.impl.commons.parse_symbol(token); +if(!((p == null))){ +var sym = cljs.core.symbol.cljs$core$IFn$_invoke$arity$2(p.cljs$core$IIndexed$_nth$arity$2(null,(0)),p.cljs$core$IIndexed$_nth$arity$2(null,(1))); +return sym.cljs$core$IWithMeta$_with_meta$arity$2(null,cljs.tools.reader.loc_info(rdr,line,column)); +} else { +return cljs.tools.reader.impl.errors.throw_invalid(rdr,cljs.core.cst$kw$symbol,token); +} + +} +} +}); +/** + * Map from ns alias to ns, if non-nil, it will be used to resolve read-time + * ns aliases. + * + * Defaults to nil + */ +cljs.tools.reader._STAR_alias_map_STAR_ = null; +cljs.tools.reader.resolve_alias = (function cljs$tools$reader$resolve_alias(sym){ +return cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.tools.reader._STAR_alias_map_STAR_,sym); +}); +cljs.tools.reader.resolve_ns = (function cljs$tools$reader$resolve_ns(sym){ +var or__3936__auto__ = cljs.tools.reader.resolve_alias(sym); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var temp__5457__auto__ = cljs.core.find_ns(sym); +if(cljs.core.truth_(temp__5457__auto__)){ +var ns = temp__5457__auto__; +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.ns_name(ns)); +} else { +return null; +} +} +}); +cljs.tools.reader.read_keyword = (function cljs$tools$reader$read_keyword(reader,initch,opts,pending_forms){ +var ch = reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(!(cljs.tools.reader.impl.utils.whitespace_QMARK_(ch))){ +var token = cljs.tools.reader.read_token(reader,cljs.core.cst$kw$keyword,ch); +var s = cljs.tools.reader.impl.commons.parse_symbol(token); +if(!((s == null))){ +var ns = s.cljs$core$IIndexed$_nth$arity$2(null,(0)); +var name = s.cljs$core$IIndexed$_nth$arity$2(null,(1)); +if((":" === token.charAt((0)))){ +if(!((ns == null))){ +var temp__5455__auto__ = cljs.tools.reader.resolve_alias(cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.subs.cljs$core$IFn$_invoke$arity$2(ns,(1)))); +if(cljs.core.truth_(temp__5455__auto__)){ +var ns__$1 = temp__5455__auto__; +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$2([cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns__$1)].join(''),name); +} else { +return cljs.tools.reader.impl.errors.throw_invalid(reader,cljs.core.cst$kw$keyword,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(":"),cljs.core.str.cljs$core$IFn$_invoke$arity$1(token)].join('')); +} +} else { +var temp__5455__auto__ = cljs.core._STAR_ns_STAR_; +if(cljs.core.truth_(temp__5455__auto__)){ +var ns__$1 = temp__5455__auto__; +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$2([cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns__$1)].join(''),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(name,(1))); +} else { +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(reader,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid token: :",token], 0)); +} +} +} else { +return cljs.core.keyword.cljs$core$IFn$_invoke$arity$2(ns,name); +} +} else { +return cljs.tools.reader.impl.errors.throw_invalid(reader,cljs.core.cst$kw$keyword,[cljs.core.str.cljs$core$IFn$_invoke$arity$1(":"),cljs.core.str.cljs$core$IFn$_invoke$arity$1(token)].join('')); +} +} else { +return cljs.tools.reader.impl.errors.throw_single_colon(reader); +} +}); +/** + * Returns a function which wraps a reader in a call to sym + */ +cljs.tools.reader.wrapping_reader = (function cljs$tools$reader$wrapping_reader(sym){ +return (function (rdr,_,opts,pending_forms){ +return (new cljs.core.List(null,sym,(new cljs.core.List(null,(cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)),null,(1),null)),(2),null)); +}); +}); +/** + * Read metadata and return the following object with the metadata applied + */ +cljs.tools.reader.read_meta = (function cljs$tools$reader$read_meta(rdr,_,opts,pending_forms){ +if(((cljs.tools.reader.reader_types.source_logging_reader_QMARK_(rdr)) && (!(cljs.tools.reader.impl.utils.whitespace_QMARK_(cljs.tools.reader.reader_types.peek_char(rdr)))))){ +return cljs.tools.reader.reader_types.log_source_STAR_(rdr,(function (){ +var vec__2014 = cljs.tools.reader.starting_line_col_info(rdr); +var line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2014,(0),null); +var column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2014,(1),null); +var m = cljs.tools.reader.impl.utils.desugar_meta((cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms))); +if(cljs.core.map_QMARK_(m)){ +} else { +cljs.tools.reader.impl.errors.throw_bad_metadata(rdr,m); +} + +var o = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (131072))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IMeta$))))?true:false):false)){ +var m__$1 = (cljs.core.truth_((function (){var and__3925__auto__ = line; +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.seq_QMARK_(o); +} else { +return and__3925__auto__; +} +})())?cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(m,cljs.core.cst$kw$line,line,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$column,column], 0)):m); +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (262144))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IWithMeta$))))?true:false):false)){ +return cljs.core.with_meta(o,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.meta(o),m__$1], 0))); +} else { +return cljs.core.reset_meta_BANG_(o,m__$1); +} +} else { +return cljs.tools.reader.impl.errors.throw_bad_metadata_target(rdr,o); +} +})); +} else { +var vec__2019 = cljs.tools.reader.starting_line_col_info(rdr); +var line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2019,(0),null); +var column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2019,(1),null); +var m = cljs.tools.reader.impl.utils.desugar_meta((cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms))); +if(cljs.core.map_QMARK_(m)){ +} else { +cljs.tools.reader.impl.errors.throw_bad_metadata(rdr,m); +} + +var o = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (131072))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IMeta$))))?true:false):false)){ +var m__$1 = (cljs.core.truth_((function (){var and__3925__auto__ = line; +if(cljs.core.truth_(and__3925__auto__)){ +return cljs.core.seq_QMARK_(o); +} else { +return and__3925__auto__; +} +})())?cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(m,cljs.core.cst$kw$line,line,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$column,column], 0)):m); +if(((!((o == null)))?(((((o.cljs$lang$protocol_mask$partition0$ & (262144))) || ((cljs.core.PROTOCOL_SENTINEL === o.cljs$core$IWithMeta$))))?true:false):false)){ +return cljs.core.with_meta(o,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.meta(o),m__$1], 0))); +} else { +return cljs.core.reset_meta_BANG_(o,m__$1); +} +} else { +return cljs.tools.reader.impl.errors.throw_bad_metadata_target(rdr,o); +} +} +}); +cljs.tools.reader.read_set = (function cljs$tools$reader$read_set(rdr,_,opts,pending_forms){ +var vec__2024 = cljs.tools.reader.starting_line_col_info(rdr); +var start_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2024,(0),null); +var start_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2024,(1),null); +var start_column__$1 = (cljs.core.truth_(start_column)?((start_column - (1)) | (0)):null); +var coll = cljs.tools.reader.read_delimited(cljs.core.cst$kw$set,"}",rdr,opts,pending_forms); +var the_set = cljs.core.set(coll); +var vec__2027 = cljs.tools.reader.ending_line_col_info(rdr); +var end_line = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2027,(0),null); +var end_column = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__2027,(1),null); +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(coll),cljs.core.count(the_set))){ +} else { +cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.tools.reader.impl.errors.throw_dup_keys(rdr,cljs.core.cst$kw$set,coll)], 0)); +} + +return cljs.core.with_meta(the_set,(cljs.core.truth_(start_line)?cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(function (){var temp__5457__auto__ = cljs.tools.reader.reader_types.get_file_name(rdr); +if(cljs.core.truth_(temp__5457__auto__)){ +var file = temp__5457__auto__; +return new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$file,file], null); +} else { +return null; +} +})(),new cljs.core.PersistentArrayMap(null, 4, [cljs.core.cst$kw$line,start_line,cljs.core.cst$kw$column,start_column__$1,cljs.core.cst$kw$end_DASH_line,end_line,cljs.core.cst$kw$end_DASH_column,end_column], null)], 0)):null)); +}); +/** + * Read and discard the first object from rdr + */ +cljs.tools.reader.read_discard = (function cljs$tools$reader$read_discard(rdr,_,opts,pending_forms){ +var G__2030 = rdr; +(cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(G__2030,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,G__2030,true,null,opts,pending_forms)); + +return G__2030; +}); +cljs.tools.reader.read_symbolic_value = (function cljs$tools$reader$read_symbolic_value(rdr,_,opts,pending_forms){ +var sym = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +var G__2031 = sym; +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$sym$NaN,G__2031)){ +return Number.NaN; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$sym$_DASH_Inf,G__2031)){ +return Number.NEGATIVE_INFINITY; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$sym$Inf,G__2031)){ +return Number.POSITIVE_INFINITY; +} else { +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([["Invalid token: ##",cljs.core.str.cljs$core$IFn$_invoke$arity$1(sym)].join('')], 0)); + +} +} +} +}); +cljs.tools.reader.RESERVED_FEATURES = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$else,null,cljs.core.cst$kw$none,null], null), null); +cljs.tools.reader.has_feature_QMARK_ = (function cljs$tools$reader$has_feature_QMARK_(rdr,feature,opts){ +if((feature instanceof cljs.core.Keyword)){ +return ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$kw$default,feature)) || (cljs.core.contains_QMARK_(cljs.core.get.cljs$core$IFn$_invoke$arity$2(opts,cljs.core.cst$kw$features),feature))); +} else { +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Feature should be a keyword: ",feature], 0)); +} +}); +cljs.tools.reader.check_eof_error = (function cljs$tools$reader$check_eof_error(form,rdr,first_line){ +if((form === cljs.tools.reader.READ_EOF)){ +return cljs.tools.reader.impl.errors.throw_eof_error(rdr,(function (){var and__3925__auto__ = (first_line < (0)); +if(and__3925__auto__){ +return first_line; +} else { +return and__3925__auto__; +} +})()); +} else { +return null; +} +}); +cljs.tools.reader.check_reserved_features = (function cljs$tools$reader$check_reserved_features(rdr,form){ +if(cljs.core.truth_(cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.tools.reader.RESERVED_FEATURES,form))){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Feature name ",form," is reserved"], 0)); +} else { +return null; +} +}); +cljs.tools.reader.check_invalid_read_cond = (function cljs$tools$reader$check_invalid_read_cond(form,rdr,first_line){ +if((form === cljs.tools.reader.READ_FINISHED)){ +if((first_line < (0))){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["read-cond requires an even number of forms"], 0)); +} else { +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["read-cond starting on line ",first_line," requires an even number of forms"], 0)); +} +} else { +return null; +} +}); +/** + * Read next form and suppress. Return nil or READ_FINISHED. + */ +cljs.tools.reader.read_suppress = (function cljs$tools$reader$read_suppress(first_line,rdr,opts,pending_forms){ +var _STAR_suppress_read_STAR_2032 = cljs.tools.reader._STAR_suppress_read_STAR_; +cljs.tools.reader._STAR_suppress_read_STAR_ = true; + +try{var form = (function (){var G__2033 = rdr; +var G__2034 = false; +var G__2035 = cljs.tools.reader.READ_EOF; +var G__2036 = ")"; +var G__2037 = opts; +var G__2038 = pending_forms; +return (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(G__2033,G__2034,G__2035,G__2036,G__2037,G__2038) : cljs.tools.reader.read_STAR_.call(null,G__2033,G__2034,G__2035,G__2036,G__2037,G__2038)); +})(); +cljs.tools.reader.check_eof_error(form,rdr,first_line); + +if((form === cljs.tools.reader.READ_FINISHED)){ +return cljs.tools.reader.READ_FINISHED; +} else { +return null; +} +}finally {cljs.tools.reader._STAR_suppress_read_STAR_ = _STAR_suppress_read_STAR_2032; +}}); +if((typeof cljs !== 'undefined') && (typeof cljs.tools !== 'undefined') && (typeof cljs.tools.reader !== 'undefined') && (typeof cljs.tools.reader.NO_MATCH !== 'undefined')){ +} else { +cljs.tools.reader.NO_MATCH = (new Object()); +} +/** + * Read next feature. If matched, read next form and return. + * Otherwise, read and skip next form, returning READ_FINISHED or nil. + */ +cljs.tools.reader.match_feature = (function cljs$tools$reader$match_feature(first_line,rdr,opts,pending_forms){ +var feature = (function (){var G__2039 = rdr; +var G__2040 = false; +var G__2041 = cljs.tools.reader.READ_EOF; +var G__2042 = ")"; +var G__2043 = opts; +var G__2044 = pending_forms; +return (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(G__2039,G__2040,G__2041,G__2042,G__2043,G__2044) : cljs.tools.reader.read_STAR_.call(null,G__2039,G__2040,G__2041,G__2042,G__2043,G__2044)); +})(); +cljs.tools.reader.check_eof_error(feature,rdr,first_line); + +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(feature,cljs.tools.reader.READ_FINISHED)){ +return cljs.tools.reader.READ_FINISHED; +} else { +cljs.tools.reader.check_reserved_features(rdr,feature); + +if(cljs.core.truth_(cljs.tools.reader.has_feature_QMARK_(rdr,feature,opts))){ +var G__2045 = (function (){var G__2046 = rdr; +var G__2047 = false; +var G__2048 = cljs.tools.reader.READ_EOF; +var G__2049 = ")"; +var G__2050 = opts; +var G__2051 = pending_forms; +return (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(G__2046,G__2047,G__2048,G__2049,G__2050,G__2051) : cljs.tools.reader.read_STAR_.call(null,G__2046,G__2047,G__2048,G__2049,G__2050,G__2051)); +})(); +cljs.tools.reader.check_eof_error(G__2045,rdr,first_line); + +cljs.tools.reader.check_invalid_read_cond(G__2045,rdr,first_line); + +return G__2045; +} else { +var or__3936__auto__ = cljs.tools.reader.read_suppress(first_line,rdr,opts,pending_forms); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.tools.reader.NO_MATCH; +} +} +} +}); +cljs.tools.reader.read_cond_delimited = (function cljs$tools$reader$read_cond_delimited(rdr,splicing,opts,pending_forms){ +var first_line = (cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(rdr))?cljs.tools.reader.reader_types.get_line_number(rdr):(-1)); +var result = (function (){var matched = cljs.tools.reader.NO_MATCH; +var finished = null; +while(true){ +if((matched === cljs.tools.reader.NO_MATCH)){ +var match = cljs.tools.reader.match_feature(first_line,rdr,opts,pending_forms); +if((match === cljs.tools.reader.READ_FINISHED)){ +return cljs.tools.reader.READ_FINISHED; +} else { +var G__2056 = match; +var G__2057 = null; +matched = G__2056; +finished = G__2057; +continue; +} +} else { +if(!((finished === cljs.tools.reader.READ_FINISHED))){ +var G__2058 = matched; +var G__2059 = cljs.tools.reader.read_suppress(first_line,rdr,opts,pending_forms); +matched = G__2058; +finished = G__2059; +continue; +} else { +return matched; + +} +} +break; +} +})(); +if((result === cljs.tools.reader.READ_FINISHED)){ +return rdr; +} else { +if(cljs.core.truth_(splicing)){ +if(((!((result == null)))?(((((result.cljs$lang$protocol_mask$partition0$ & (16777216))) || ((cljs.core.PROTOCOL_SENTINEL === result.cljs$core$ISequential$))))?true:false):false)){ +var G__2053_2060 = pending_forms; +var G__2054_2061 = cljs.core.to_array(result); +var G__2055_2062 = (0); +goog.array.insertArrayAt(G__2053_2060,G__2054_2061,G__2055_2062); + +return rdr; +} else { +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Spliced form list in read-cond-splicing must implement ISequential"], 0)); +} +} else { +return result; +} +} +}); +cljs.tools.reader.read_cond = (function cljs$tools$reader$read_cond(rdr,_,opts,pending_forms){ +if(cljs.core.not((function (){var and__3925__auto__ = opts; +if(cljs.core.truth_(and__3925__auto__)){ +var G__2064 = cljs.core.cst$kw$read_DASH_cond.cljs$core$IFn$_invoke$arity$1(opts); +var fexpr__2063 = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$preserve,null,cljs.core.cst$kw$allow,null], null), null); +return (fexpr__2063.cljs$core$IFn$_invoke$arity$1 ? fexpr__2063.cljs$core$IFn$_invoke$arity$1(G__2064) : fexpr__2063.call(null,G__2064)); +} else { +return and__3925__auto__; +} +})())){ +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("Conditional read not allowed",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$runtime_DASH_exception], null)); +} else { +} + +var temp__5455__auto__ = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(cljs.core.truth_(temp__5455__auto__)){ +var ch = temp__5455__auto__; +var splicing = cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ch,"@"); +var ch__$1 = ((splicing)?rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null):ch); +if(splicing){ +if(cljs.tools.reader._STAR_read_delim_STAR_){ +} else { +cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["cond-splice not in list"], 0)); +} +} else { +} + +var temp__5455__auto____$1 = ((cljs.tools.reader.impl.utils.whitespace_QMARK_(ch__$1))?cljs.tools.reader.impl.commons.read_past(cljs.tools.reader.impl.utils.whitespace_QMARK_,rdr):ch__$1); +if(cljs.core.truth_(temp__5455__auto____$1)){ +var ch__$2 = temp__5455__auto____$1; +if(cljs.core.not_EQ_.cljs$core$IFn$_invoke$arity$2(ch__$2,"(")){ +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("read-cond body must be a list",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$runtime_DASH_exception], null)); +} else { +var _STAR_suppress_read_STAR_2065 = cljs.tools.reader._STAR_suppress_read_STAR_; +cljs.tools.reader._STAR_suppress_read_STAR_ = (function (){var or__3936__auto__ = cljs.tools.reader._STAR_suppress_read_STAR_; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$kw$preserve,cljs.core.cst$kw$read_DASH_cond.cljs$core$IFn$_invoke$arity$1(opts)); +} +})(); + +try{if(cljs.core.truth_(cljs.tools.reader._STAR_suppress_read_STAR_)){ +return cljs.tools.reader.impl.utils.reader_conditional(cljs.tools.reader.read_list(rdr,ch__$2,opts,pending_forms),splicing); +} else { +return cljs.tools.reader.read_cond_delimited(rdr,splicing,opts,pending_forms); +} +}finally {cljs.tools.reader._STAR_suppress_read_STAR_ = _STAR_suppress_read_STAR_2065; +}} +} else { +return cljs.tools.reader.impl.errors.throw_eof_in_character(rdr); +} +} else { +return cljs.tools.reader.impl.errors.throw_eof_in_character(rdr); +} +}); +cljs.tools.reader.arg_env = null; +/** + * Get a symbol for an anonymous ?argument? + */ +cljs.tools.reader.garg = (function cljs$tools$reader$garg(n){ +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(((((-1) === n))?"rest":["p",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)].join(''))),"__",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.tools.reader.impl.utils.next_id()),"#"].join('')); +}); +cljs.tools.reader.read_fn = (function cljs$tools$reader$read_fn(rdr,_,opts,pending_forms){ +if(cljs.core.truth_(cljs.tools.reader.arg_env)){ +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("Nested #()s are not allowed",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$illegal_DASH_state], null)); +} else { +} + +var arg_env2066 = cljs.tools.reader.arg_env; +cljs.tools.reader.arg_env = cljs.core.sorted_map(); + +try{var form = (function (){var G__2067 = (function (){var G__2072 = rdr; +cljs.tools.reader.reader_types.unread(G__2072,"("); + +return G__2072; +})(); +var G__2068 = true; +var G__2069 = null; +var G__2070 = opts; +var G__2071 = pending_forms; +return (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(G__2067,G__2068,G__2069,G__2070,G__2071) : cljs.tools.reader.read_STAR_.call(null,G__2067,G__2068,G__2069,G__2070,G__2071)); +})(); +var rargs = cljs.core.rseq(cljs.tools.reader.arg_env); +var args = ((rargs)?(function (){var higharg = cljs.core.key(cljs.core.first(rargs)); +var args = (function (){var i = (1); +var args = cljs.core.transient$(cljs.core.PersistentVector.EMPTY); +while(true){ +if((i > higharg)){ +return cljs.core.persistent_BANG_(args); +} else { +var G__2073 = (i + (1)); +var G__2074 = cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(args,(function (){var or__3936__auto__ = cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.tools.reader.arg_env,i); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return cljs.tools.reader.garg(i); +} +})()); +i = G__2073; +args = G__2074; +continue; +} +break; +} +})(); +var args__$1 = (cljs.core.truth_((cljs.tools.reader.arg_env.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.arg_env.cljs$core$IFn$_invoke$arity$1((-1)) : cljs.tools.reader.arg_env.call(null,(-1))))?cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(args,cljs.core.cst$sym$_AMPERSAND_,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([(cljs.tools.reader.arg_env.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.arg_env.cljs$core$IFn$_invoke$arity$1((-1)) : cljs.tools.reader.arg_env.call(null,(-1)))], 0)):args); +return args__$1; +})():cljs.core.PersistentVector.EMPTY); +return (new cljs.core.List(null,cljs.core.cst$sym$fn_STAR_,(new cljs.core.List(null,args,(new cljs.core.List(null,form,null,(1),null)),(2),null)),(3),null)); +}finally {cljs.tools.reader.arg_env = arg_env2066; +}}); +/** + * Registers an argument to the arg-env + */ +cljs.tools.reader.register_arg = (function cljs$tools$reader$register_arg(n){ +if(cljs.core.truth_(cljs.tools.reader.arg_env)){ +var temp__5455__auto__ = (cljs.tools.reader.arg_env.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.arg_env.cljs$core$IFn$_invoke$arity$1(n) : cljs.tools.reader.arg_env.call(null,n)); +if(cljs.core.truth_(temp__5455__auto__)){ +var ret = temp__5455__auto__; +return ret; +} else { +var g = cljs.tools.reader.garg(n); +cljs.tools.reader.arg_env = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.tools.reader.arg_env,n,g); + +return g; +} +} else { +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("Arg literal not in #()",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$illegal_DASH_state], null)); +} +}); +cljs.tools.reader.read_arg = (function cljs$tools$reader$read_arg(rdr,pct,opts,pending_forms){ +if((cljs.tools.reader.arg_env == null)){ +return cljs.tools.reader.read_symbol(rdr,pct); +} else { +var ch = rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null); +if(((cljs.tools.reader.impl.utils.whitespace_QMARK_(ch)) || (cljs.tools.reader.macro_terminating_QMARK_(ch)) || ((ch == null)))){ +return cljs.tools.reader.register_arg((1)); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(ch,"&")){ +rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); + +return cljs.tools.reader.register_arg((-1)); +} else { +var n = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +if(!(cljs.core.integer_QMARK_(n))){ +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("Arg literal must be %, %& or %integer",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$illegal_DASH_state], null)); +} else { +return cljs.tools.reader.register_arg(n); +} + +} +} +} +}); +cljs.tools.reader.gensym_env = null; +cljs.tools.reader.read_unquote = (function cljs$tools$reader$read_unquote(rdr,comma,opts,pending_forms){ +var temp__5455__auto__ = rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null); +if(cljs.core.truth_(temp__5455__auto__)){ +var ch = temp__5455__auto__; +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2("@",ch)){ +var G__2076 = (function (){var G__2080 = rdr; +G__2080.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); + +return G__2080; +})(); +var G__2077 = "@"; +var G__2078 = opts; +var G__2079 = pending_forms; +var fexpr__2075 = cljs.tools.reader.wrapping_reader(cljs.core.cst$sym$clojure$core_SLASH_unquote_DASH_splicing); +return (fexpr__2075.cljs$core$IFn$_invoke$arity$4 ? fexpr__2075.cljs$core$IFn$_invoke$arity$4(G__2076,G__2077,G__2078,G__2079) : fexpr__2075.call(null,G__2076,G__2077,G__2078,G__2079)); +} else { +var G__2082 = rdr; +var G__2083 = "~"; +var G__2084 = opts; +var G__2085 = pending_forms; +var fexpr__2081 = cljs.tools.reader.wrapping_reader(cljs.core.cst$sym$clojure$core_SLASH_unquote); +return (fexpr__2081.cljs$core$IFn$_invoke$arity$4 ? fexpr__2081.cljs$core$IFn$_invoke$arity$4(G__2082,G__2083,G__2084,G__2085) : fexpr__2081.call(null,G__2082,G__2083,G__2084,G__2085)); +} +} else { +return null; +} +}); +cljs.tools.reader.unquote_splicing_QMARK_ = (function cljs$tools$reader$unquote_splicing_QMARK_(form){ +return ((cljs.core.seq_QMARK_(form)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.first(form),cljs.core.cst$sym$clojure$core_SLASH_unquote_DASH_splicing))); +}); +cljs.tools.reader.unquote_QMARK_ = (function cljs$tools$reader$unquote_QMARK_(form){ +return ((cljs.core.seq_QMARK_(form)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.first(form),cljs.core.cst$sym$clojure$core_SLASH_unquote))); +}); +/** + * Expand a list by resolving its syntax quotes and unquotes + */ +cljs.tools.reader.expand_list = (function cljs$tools$reader$expand_list(s){ +var s__$1 = cljs.core.seq(s); +var r = cljs.core.transient$(cljs.core.PersistentVector.EMPTY); +while(true){ +if(s__$1){ +var item = cljs.core.first(s__$1); +var ret = cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(r,(cljs.core.truth_(cljs.tools.reader.unquote_QMARK_(item))?(new cljs.core.List(null,cljs.core.cst$sym$clojure$core_SLASH_list,(new cljs.core.List(null,cljs.core.second(item),null,(1),null)),(2),null)):(cljs.core.truth_(cljs.tools.reader.unquote_splicing_QMARK_(item))?cljs.core.second(item):(new cljs.core.List(null,cljs.core.cst$sym$clojure$core_SLASH_list,(new cljs.core.List(null,(cljs.tools.reader.syntax_quote_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.syntax_quote_STAR_.cljs$core$IFn$_invoke$arity$1(item) : cljs.tools.reader.syntax_quote_STAR_.call(null,item)),null,(1),null)),(2),null)) +))); +var G__2086 = cljs.core.next(s__$1); +var G__2087 = ret; +s__$1 = G__2086; +r = G__2087; +continue; +} else { +return cljs.core.seq(cljs.core.persistent_BANG_(r)); +} +break; +} +}); +/** + * Flatten a map into a seq of alternate keys and values + */ +cljs.tools.reader.flatten_map = (function cljs$tools$reader$flatten_map(form){ +var s = cljs.core.seq(form); +var key_vals = cljs.core.transient$(cljs.core.PersistentVector.EMPTY); +while(true){ +if(s){ +var e = cljs.core.first(s); +var G__2088 = cljs.core.next(s); +var G__2089 = cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(cljs.core.conj_BANG_.cljs$core$IFn$_invoke$arity$2(key_vals,cljs.core.key(e)),cljs.core.val(e)); +s = G__2088; +key_vals = G__2089; +continue; +} else { +return cljs.core.seq(cljs.core.persistent_BANG_(key_vals)); +} +break; +} +}); +cljs.tools.reader.register_gensym = (function cljs$tools$reader$register_gensym(sym){ +if(cljs.core.not(cljs.tools.reader.gensym_env)){ +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("Gensym literal not in syntax-quote",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$illegal_DASH_state], null)); +} else { +} + +var or__3936__auto__ = cljs.core.get.cljs$core$IFn$_invoke$arity$2(cljs.tools.reader.gensym_env,sym); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +var gs = cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.subs.cljs$core$IFn$_invoke$arity$3(cljs.core.name(sym),(0),(cljs.core.count(cljs.core.name(sym)) - (1)))),"__",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.tools.reader.impl.utils.next_id()),"__auto__"].join('')); +cljs.tools.reader.gensym_env = cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(cljs.tools.reader.gensym_env,sym,gs); + +return gs; +} +}); +cljs.tools.reader.add_meta = (function cljs$tools$reader$add_meta(form,ret){ +if((function (){var and__3925__auto__ = ((!((form == null)))?(((((form.cljs$lang$protocol_mask$partition0$ & (262144))) || ((cljs.core.PROTOCOL_SENTINEL === form.cljs$core$IWithMeta$))))?true:false):false); +if(and__3925__auto__){ +return cljs.core.seq(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(cljs.core.meta(form),cljs.core.cst$kw$line,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$column,cljs.core.cst$kw$end_DASH_line,cljs.core.cst$kw$end_DASH_column,cljs.core.cst$kw$file,cljs.core.cst$kw$source], 0))); +} else { +return and__3925__auto__; +} +})()){ +return (new cljs.core.List(null,cljs.core.cst$sym$cljs$core_SLASH_with_DASH_meta,(new cljs.core.List(null,ret,(new cljs.core.List(null,(function (){var G__2092 = cljs.core.meta(form); +return (cljs.tools.reader.syntax_quote_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.syntax_quote_STAR_.cljs$core$IFn$_invoke$arity$1(G__2092) : cljs.tools.reader.syntax_quote_STAR_.call(null,G__2092)); +})(),null,(1),null)),(2),null)),(3),null)); +} else { +return ret; +} +}); +cljs.tools.reader.syntax_quote_coll = (function cljs$tools$reader$syntax_quote_coll(type,coll){ +var res = (new cljs.core.List(null,cljs.core.cst$sym$cljs$core_SLASH_sequence,(new cljs.core.List(null,cljs.core.cons(cljs.core.cst$sym$cljs$core_SLASH_concat,cljs.tools.reader.expand_list(coll)),null,(1),null)),(2),null)); +if(cljs.core.truth_(type)){ +return (new cljs.core.List(null,cljs.core.cst$sym$cljs$core_SLASH_apply,(new cljs.core.List(null,type,(new cljs.core.List(null,res,null,(1),null)),(2),null)),(3),null)); +} else { +return res; +} +}); +/** + * Decide which map type to use, array-map if less than 16 elements + */ +cljs.tools.reader.map_func = (function cljs$tools$reader$map_func(coll){ +if((cljs.core.count(coll) >= (16))){ +return cljs.core.cst$sym$cljs$core_SLASH_hash_DASH_map; +} else { +return cljs.core.cst$sym$cljs$core_SLASH_array_DASH_map; +} +}); +cljs.tools.reader.bool_QMARK_ = (function cljs$tools$reader$bool_QMARK_(x){ +return (((x instanceof Boolean)) || (x === true) || (x === false)); +}); +/** + * Resolve a symbol s into its fully qualified namespace version + */ +cljs.tools.reader.resolve_symbol = (function cljs$tools$reader$resolve_symbol(s){ +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("resolve-symbol is not implemented",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$sym,s], null)); +}); +cljs.tools.reader.syntax_quote_STAR_ = (function cljs$tools$reader$syntax_quote_STAR_(form){ +return cljs.tools.reader.add_meta(form,((cljs.core.special_symbol_QMARK_(form))?(new cljs.core.List(null,cljs.core.cst$sym$quote,(new cljs.core.List(null,form,null,(1),null)),(2),null)):(((form instanceof cljs.core.Symbol))?(new cljs.core.List(null,cljs.core.cst$sym$quote,(new cljs.core.List(null,(cljs.core.truth_((function (){var and__3925__auto__ = cljs.core.not(cljs.core.namespace(form)); +if(and__3925__auto__){ +var G__2095 = cljs.core.name(form); +var G__2096 = "#"; +return goog.string.endsWith(G__2095,G__2096); +} else { +return and__3925__auto__; +} +})())?cljs.tools.reader.register_gensym(form):(function (){var sym = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(form)].join(''); +if(cljs.core.truth_(goog.string.endsWith(sym,"."))){ +var csym = cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(cljs.core.subs.cljs$core$IFn$_invoke$arity$3(sym,(0),(cljs.core.count(sym) - (1)))); +return cljs.core.symbol.cljs$core$IFn$_invoke$arity$1([cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.tools.reader.resolve_symbol.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.resolve_symbol.cljs$core$IFn$_invoke$arity$1(csym) : cljs.tools.reader.resolve_symbol.call(null,csym))),"."].join('')); +} else { +return (cljs.tools.reader.resolve_symbol.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.resolve_symbol.cljs$core$IFn$_invoke$arity$1(form) : cljs.tools.reader.resolve_symbol.call(null,form)); +} +})()),null,(1),null)),(2),null)):(cljs.core.truth_(cljs.tools.reader.unquote_QMARK_(form))?cljs.core.second(form):(cljs.core.truth_(cljs.tools.reader.unquote_splicing_QMARK_(form))?(function(){throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("unquote-splice not in list",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$illegal_DASH_state], null))})():((cljs.core.coll_QMARK_(form))?((((!((form == null)))?(((((form.cljs$lang$protocol_mask$partition0$ & (67108864))) || ((cljs.core.PROTOCOL_SENTINEL === form.cljs$core$IRecord$))))?true:false):false))?form:((cljs.core.map_QMARK_(form))?cljs.tools.reader.syntax_quote_coll(cljs.tools.reader.map_func(form),cljs.tools.reader.flatten_map(form)):((cljs.core.vector_QMARK_(form))?(new cljs.core.List(null,cljs.core.cst$sym$cljs$core_SLASH_vec,(new cljs.core.List(null,cljs.tools.reader.syntax_quote_coll(null,form),null,(1),null)),(2),null)):((cljs.core.set_QMARK_(form))?cljs.tools.reader.syntax_quote_coll(cljs.core.cst$sym$cljs$core_SLASH_hash_DASH_set,form):((((cljs.core.seq_QMARK_(form)) || (cljs.core.list_QMARK_(form))))?(function (){var seq = cljs.core.seq(form); +if(seq){ +return cljs.tools.reader.syntax_quote_coll(null,seq); +} else { +return cljs.core.list(cljs.core.cst$sym$cljs$core_SLASH_list); +} +})():(function(){throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2("Unknown Collection type",new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$unsupported_DASH_operation], null))})() +))))):(cljs.core.truth_((function (){var or__3936__auto__ = (form instanceof cljs.core.Keyword); +if(or__3936__auto__){ +return or__3936__auto__; +} else { +var or__3936__auto____$1 = typeof form === 'number'; +if(or__3936__auto____$1){ +return or__3936__auto____$1; +} else { +var or__3936__auto____$2 = typeof form === 'string'; +if(or__3936__auto____$2){ +return or__3936__auto____$2; +} else { +var or__3936__auto____$3 = (form == null); +if(or__3936__auto____$3){ +return or__3936__auto____$3; +} else { +var or__3936__auto____$4 = cljs.tools.reader.bool_QMARK_(form); +if(cljs.core.truth_(or__3936__auto____$4)){ +return or__3936__auto____$4; +} else { +return (form instanceof RegExp); +} +} +} +} +} +})())?form:(new cljs.core.List(null,cljs.core.cst$sym$quote,(new cljs.core.List(null,form,null,(1),null)),(2),null)) +))))))); +}); +cljs.tools.reader.read_syntax_quote = (function cljs$tools$reader$read_syntax_quote(rdr,backquote,opts,pending_forms){ +var gensym_env2098 = cljs.tools.reader.gensym_env; +cljs.tools.reader.gensym_env = cljs.core.PersistentArrayMap.EMPTY; + +try{return cljs.tools.reader.syntax_quote_STAR_((cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms))); +}finally {cljs.tools.reader.gensym_env = gensym_env2098; +}}); +cljs.tools.reader.read_namespaced_map = (function cljs$tools$reader$read_namespaced_map(rdr,_,opts,pending_forms){ +var token = cljs.tools.reader.read_token(rdr,cljs.core.cst$kw$namespaced_DASH_map,cljs.tools.reader.reader_types.read_char(rdr)); +var temp__5455__auto__ = ((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(token,":"))?cljs.core.ns_name(cljs.core._STAR_ns_STAR_):((cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(":",cljs.core.first(token)))?(function (){var G__2099 = token; +var G__2099__$1 = (((G__2099 == null))?null:cljs.core.subs.cljs$core$IFn$_invoke$arity$2(G__2099,(1))); +var G__2099__$2 = (((G__2099__$1 == null))?null:cljs.tools.reader.impl.commons.parse_symbol(G__2099__$1)); +var G__2099__$3 = (((G__2099__$2 == null))?null:cljs.tools.reader.impl.utils.second_SINGLEQUOTE_(G__2099__$2)); +var G__2099__$4 = (((G__2099__$3 == null))?null:cljs.core.symbol.cljs$core$IFn$_invoke$arity$1(G__2099__$3)); +if((G__2099__$4 == null)){ +return null; +} else { +return cljs.tools.reader.resolve_ns(G__2099__$4); +} +})():(function (){var G__2100 = token; +var G__2100__$1 = (((G__2100 == null))?null:cljs.tools.reader.impl.commons.parse_symbol(G__2100)); +if((G__2100__$1 == null)){ +return null; +} else { +return cljs.tools.reader.impl.utils.second_SINGLEQUOTE_(G__2100__$1); +} +})() +)); +if(cljs.core.truth_(temp__5455__auto__)){ +var ns = temp__5455__auto__; +var ch = cljs.tools.reader.impl.commons.read_past(cljs.tools.reader.impl.utils.whitespace_QMARK_,rdr); +if((ch === "{")){ +var items = cljs.tools.reader.read_delimited(cljs.core.cst$kw$namespaced_DASH_map,"}",rdr,opts,pending_forms); +if(cljs.core.odd_QMARK_(cljs.core.count(items))){ +cljs.tools.reader.impl.errors.throw_odd_map(rdr,null,null,items); +} else { +} + +var keys = cljs.tools.reader.impl.utils.namespace_keys([cljs.core.str.cljs$core$IFn$_invoke$arity$1(ns)].join(''),cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),items)); +var vals = cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),cljs.core.rest(items)); +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(cljs.core.set(keys)),cljs.core.count(keys))){ +} else { +cljs.tools.reader.impl.errors.throw_dup_keys(rdr,cljs.core.cst$kw$namespaced_DASH_map,keys); +} + +return cljs.core.zipmap(keys,vals); +} else { +return cljs.tools.reader.impl.errors.throw_ns_map_no_map(rdr,token); +} +} else { +return cljs.tools.reader.impl.errors.throw_bad_ns(rdr,token); +} +}); +cljs.tools.reader.macros = (function cljs$tools$reader$macros(ch){ +var G__2101 = ch; +switch (G__2101) { +case "\"": +return cljs.tools.reader.read_string_STAR_; + +break; +case ":": +return cljs.tools.reader.read_keyword; + +break; +case ";": +return cljs.tools.reader.impl.commons.read_comment; + +break; +case "'": +return cljs.tools.reader.wrapping_reader(cljs.core.cst$sym$quote); + +break; +case "@": +return cljs.tools.reader.wrapping_reader(cljs.core.cst$sym$clojure$core_SLASH_deref); + +break; +case "^": +return cljs.tools.reader.read_meta; + +break; +case "`": +return cljs.tools.reader.read_syntax_quote; + +break; +case "~": +return cljs.tools.reader.read_unquote; + +break; +case "(": +return cljs.tools.reader.read_list; + +break; +case ")": +return cljs.tools.reader.read_unmatched_delimiter; + +break; +case "[": +return cljs.tools.reader.read_vector; + +break; +case "]": +return cljs.tools.reader.read_unmatched_delimiter; + +break; +case "{": +return cljs.tools.reader.read_map; + +break; +case "}": +return cljs.tools.reader.read_unmatched_delimiter; + +break; +case "\\": +return cljs.tools.reader.read_char_STAR_; + +break; +case "%": +return cljs.tools.reader.read_arg; + +break; +case "#": +return cljs.tools.reader.read_dispatch; + +break; +default: +return null; + +} +}); +cljs.tools.reader.dispatch_macros = (function cljs$tools$reader$dispatch_macros(ch){ +var G__2103 = ch; +switch (G__2103) { +case "^": +return cljs.tools.reader.read_meta; + +break; +case "'": +return cljs.tools.reader.wrapping_reader(cljs.core.cst$sym$var); + +break; +case "(": +return cljs.tools.reader.read_fn; + +break; +case "{": +return cljs.tools.reader.read_set; + +break; +case "<": +return cljs.tools.reader.impl.commons.throwing_reader("Unreadable form"); + +break; +case "=": +return cljs.tools.reader.impl.commons.throwing_reader("read-eval not supported"); + +break; +case "\"": +return cljs.tools.reader.read_regex; + +break; +case "!": +return cljs.tools.reader.impl.commons.read_comment; + +break; +case "_": +return cljs.tools.reader.read_discard; + +break; +case "?": +return cljs.tools.reader.read_cond; + +break; +case ":": +return cljs.tools.reader.read_namespaced_map; + +break; +case "#": +return cljs.tools.reader.read_symbolic_value; + +break; +default: +return null; + +} +}); +cljs.tools.reader.read_tagged = (function cljs$tools$reader$read_tagged(rdr,initch,opts,pending_forms){ +var tag = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +if(!((tag instanceof cljs.core.Symbol))){ +cljs.tools.reader.impl.errors.throw_bad_reader_tag(rdr,tag); +} else { +} + +if(cljs.core.truth_(cljs.tools.reader._STAR_suppress_read_STAR_)){ +return cljs.core.tagged_literal(tag,(cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms))); +} else { +var temp__5455__auto__ = (function (){var or__3936__auto__ = (cljs.tools.reader._STAR_data_readers_STAR_.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader._STAR_data_readers_STAR_.cljs$core$IFn$_invoke$arity$1(tag) : cljs.tools.reader._STAR_data_readers_STAR_.call(null,tag)); +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return (cljs.tools.reader.default_data_readers.cljs$core$IFn$_invoke$arity$1 ? cljs.tools.reader.default_data_readers.cljs$core$IFn$_invoke$arity$1(tag) : cljs.tools.reader.default_data_readers.call(null,tag)); +} +})(); +if(cljs.core.truth_(temp__5455__auto__)){ +var f = temp__5455__auto__; +var G__2105 = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__2105) : f.call(null,G__2105)); +} else { +var temp__5455__auto____$1 = cljs.tools.reader._STAR_default_data_reader_fn_STAR_; +if(cljs.core.truth_(temp__5455__auto____$1)){ +var f = temp__5455__auto____$1; +var G__2106 = tag; +var G__2107 = (cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 ? cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5(rdr,true,null,opts,pending_forms) : cljs.tools.reader.read_STAR_.call(null,rdr,true,null,opts,pending_forms)); +return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__2106,G__2107) : f.call(null,G__2106,G__2107)); +} else { +return cljs.tools.reader.impl.errors.throw_unknown_reader_tag(rdr,tag); +} +} +} +}); +/** + * Map from reader tag symbols to data reader Vars. + * Reader tags without namespace qualifiers are reserved for Clojure. + * This light version of tools.reader has no implementation for default + * reader tags such as #inst and #uuid. + */ +cljs.tools.reader._STAR_data_readers_STAR_ = cljs.core.PersistentArrayMap.EMPTY; +/** + * When no data reader is found for a tag and *default-data-reader-fn* + * is non-nil, it will be called with two arguments, the tag and the value. + * If *default-data-reader-fn* is nil (the default value), an exception + * will be thrown for the unknown tag. + */ +cljs.tools.reader._STAR_default_data_reader_fn_STAR_ = null; +cljs.tools.reader._STAR_suppress_read_STAR_ = false; +/** + * Default map of data reader functions provided by Clojure. + * May be overridden by binding *data-readers* + */ +cljs.tools.reader.default_data_readers = cljs.core.PersistentArrayMap.EMPTY; +cljs.tools.reader.read_STAR__internal = (function cljs$tools$reader$read_STAR__internal(reader,eof_error_QMARK_,sentinel,return_on,opts,pending_forms){ +while(true){ +if(((cljs.tools.reader.reader_types.source_logging_reader_QMARK_(reader)) && (!(cljs.tools.reader.impl.utils.whitespace_QMARK_(reader.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null)))))){ +return cljs.tools.reader.reader_types.log_source_STAR_(reader,(function (){ +while(true){ +if(!(goog.array.isEmpty(pending_forms))){ +var form = (pending_forms[(0)]); +goog.array.removeAt(pending_forms,(0)); + +return form; +} else { +var ch = reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(cljs.tools.reader.impl.utils.whitespace_QMARK_(ch)){ +continue; +} else { +if((ch == null)){ +if(eof_error_QMARK_){ +return cljs.tools.reader.impl.errors.throw_eof_error(reader,null); +} else { +return sentinel; +} +} else { +if((ch === return_on)){ +return cljs.tools.reader.READ_FINISHED; +} else { +if(cljs.tools.reader.impl.commons.number_literal_QMARK_(reader,ch)){ +return cljs.tools.reader.read_number(reader,ch); +} else { +var f = cljs.tools.reader.macros(ch); +if(!((f == null))){ +var res = (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(reader,ch,opts,pending_forms) : f.call(null,reader,ch,opts,pending_forms)); +if((res === reader)){ +continue; +} else { +return res; +} +} else { +return cljs.tools.reader.read_symbol(reader,ch); +} + +} +} +} +} +} +break; +} +})); +} else { +if(!(goog.array.isEmpty(pending_forms))){ +var form = (pending_forms[(0)]); +goog.array.removeAt(pending_forms,(0)); + +return form; +} else { +var ch = reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(cljs.tools.reader.impl.utils.whitespace_QMARK_(ch)){ +continue; +} else { +if((ch == null)){ +if(eof_error_QMARK_){ +return cljs.tools.reader.impl.errors.throw_eof_error(reader,null); +} else { +return sentinel; +} +} else { +if((ch === return_on)){ +return cljs.tools.reader.READ_FINISHED; +} else { +if(cljs.tools.reader.impl.commons.number_literal_QMARK_(reader,ch)){ +return cljs.tools.reader.read_number(reader,ch); +} else { +var f = cljs.tools.reader.macros(ch); +if(!((f == null))){ +var res = (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(reader,ch,opts,pending_forms) : f.call(null,reader,ch,opts,pending_forms)); +if((res === reader)){ +continue; +} else { +return res; +} +} else { +return cljs.tools.reader.read_symbol(reader,ch); +} + +} +} +} +} +} +} +break; +} +}); +cljs.tools.reader.read_STAR_ = (function cljs$tools$reader$read_STAR_(var_args){ +var G__2109 = arguments.length; +switch (G__2109) { +case 5: +return cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +case 6: +return cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$5 = (function (reader,eof_error_QMARK_,sentinel,opts,pending_forms){ +return cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(reader,eof_error_QMARK_,sentinel,null,opts,pending_forms); +}); + +cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6 = (function (reader,eof_error_QMARK_,sentinel,return_on,opts,pending_forms){ +try{return cljs.tools.reader.read_STAR__internal(reader,eof_error_QMARK_,sentinel,return_on,opts,pending_forms); +}catch (e2110){if((e2110 instanceof Error)){ +var e = e2110; +if(cljs.tools.reader.impl.utils.ex_info_QMARK_(e)){ +var d = cljs.core.ex_data(e); +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.cst$kw$reader_DASH_exception,cljs.core.cst$kw$type.cljs$core$IFn$_invoke$arity$1(d))){ +throw e; +} else { +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3(e.message,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$reader_DASH_exception], null),d,(cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(reader))?new cljs.core.PersistentArrayMap(null, 3, [cljs.core.cst$kw$line,reader.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1(null),cljs.core.cst$kw$column,reader.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1(null),cljs.core.cst$kw$file,reader.cljs$tools$reader$reader_types$IndexingReader$get_file_name$arity$1(null)], null):null)], 0)),e); +} +} else { +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$3(e.message,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$type,cljs.core.cst$kw$reader_DASH_exception], null),(cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(reader))?new cljs.core.PersistentArrayMap(null, 3, [cljs.core.cst$kw$line,reader.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1(null),cljs.core.cst$kw$column,reader.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1(null),cljs.core.cst$kw$file,reader.cljs$tools$reader$reader_types$IndexingReader$get_file_name$arity$1(null)], null):null)], 0)),e); +} +} else { +throw e2110; + +} +}}); + +cljs.tools.reader.read_STAR_.cljs$lang$maxFixedArity = 6; + +/** + * Reads the first object from an IPushbackReader. + * Returns the object read. If EOF, throws if eof-error? is true. + * Otherwise returns sentinel. If no stream is providen, *in* will be used. + * + * Opts is a persistent map with valid keys: + * :read-cond - :allow to process reader conditionals, or + * :preserve to keep all branches + * :features - persistent set of feature keywords for reader conditionals + * :eof - on eof, return value unless :eofthrow, then throw. + * if not specified, will throw + * + * To read data structures only, use clojure.tools.reader.edn/read + * + * Note that the function signature of clojure.tools.reader/read and + * clojure.tools.reader.edn/read is not the same for eof-handling + */ +cljs.tools.reader.read = (function cljs$tools$reader$read(var_args){ +var G__2113 = arguments.length; +switch (G__2113) { +case 1: +return cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$1 = (function (reader){ +return cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$3(reader,true,null); +}); + +cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$2 = (function (p__2114,reader){ +var map__2115 = p__2114; +var map__2115__$1 = ((((!((map__2115 == null)))?(((((map__2115.cljs$lang$protocol_mask$partition0$ & (64))) || ((cljs.core.PROTOCOL_SENTINEL === map__2115.cljs$core$ISeq$))))?true:false):false))?cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,map__2115):map__2115); +var opts = map__2115__$1; +var eof = cljs.core.get.cljs$core$IFn$_invoke$arity$3(map__2115__$1,cljs.core.cst$kw$eof,cljs.core.cst$kw$eofthrow); +return cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(reader,cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(eof,cljs.core.cst$kw$eofthrow),eof,null,opts,cljs.core.to_array(cljs.core.PersistentVector.EMPTY)); +}); + +cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$3 = (function (reader,eof_error_QMARK_,sentinel){ +return cljs.tools.reader.read_STAR_.cljs$core$IFn$_invoke$arity$6(reader,eof_error_QMARK_,sentinel,null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.to_array(cljs.core.PersistentVector.EMPTY)); +}); + +cljs.tools.reader.read.cljs$lang$maxFixedArity = 3; + +/** + * Reads one object from the string s. + * Returns nil when s is nil or empty. + * + * To read data structures only, use clojure.tools.reader.edn/read-string + * + * Note that the function signature of clojure.tools.reader/read-string and + * clojure.tools.reader.edn/read-string is not the same for eof-handling + */ +cljs.tools.reader.read_string = (function cljs$tools$reader$read_string(var_args){ +var G__2119 = arguments.length; +switch (G__2119) { +case 1: +return cljs.tools.reader.read_string.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.tools.reader.read_string.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.read_string.cljs$core$IFn$_invoke$arity$1 = (function (s){ +return cljs.tools.reader.read_string.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,s); +}); + +cljs.tools.reader.read_string.cljs$core$IFn$_invoke$arity$2 = (function (opts,s){ +if(cljs.core.truth_((function (){var and__3925__auto__ = s; +if(cljs.core.truth_(and__3925__auto__)){ +return !((s === "")); +} else { +return and__3925__auto__; +} +})())){ +return cljs.tools.reader.read.cljs$core$IFn$_invoke$arity$2(opts,cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$1(s)); +} else { +return null; +} +}); + +cljs.tools.reader.read_string.cljs$lang$maxFixedArity = 2; + diff --git a/js/cljs/tools/reader/impl/commons.cljs b/js/cljs/tools/reader/impl/commons.cljs new file mode 100644 index 0000000..bb81955 --- /dev/null +++ b/js/cljs/tools/reader/impl/commons.cljs @@ -0,0 +1,131 @@ +;; Copyright (c) Nicola Mometto, Rich Hickey & contributors. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns cljs.tools.reader.impl.commons + (:refer-clojure :exclude [char]) + (:require + [cljs.tools.reader.impl.errors :refer [reader-error]] + [cljs.tools.reader.reader-types :refer [peek-char read-char]] + [cljs.tools.reader.impl.utils :refer [numeric? newline? char]])) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; helpers +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defn ^boolean number-literal? + "Checks whether the reader is at the start of a number literal" + [^not-native reader initch] + (or (numeric? initch) + (and (or (identical? \+ initch) (identical? \- initch)) + (numeric? (peek-char reader))))) + +(defn read-past + "Read until first character that doesn't match pred, returning + char." + [pred ^not-native rdr] + (loop [ch (read-char rdr)] + (if ^boolean (pred ch) + (recur (read-char rdr)) + ch))) + +(defn skip-line + "Advances the reader to the end of a line. Returns the reader" + [^not-native reader] + (loop [] + (when-not (newline? (read-char reader)) + (recur))) + reader) + +(def int-pattern #"^([-+]?)(?:(0)|([1-9][0-9]*)|0[xX]([0-9A-Fa-f]+)|0([0-7]+)|([1-9][0-9]?)[rR]([0-9A-Za-z]+)|0[0-9]+)(N)?$") +(def ratio-pattern #"([-+]?[0-9]+)/([0-9]+)") +(def float-pattern #"([-+]?[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)(M)?") + +(defn- match-int + [s] + (let [m (vec (re-find int-pattern s))] + (if-not (nil? (m 2)) + 0 + (let [^boolean negate? (identical? "-" (m 1)) + a (cond + (not (nil? (m 3))) [(m 3) 10] + (not (nil? (m 4))) [(m 4) 16] + (not (nil? (m 5))) [(m 5) 8] + (not (nil? (m 7))) [(m 7) (js/parseInt (m 6))] + :else [nil nil]) + n (a 0)] + (when-not (nil? n) + (let [bn (js/parseInt n (a 1)) + bn (if negate? (* -1 bn) bn)] + (when-not (js/isNaN bn) + bn))))))) + +(defn- match-ratio + [s] + (let [m (vec (re-find ratio-pattern s)) + numerator (m 1) + denominator (m 2) + numerator (if (re-find #"^\+" numerator) + (subs numerator 1) + numerator)] + (/ (-> numerator js/parseInt) ;;; No ratio type in cljs + (-> denominator js/parseInt)))); So will convert to js/Number + +(defn- match-float + [s] + (let [m (vec (re-find float-pattern s))] + (if-not (nil? (m 4)) ;; for BigDecimal "10.03M", as all parsed to js/Number + (js/parseFloat (m 1)) + (js/parseFloat s)))) + +(defn ^boolean matches? [pattern s] + (let [[match] (re-find pattern s)] + (identical? match s))) + +(defn match-number [s] + (if (matches? int-pattern s) + (match-int s) + (if (matches? float-pattern s) + (match-float s) + (when (matches? ratio-pattern s) + (match-ratio s))))) + +(defn parse-symbol + "Parses a string into a vector of the namespace and symbol" + [token] + (when-not (or (identical? "" token) + (true? (.test #":$" token)) + (true? (.test #"^::" token))) + (let [ns-idx (.indexOf token "/") + ns (when (pos? ns-idx) + (subs token 0 ns-idx))] + (if-not (nil? ns) + (let [ns-idx (inc ns-idx)] + (when-not (== ns-idx (count token)) + (let [sym (subs token ns-idx)] + (when (and (not (numeric? (nth sym 0))) + (not (identical? "" sym)) + (false? (.test #":$" ns)) + (or (identical? sym "/") + (== -1 (.indexOf sym "/")))) + [ns sym])))) + (when (or (identical? token "/") + (== -1 (.indexOf token "/"))) + [nil token]))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; readers +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defn read-comment + [rdr & _] + (skip-line rdr)) + +(defn throwing-reader + [msg] + (fn [rdr & _] + (reader-error rdr msg))) diff --git a/js/cljs/tools/reader/impl/commons.cljs.cache.json b/js/cljs/tools/reader/impl/commons.cljs.cache.json new file mode 100644 index 0000000..4cb9cd4 --- /dev/null +++ b/js/cljs/tools/reader/impl/commons.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$parseInt",["^ "],"~$isNaN",["^ "],"~$parseFloat",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",["~$char"]],"~:name","~$cljs.tools.reader.impl.commons","~:imports",null,"~:requires",["^ ","~$cljs.tools.reader.impl.errors","^>","~$cljs.tools.reader.reader-types","^?","~$cljs.tools.reader.impl.utils","^@"],"~:cljs.spec/speced-vars",[],"~:uses",["^ ","^9","^@","~$numeric?","^@","~$reader-error","^>","~$peek-char","^?","~$read-char","^?","~$newline?","^@"],"~:defs",["^ ","~$match-number",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:file","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","~:line",89,"~:column",7,"~:end-line",89,"~:end-column",19,"~:arglists",["~#list",["~$quote",["^R",[["~$s"]]]]]],"^:","~$cljs.tools.reader.impl.commons/match-number","~:variadic",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",19,"~:method-params",["^R",[["~$s"]]],"~:protocol-impl",null,"~:arglists-meta",["^R",[null,null]],"^N",1,"^M",89,"^O",89,"~:max-fixed-arity",1,"~:fn-var",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"~$skip-line",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",36,"^N",7,"^O",36,"^P",16,"^Q",["^R",["^S",["^R",[["~$reader"]]]]],"~:doc","Advances the reader to the end of a line. Returns the reader"],"^:","~$cljs.tools.reader.impl.commons/skip-line","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",16,"^V",["^R",[["^10"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",36,"^O",36,"^Y",1,"^Z",true,"^Q",["^R",["^S",["^R",[["^10"]]]]],"^11","Advances the reader to the end of a line. Returns the reader"],"~$int-pattern",["^ ","^:","~$cljs.tools.reader.impl.commons/int-pattern","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",44,"^N",1,"^O",44,"^P",17,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",44,"^N",6,"^O",44,"^P",17],"~:tag","~$any"],"~$read-comment",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",124,"^N",7,"^O",124,"^P",19,"^Q",["^R",["^S",["^R",[["~$rdr","~$&","~$_"]]]]],"~:top-fn",["^ ","^U",true,"^Y",1,"^V",[["^R",["^18","~$_"]]],"^Q",["^R",[["^18","~$&","~$_"]]],"^X",["^R",[null]]]],"^:","~$cljs.tools.reader.impl.commons/read-comment","^U",true,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",19,"^19",["^ ","^U",true,"^Y",1,"^V",[["^R",["^18","~$_"]]],"^Q",["^R",[["^18","~$&","~$_"]]],"^X",["^R",[null]]],"^V",[["^R",["^18","~$_"]]],"^W",null,"^X",["^R",[null]],"^N",1,"^M",124,"^O",124,"^Y",1,"^Z",true,"^Q",["^R",[["^18","~$&","~$_"]]]],"~$match-ratio",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",67,"^N",8,"^O",67,"^P",19,"~:private",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"^1<",true,"^:","~$cljs.tools.reader.impl.commons/match-ratio","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",19,"^V",["^R",[["~$s"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",67,"^O",67,"^Y",1,"^Z",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"~$match-int",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",48,"^N",8,"^O",48,"^P",17,"^1<",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"^1<",true,"^:","~$cljs.tools.reader.impl.commons/match-int","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",17,"^V",["^R",[["~$s"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",48,"^O",48,"^Y",1,"^Z",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"~$parse-symbol",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",97,"^N",7,"^O",97,"^P",19,"^Q",["^R",["^S",["^R",[["~$token"]]]]],"^11","Parses a string into a vector of the namespace and symbol"],"^:","~$cljs.tools.reader.impl.commons/parse-symbol","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",19,"^V",["^R",[["^1A"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",97,"^O",97,"^Y",1,"^Z",true,"^Q",["^R",["^S",["^R",[["^1A"]]]]],"^11","Parses a string into a vector of the namespace and symbol"],"~$number-literal?",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",20,"^N",16,"^O",20,"^P",31,"^15","~$boolean","^Q",["^R",["^S",["^R",[["^10","~$initch"]]]]],"^11","Checks whether the reader is at the start of a number literal"],"^:","~$cljs.tools.reader.impl.commons/number-literal?","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",31,"^V",["^R",[["^10","^1E"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",20,"~:ret-tag","^1D","^O",20,"^Y",2,"^15","^1D","^Z",true,"^Q",["^R",["^S",["^R",[["^10","^1E"]]]]],"^11","Checks whether the reader is at the start of a number literal"],"~$read-past",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",27,"^N",7,"^O",27,"^P",16,"^Q",["^R",["^S",["^R",[["~$pred","^18"]]]]],"^11","Read until first character that doesn't match pred, returning\n char."],"^:","~$cljs.tools.reader.impl.commons/read-past","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",16,"^V",["^R",[["^1I","^18"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",27,"^O",27,"^Y",2,"^Z",true,"^Q",["^R",["^S",["^R",[["^1I","^18"]]]]],"^11","Read until first character that doesn't match pred, returning\n char."],"~$float-pattern",["^ ","^:","~$cljs.tools.reader.impl.commons/float-pattern","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",46,"^N",1,"^O",46,"^P",19,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",46,"^N",6,"^O",46,"^P",19],"^15","^16"],"~$matches?",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",85,"^N",16,"^O",85,"^P",24,"^15","^1D","^Q",["^R",["^S",["^R",[["~$pattern","~$s"]]]]]],"^:","~$cljs.tools.reader.impl.commons/matches?","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",24,"^V",["^R",[["^1N","~$s"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",85,"^1G","^1D","^O",85,"^Y",2,"^15","^1D","^Z",true,"^Q",["^R",["^S",["^R",[["^1N","~$s"]]]]]],"~$throwing-reader",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",128,"^N",7,"^O",128,"^P",22,"^Q",["^R",["^S",["^R",[["~$msg"]]]]]],"^:","~$cljs.tools.reader.impl.commons/throwing-reader","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",22,"^V",["^R",[["^1Q"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",128,"^O",128,"^Y",1,"^Z",true,"^Q",["^R",["^S",["^R",[["^1Q"]]]]]],"~$match-float",["^ ","^J",null,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",78,"^N",8,"^O",78,"^P",19,"^1<",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"^1<",true,"^:","~$cljs.tools.reader.impl.commons/match-float","^U",false,"^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^P",19,"^V",["^R",[["~$s"]]],"^W",null,"^X",["^R",[null,null]],"^N",1,"^M",78,"^O",78,"^Y",1,"^Z",true,"^Q",["^R",["^S",["^R",[["~$s"]]]]]],"~$ratio-pattern",["^ ","^:","~$cljs.tools.reader.impl.commons/ratio-pattern","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",45,"^N",1,"^O",45,"^P",19,"^K",["^ ","^L","/home/julien/.cljs/.aot_cache/1.10.329/A34FA64/cljs/tools/reader/impl/commons.cljs","^M",45,"^N",6,"^O",45,"^P",19],"^15","^16"]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^8",["~:else"]],"~:order",["^1["]],"^11",null] \ No newline at end of file diff --git a/js/cljs/tools/reader/impl/commons.js b/js/cljs/tools/reader/impl/commons.js new file mode 100644 index 0000000..9c13fd2 --- /dev/null +++ b/js/cljs/tools/reader/impl/commons.js @@ -0,0 +1,192 @@ +// Compiled by ClojureScript 1.10.329 {:static-fns true, :optimize-constants true, :target :nodejs} +goog.provide('cljs.tools.reader.impl.commons'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +goog.require('cljs.tools.reader.impl.errors'); +goog.require('cljs.tools.reader.reader_types'); +goog.require('cljs.tools.reader.impl.utils'); +/** + * Checks whether the reader is at the start of a number literal + */ +cljs.tools.reader.impl.commons.number_literal_QMARK_ = (function cljs$tools$reader$impl$commons$number_literal_QMARK_(reader,initch){ +return ((cljs.tools.reader.impl.utils.numeric_QMARK_(initch)) || (((((("+" === initch)) || (("-" === initch)))) && (cljs.tools.reader.impl.utils.numeric_QMARK_(reader.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null)))))); +}); +/** + * Read until first character that doesn't match pred, returning + * char. + */ +cljs.tools.reader.impl.commons.read_past = (function cljs$tools$reader$impl$commons$read_past(pred,rdr){ +var ch = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +while(true){ +if((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(ch) : pred.call(null,ch))){ +var G__1923 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +ch = G__1923; +continue; +} else { +return ch; +} +break; +} +}); +/** + * Advances the reader to the end of a line. Returns the reader + */ +cljs.tools.reader.impl.commons.skip_line = (function cljs$tools$reader$impl$commons$skip_line(reader){ +while(true){ +if(cljs.tools.reader.impl.utils.newline_QMARK_(reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null))){ +} else { +continue; +} +break; +} + +return reader; +}); +cljs.tools.reader.impl.commons.int_pattern = /^([-+]?)(?:(0)|([1-9][0-9]*)|0[xX]([0-9A-Fa-f]+)|0([0-7]+)|([1-9][0-9]?)[rR]([0-9A-Za-z]+)|0[0-9]+)(N)?$/; +cljs.tools.reader.impl.commons.ratio_pattern = /([-+]?[0-9]+)\/([0-9]+)/; +cljs.tools.reader.impl.commons.float_pattern = /([-+]?[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+)?)(M)?/; +cljs.tools.reader.impl.commons.match_int = (function cljs$tools$reader$impl$commons$match_int(s){ +var m = cljs.core.vec(cljs.core.re_find(cljs.tools.reader.impl.commons.int_pattern,s)); +if(!(((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((2)) : m.call(null,(2))) == null))){ +return (0); +} else { +var negate_QMARK_ = ("-" === (m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((1)) : m.call(null,(1)))); +var a = ((!(((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((3)) : m.call(null,(3))) == null)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((3)) : m.call(null,(3))),(10)], null):((!(((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((4)) : m.call(null,(4))) == null)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((4)) : m.call(null,(4))),(16)], null):((!(((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((5)) : m.call(null,(5))) == null)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((5)) : m.call(null,(5))),(8)], null):((!(((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((7)) : m.call(null,(7))) == null)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((7)) : m.call(null,(7))),parseInt((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((6)) : m.call(null,(6))))], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null], null) +)))); +var n = (a.cljs$core$IFn$_invoke$arity$1 ? a.cljs$core$IFn$_invoke$arity$1((0)) : a.call(null,(0))); +if((n == null)){ +return null; +} else { +var bn = parseInt(n,(a.cljs$core$IFn$_invoke$arity$1 ? a.cljs$core$IFn$_invoke$arity$1((1)) : a.call(null,(1)))); +var bn__$1 = ((negate_QMARK_)?((-1) * bn):bn); +if(cljs.core.truth_(isNaN(bn__$1))){ +return null; +} else { +return bn__$1; +} +} +} +}); +cljs.tools.reader.impl.commons.match_ratio = (function cljs$tools$reader$impl$commons$match_ratio(s){ +var m = cljs.core.vec(cljs.core.re_find(cljs.tools.reader.impl.commons.ratio_pattern,s)); +var numerator = (m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((1)) : m.call(null,(1))); +var denominator = (m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((2)) : m.call(null,(2))); +var numerator__$1 = (cljs.core.truth_(cljs.core.re_find(/^\+/,numerator))?cljs.core.subs.cljs$core$IFn$_invoke$arity$2(numerator,(1)):numerator); +return (parseInt(numerator__$1) / parseInt(denominator)); +}); +cljs.tools.reader.impl.commons.match_float = (function cljs$tools$reader$impl$commons$match_float(s){ +var m = cljs.core.vec(cljs.core.re_find(cljs.tools.reader.impl.commons.float_pattern,s)); +if(!(((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((4)) : m.call(null,(4))) == null))){ +return parseFloat((m.cljs$core$IFn$_invoke$arity$1 ? m.cljs$core$IFn$_invoke$arity$1((1)) : m.call(null,(1)))); +} else { +return parseFloat(s); +} +}); +cljs.tools.reader.impl.commons.matches_QMARK_ = (function cljs$tools$reader$impl$commons$matches_QMARK_(pattern,s){ +var vec__1924 = cljs.core.re_find(pattern,s); +var match = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1924,(0),null); +return (match === s); +}); +cljs.tools.reader.impl.commons.match_number = (function cljs$tools$reader$impl$commons$match_number(s){ +if(cljs.tools.reader.impl.commons.matches_QMARK_(cljs.tools.reader.impl.commons.int_pattern,s)){ +return cljs.tools.reader.impl.commons.match_int(s); +} else { +if(cljs.tools.reader.impl.commons.matches_QMARK_(cljs.tools.reader.impl.commons.float_pattern,s)){ +return cljs.tools.reader.impl.commons.match_float(s); +} else { +if(cljs.tools.reader.impl.commons.matches_QMARK_(cljs.tools.reader.impl.commons.ratio_pattern,s)){ +return cljs.tools.reader.impl.commons.match_ratio(s); +} else { +return null; +} +} +} +}); +/** + * Parses a string into a vector of the namespace and symbol + */ +cljs.tools.reader.impl.commons.parse_symbol = (function cljs$tools$reader$impl$commons$parse_symbol(token){ +if(((("" === token)) || (/:$/.test(token) === true) || (/^::/.test(token) === true))){ +return null; +} else { +var ns_idx = token.indexOf("/"); +var ns = (((ns_idx > (0)))?cljs.core.subs.cljs$core$IFn$_invoke$arity$3(token,(0),ns_idx):null); +if(!((ns == null))){ +var ns_idx__$1 = (ns_idx + (1)); +if((ns_idx__$1 === cljs.core.count(token))){ +return null; +} else { +var sym = cljs.core.subs.cljs$core$IFn$_invoke$arity$2(token,ns_idx__$1); +if(((!(cljs.tools.reader.impl.utils.numeric_QMARK_(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(sym,(0))))) && (!(("" === sym))) && (/:$/.test(ns) === false) && ((((sym === "/")) || (((-1) === sym.indexOf("/"))))))){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns,sym], null); +} else { +return null; +} +} +} else { +if((((token === "/")) || (((-1) === token.indexOf("/"))))){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,token], null); +} else { +return null; +} +} +} +}); +cljs.tools.reader.impl.commons.read_comment = (function cljs$tools$reader$impl$commons$read_comment(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1929 = arguments.length; +var i__4519__auto___1930 = (0); +while(true){ +if((i__4519__auto___1930 < len__4518__auto___1929)){ +args__4521__auto__.push((arguments[i__4519__auto___1930])); + +var G__1931 = (i__4519__auto___1930 + (1)); +i__4519__auto___1930 = G__1931; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.tools.reader.impl.commons.read_comment.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.tools.reader.impl.commons.read_comment.cljs$core$IFn$_invoke$arity$variadic = (function (rdr,_){ +return cljs.tools.reader.impl.commons.skip_line(rdr); +}); + +cljs.tools.reader.impl.commons.read_comment.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.tools.reader.impl.commons.read_comment.cljs$lang$applyTo = (function (seq1927){ +var G__1928 = cljs.core.first(seq1927); +var seq1927__$1 = cljs.core.next(seq1927); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1928,seq1927__$1); +}); + +cljs.tools.reader.impl.commons.throwing_reader = (function cljs$tools$reader$impl$commons$throwing_reader(msg){ +return (function() { +var G__1932__delegate = function (rdr,_){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([msg], 0)); +}; +var G__1932 = function (rdr,var_args){ +var _ = null; +if (arguments.length > 1) { +var G__1933__i = 0, G__1933__a = new Array(arguments.length - 1); +while (G__1933__i < G__1933__a.length) {G__1933__a[G__1933__i] = arguments[G__1933__i + 1]; ++G__1933__i;} + _ = new cljs.core.IndexedSeq(G__1933__a,0,null); +} +return G__1932__delegate.call(this,rdr,_);}; +G__1932.cljs$lang$maxFixedArity = 1; +G__1932.cljs$lang$applyTo = (function (arglist__1934){ +var rdr = cljs.core.first(arglist__1934); +var _ = cljs.core.rest(arglist__1934); +return G__1932__delegate(rdr,_); +}); +G__1932.cljs$core$IFn$_invoke$arity$variadic = G__1932__delegate; +return G__1932; +})() +; +}); diff --git a/js/cljs/tools/reader/impl/errors.cljs b/js/cljs/tools/reader/impl/errors.cljs new file mode 100644 index 0000000..104e662 --- /dev/null +++ b/js/cljs/tools/reader/impl/errors.cljs @@ -0,0 +1,253 @@ +;; Copyright (c) Russ Olsen, Nicola Mometto, Rich Hickey & contributors. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns cljs.tools.reader.impl.errors + (:require [cljs.tools.reader.reader-types :as types] + [clojure.string :as s] + [cljs.tools.reader.impl.inspect :as i])) + +(defn- ex-details + [rdr ex-type] + (let [details {:type :reader-exception + :ex-kind ex-type}] + (if (types/indexing-reader? rdr) + (assoc + details + :file (types/get-file-name rdr) + :line (types/get-line-number rdr) + :col (types/get-column-number rdr)) + details))) + +(defn- throw-ex + "Throw an ex-info error." + [rdr ex-type & msg] + (let [details (ex-details rdr ex-type) + file (:file details) + line (:line details) + col (:col details) + msg1 (if file (str file " ")) + msg2 (if line (str "[line " line ", col " col "]")) + msg3 (if (or msg1 msg2) " ") + full-msg (apply str msg1 msg2 msg3 msg)] + (throw (ex-info full-msg details)))) + +(defn reader-error + "Throws an ExceptionInfo with the given message. + If rdr is an IndexingReader, additional information about column and line number is provided" + [rdr & msgs] + (throw-ex rdr :reader-error (apply str msgs))) + +(defn illegal-arg-error + "Throws an ExceptionInfo with the given message. + If rdr is an IndexingReader, additional information about column and line number is provided" + [rdr & msgs] + (throw-ex rdr :illegal-argument (apply str msgs))) + +(defn eof-error + "Throws an ExceptionInfo with the given message. + If rdr is an IndexingReader, additional information about column and line number is provided" + [rdr & msgs] + (throw-ex rdr :eof (apply str msgs))) + +(defn throw-eof-delimited + ([rdr kind column line] (throw-eof-delimited rdr kind line column nil)) + ([rdr kind line column n] + (eof-error + rdr + "Unexpected EOF while reading " + (if n + (str "item " n " of ")) + (name kind) + (if line + (str ", starting at line " line " and column " column)) + "."))) + +(defn throw-odd-map [rdr line col elements] + (reader-error + rdr + "The map literal starting with " + (i/inspect (first elements)) + (if line (str " on line " line " column " col)) + " contains " + (count elements) + " form(s). Map literals must contain an even number of forms.")) + +(defn throw-invalid-number [rdr token] + (reader-error + rdr + "Invalid number: " + token + ".")) + +(defn throw-invalid-unicode-literal [rdr token] + (throw + (illegal-arg-error + rdr + "Invalid unicode literal: \\" + token + "."))) + +(defn throw-invalid-unicode-escape [rdr ch] + (reader-error + rdr + "Invalid unicode escape: \\u" + ch + ".")) + +(defn throw-invalid [rdr kind token] + (reader-error rdr "Invalid " (name kind) ": " token ".")) + +(defn throw-eof-at-start [rdr kind] + (eof-error rdr "Unexpected EOF while reading start of " (name kind) ".")) + +(defn throw-bad-char [rdr kind ch] + (reader-error rdr "Invalid character: " ch " found while reading " (name kind) ".")) + +(defn throw-eof-at-dispatch [rdr] + (eof-error rdr "Unexpected EOF while reading dispatch character.")) + +(defn throw-bad-dispatch [rdr ch] + (reader-error rdr "No dispatch macro for " ch ".")) + +(defn throw-unmatch-delimiter [rdr ch] + (reader-error rdr "Unmatched delimiter " ch ".")) + +(defn throw-eof-reading [rdr kind & start] + (let [init (case kind :regex "#\"" :string \")] + (eof-error rdr "Unexpected EOF reading " (name kind) " starting " (apply str init start) "."))) + +(defn throw-no-dispatch [rdr ch] + (throw-bad-dispatch rdr ch)) + +(defn throw-invalid-unicode-char[rdr token] + (reader-error + rdr + "Invalid unicode character \\" + token + ".")) + +(defn throw-invalid-unicode-digit-in-token[rdr ch token] + (illegal-arg-error + rdr + "Invalid digit " + ch + " in unicode character \\" + token + ".")) + +(defn throw-invalid-unicode-digit[rdr ch] + (illegal-arg-error + rdr + "Invalid digit " + ch + " in unicode character.")) + +(defn throw-invalid-unicode-len[rdr actual expected] + (illegal-arg-error + rdr + "Invalid unicode literal. Unicode literals should be " + expected + "characters long. " + "value suppled is " + actual + "characters long.")) + +(defn throw-invalid-character-literal[rdr token] + (reader-error rdr "Invalid character literal \\u" token ".")) + +(defn throw-invalid-octal-len[rdr token] + (reader-error + rdr + "Invalid octal escape sequence in a character literal:" + token + ". Octal escape sequences must be 3 or fewer digits.")) + +(defn throw-bad-octal-number [rdr] + (reader-error rdr "Octal escape sequence must be in range [0, 377].")) + +(defn throw-unsupported-character[rdr token] + (reader-error + rdr + "Unsupported character: " + token + ".")) + +(defn throw-eof-in-character [rdr] + (eof-error + rdr + "Unexpected EOF while reading character.")) + +(defn throw-bad-escape-char [rdr ch] + (reader-error rdr "Unsupported escape character: \\" ch ".")) + +(defn throw-single-colon [rdr] + (reader-error rdr "A single colon is not a valid keyword.")) + +(defn throw-bad-metadata [rdr x] + (reader-error + rdr + "Metadata cannot be " + (i/inspect x) + ". Metadata must be a Symbol, Keyword, String or Map.")) + +(defn throw-bad-metadata-target [rdr target] + (reader-error + rdr + "Metadata can not be applied to " + (i/inspect target) + ". " + "Metadata can only be applied to IMetas.")) + +(defn throw-feature-not-keyword [rdr feature] + (reader-error + rdr + "Feature cannot be " + (i/inspect feature) + " Features must be keywords.")) + +(defn throw-ns-map-no-map [rdr ns-name] + (reader-error rdr "Namespaced map with namespace " ns-name " does not specify a map.")) + +(defn throw-bad-ns [rdr ns-name] + (reader-error rdr "Invalid value used as namespace in namespaced map: " ns-name ".")) + +(defn throw-bad-reader-tag [rdr tag] + (reader-error + rdr + "Invalid reader tag: " + (i/inspect tag) + ". Reader tags must be symbols.")) + +(defn throw-unknown-reader-tag [rdr tag] + (reader-error + rdr + "No reader function for tag " + (i/inspect tag) + ".")) + +(defn- duplicate-keys-error [msg coll] + (letfn [(duplicates [seq] + (for [[id freq] (frequencies seq) + :when (> freq 1)] + id))] + (let [dups (duplicates coll)] + (apply str msg + (when (> (count dups) 1) "s") + ": " (interpose ", " dups))))) + +(defn throw-dup-keys [rdr kind ks] + (reader-error + rdr + (duplicate-keys-error + (str (s/capitalize (name kind)) " literal contains duplicate key") + ks))) + +(defn throw-eof-error [rdr line] + (if line + (eof-error rdr "EOF while reading, starting at line " line ".") + (eof-error rdr "EOF while reading."))) diff --git a/js/cljs/tools/reader/impl/errors.cljs.cache.json b/js/cljs/tools/reader/impl/errors.cljs.cache.json new file mode 100644 index 0000000..9f715b1 --- /dev/null +++ b/js/cljs/tools/reader/impl/errors.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$Error",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",[]],"~:name","~$cljs.tools.reader.impl.errors","~:imports",null,"~:requires",["^ ","~$types","~$cljs.tools.reader.reader-types","^<","^<","~$s","~$clojure.string","^=","^=","~$i","~$cljs.tools.reader.impl.inspect","^>","^>"],"~:cljs.spec/speced-vars",[],"~:uses",null,"~:defs",["^ ","~$throw-bad-dispatch",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:file","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","~:line",114,"~:column",7,"~:end-line",114,"~:end-column",25,"~:arglists",["~#list",["~$quote",["^K",[["~$rdr","~$ch"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-dispatch","~:variadic",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",25,"~:method-params",["^K",[["^M","^N"]]],"~:protocol-impl",null,"~:arglists-meta",["^K",[null,null]],"^G",1,"^F",114,"^H",114,"~:max-fixed-arity",2,"~:fn-var",true,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"~$throw-invalid-unicode-escape",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",95,"^G",7,"^H",95,"^I",35,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-unicode-escape","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",35,"^Q",["^K",[["^M","^N"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",95,"^H",95,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"~$throw-dup-keys",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",243,"^G",7,"^H",243,"^I",21,"^J",["^K",["^L",["^K",[["^M","~$kind","~$ks"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-dup-keys","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",21,"^Q",["^K",[["^M","^Y","^Z"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",243,"^H",243,"^T",3,"^U",true,"^J",["^K",["^L",["^K",[["^M","^Y","^Z"]]]]]],"~$throw-bad-ns",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",216,"^G",7,"^H",216,"^I",19,"^J",["^K",["^L",["^K",[["^M","~$ns-name"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-ns","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",19,"^Q",["^K",[["^M","^11"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",216,"^H",216,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^11"]]]]]],"~$duplicate-keys-error",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",233,"^G",8,"^H",233,"^I",28,"~:private",true,"^J",["^K",["^L",["^K",[["~$msg","~$coll"]]]]]],"^14",true,"^7","~$cljs.tools.reader.impl.errors/duplicate-keys-error","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",28,"^Q",["^K",[["^15","^16"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",233,"^H",233,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^15","^16"]]]]]],"~$throw-unknown-reader-tag",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",226,"^G",7,"^H",226,"^I",31,"^J",["^K",["^L",["^K",[["^M","~$tag"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-unknown-reader-tag","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",31,"^Q",["^K",[["^M","^19"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",226,"^H",226,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^19"]]]]]],"~$throw-eof-at-dispatch",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",111,"^G",7,"^H",111,"^I",28,"^J",["^K",["^L",["^K",[["^M"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-eof-at-dispatch","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",28,"^Q",["^K",[["^M"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",111,"^H",111,"^T",1,"^U",true,"^J",["^K",["^L",["^K",[["^M"]]]]]],"~$throw-bad-metadata-target",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",198,"^G",7,"^H",198,"^I",32,"^J",["^K",["^L",["^K",[["^M","~$target"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-metadata-target","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",32,"^Q",["^K",[["^M","^1>"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",198,"^H",198,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1>"]]]]]],"~$throw-invalid-number",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",80,"^G",7,"^H",80,"^I",27,"^J",["^K",["^L",["^K",[["^M","~$token"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-number","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",27,"^Q",["^K",[["^M","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",80,"^H",80,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"~$reader-error",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",39,"^G",7,"^H",39,"^I",19,"^J",["^K",["^L",["^K",[["^M","~$&","~$msgs"]]]]],"~:doc","Throws an ExceptionInfo with the given message.\n If rdr is an IndexingReader, additional information about column and line number is provided","~:top-fn",["^ ","^P",true,"^T",1,"^Q",[["^K",["^M","^1D"]]],"^J",["^K",[["^M","~$&","^1D"]]],"^S",["^K",[null]]]],"^7","~$cljs.tools.reader.impl.errors/reader-error","^P",true,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",19,"^1F",["^ ","^P",true,"^T",1,"^Q",[["^K",["^M","^1D"]]],"^J",["^K",[["^M","~$&","^1D"]]],"^S",["^K",[null]]],"^Q",[["^K",["^M","^1D"]]],"^R",null,"^S",["^K",[null]],"^G",1,"^F",39,"^H",39,"^T",1,"^U",true,"^J",["^K",[["^M","~$&","^1D"]]],"^1E","Throws an ExceptionInfo with the given message.\n If rdr is an IndexingReader, additional information about column and line number is provided"],"~$throw-invalid-unicode-literal",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",87,"^G",7,"^H",87,"^I",36,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-unicode-literal","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",36,"^Q",["^K",[["^M","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",87,"^H",87,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"~$throw-ns-map-no-map",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",213,"^G",7,"^H",213,"^I",26,"^J",["^K",["^L",["^K",[["^M","^11"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-ns-map-no-map","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",26,"^Q",["^K",[["^M","^11"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",213,"^H",213,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^11"]]]]]],"~$throw-unsupported-character",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",173,"^G",7,"^H",173,"^I",34,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-unsupported-character","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",34,"^Q",["^K",[["^M","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",173,"^H",173,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"~$throw-feature-not-keyword",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",206,"^G",7,"^H",206,"^I",32,"^J",["^K",["^L",["^K",[["^M","~$feature"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-feature-not-keyword","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",32,"^Q",["^K",[["^M","^1O"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",206,"^H",206,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1O"]]]]]],"~$throw-eof-delimited",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",57,"^G",7,"^H",57,"^I",26,"^J",["^K",["^L",["^K",[["^M","^Y","~$column","~$line"],["^M","^Y","^1S","^1R","~$n"]]]]],"^1F",["^ ","^P",false,"^T",5,"^Q",["^K",[["^M","^Y","^1R","^1S"],["^M","^Y","^1S","^1R","~$n"]]],"^J",["^K",[["^M","^Y","^1R","^1S"],["^M","^Y","^1S","^1R","~$n"]]],"^S",["^K",[null,null]]]],"^7","~$cljs.tools.reader.impl.errors/throw-eof-delimited","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",26,"^1F",["^ ","^P",false,"^T",5,"^Q",["^K",[["^M","^Y","^1R","^1S"],["^M","^Y","^1S","^1R","~$n"]]],"^J",["^K",[["^M","^Y","^1R","^1S"],["^M","^Y","^1S","^1R","~$n"]]],"^S",["^K",[null,null]]],"^Q",["^K",[["^M","^Y","^1R","^1S"],["^M","^Y","^1S","^1R","~$n"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",57,"^H",57,"^T",5,"^U",true,"^J",["^K",[["^M","^Y","^1R","^1S"],["^M","^Y","^1S","^1R","~$n"]]]],"~$throw-eof-in-character",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",180,"^G",7,"^H",180,"^I",29,"^J",["^K",["^L",["^K",[["^M"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-eof-in-character","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",29,"^Q",["^K",[["^M"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",180,"^H",180,"^T",1,"^U",true,"^J",["^K",["^L",["^K",[["^M"]]]]]],"~$throw-bad-char",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",108,"^G",7,"^H",108,"^I",21,"^J",["^K",["^L",["^K",[["^M","^Y","^N"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-char","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",21,"^Q",["^K",[["^M","^Y","^N"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",108,"^H",108,"^T",3,"^U",true,"^J",["^K",["^L",["^K",[["^M","^Y","^N"]]]]]],"~$eof-error",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",51,"^G",7,"^H",51,"^I",16,"^J",["^K",["^L",["^K",[["^M","~$&","^1D"]]]]],"^1E","Throws an ExceptionInfo with the given message.\n If rdr is an IndexingReader, additional information about column and line number is provided","^1F",["^ ","^P",true,"^T",1,"^Q",[["^K",["^M","^1D"]]],"^J",["^K",[["^M","~$&","^1D"]]],"^S",["^K",[null]]]],"^7","~$cljs.tools.reader.impl.errors/eof-error","^P",true,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",16,"^1F",["^ ","^P",true,"^T",1,"^Q",[["^K",["^M","^1D"]]],"^J",["^K",[["^M","~$&","^1D"]]],"^S",["^K",[null]]],"^Q",[["^K",["^M","^1D"]]],"^R",null,"^S",["^K",[null]],"^G",1,"^F",51,"^H",51,"^T",1,"^U",true,"^J",["^K",[["^M","~$&","^1D"]]],"^1E","Throws an ExceptionInfo with the given message.\n If rdr is an IndexingReader, additional information about column and line number is provided"],"~$throw-bad-metadata",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",191,"^G",7,"^H",191,"^I",25,"^J",["^K",["^L",["^K",[["^M","~$x"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-metadata","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",25,"^Q",["^K",[["^M","~$x"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",191,"^H",191,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","~$x"]]]]]],"~$throw-eof-reading",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",120,"^G",7,"^H",120,"^I",24,"^J",["^K",["^L",["^K",[["^M","^Y","~$&","~$start"]]]]],"^1F",["^ ","^P",true,"^T",2,"^Q",[["^K",["^M","^Y","^22"]]],"^J",["^K",[["^M","^Y","~$&","^22"]]],"^S",["^K",[null]]]],"^7","~$cljs.tools.reader.impl.errors/throw-eof-reading","^P",true,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",24,"^1F",["^ ","^P",true,"^T",2,"^Q",[["^K",["^M","^Y","^22"]]],"^J",["^K",[["^M","^Y","~$&","^22"]]],"^S",["^K",[null]]],"^Q",[["^K",["^M","^Y","^22"]]],"^R",null,"^S",["^K",[null]],"^G",1,"^F",120,"^H",120,"^T",2,"^U",true,"^J",["^K",[["^M","^Y","~$&","^22"]]]],"~$throw-eof-error",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",250,"^G",7,"^H",250,"^I",22,"^J",["^K",["^L",["^K",[["^M","^1S"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-eof-error","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",22,"^Q",["^K",[["^M","^1S"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",250,"^H",250,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1S"]]]]]],"~$illegal-arg-error",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",45,"^G",7,"^H",45,"^I",24,"^J",["^K",["^L",["^K",[["^M","~$&","^1D"]]]]],"^1E","Throws an ExceptionInfo with the given message.\n If rdr is an IndexingReader, additional information about column and line number is provided","^1F",["^ ","^P",true,"^T",1,"^Q",[["^K",["^M","^1D"]]],"^J",["^K",[["^M","~$&","^1D"]]],"^S",["^K",[null]]]],"^7","~$cljs.tools.reader.impl.errors/illegal-arg-error","^P",true,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",24,"^1F",["^ ","^P",true,"^T",1,"^Q",[["^K",["^M","^1D"]]],"^J",["^K",[["^M","~$&","^1D"]]],"^S",["^K",[null]]],"^Q",[["^K",["^M","^1D"]]],"^R",null,"^S",["^K",[null]],"^G",1,"^F",45,"^H",45,"^T",1,"^U",true,"^J",["^K",[["^M","~$&","^1D"]]],"^1E","Throws an ExceptionInfo with the given message.\n If rdr is an IndexingReader, additional information about column and line number is provided"],"~$throw-invalid-octal-len",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",163,"^G",7,"^H",163,"^I",30,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-octal-len","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",30,"^Q",["^K",[["^M","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",163,"^H",163,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"~$throw-invalid-unicode-digit",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",143,"^G",7,"^H",143,"^I",34,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-unicode-digit","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",34,"^Q",["^K",[["^M","^N"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",143,"^H",143,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"~$throw-invalid-unicode-digit-in-token",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",134,"^G",7,"^H",134,"^I",43,"^J",["^K",["^L",["^K",[["^M","^N","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-unicode-digit-in-token","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",43,"^Q",["^K",[["^M","^N","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",134,"^H",134,"^T",3,"^U",true,"^J",["^K",["^L",["^K",[["^M","^N","^1A"]]]]]],"~$throw-invalid-unicode-len",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",150,"^G",7,"^H",150,"^I",32,"^J",["^K",["^L",["^K",[["^M","~$actual","~$expected"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-unicode-len","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",32,"^Q",["^K",[["^M","^2?","^2@"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",150,"^H",150,"^T",3,"^U",true,"^J",["^K",["^L",["^K",[["^M","^2?","^2@"]]]]]],"~$throw-single-colon",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",188,"^G",7,"^H",188,"^I",25,"^J",["^K",["^L",["^K",[["^M"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-single-colon","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",25,"^Q",["^K",[["^M"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",188,"^H",188,"^T",1,"^U",true,"^J",["^K",["^L",["^K",[["^M"]]]]]],"~$throw-odd-map",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",70,"^G",7,"^H",70,"^I",20,"^J",["^K",["^L",["^K",[["^M","^1S","~$col","~$elements"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-odd-map","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",20,"^Q",["^K",[["^M","^1S","^2E","^2F"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",70,"^H",70,"^T",4,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1S","^2E","^2F"]]]]]],"~$throw-bad-octal-number",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",170,"^G",7,"^H",170,"^I",29,"^J",["^K",["^L",["^K",[["^M"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-octal-number","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",29,"^Q",["^K",[["^M"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",170,"^H",170,"^T",1,"^U",true,"^J",["^K",["^L",["^K",[["^M"]]]]]],"~$throw-bad-reader-tag",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",219,"^G",7,"^H",219,"^I",27,"^J",["^K",["^L",["^K",[["^M","^19"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-reader-tag","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",27,"^Q",["^K",[["^M","^19"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",219,"^H",219,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^19"]]]]]],"~$throw-unmatch-delimiter",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",117,"^G",7,"^H",117,"^I",30,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-unmatch-delimiter","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",30,"^Q",["^K",[["^M","^N"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",117,"^H",117,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"~$throw-invalid-character-literal",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",160,"^G",7,"^H",160,"^I",38,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-character-literal","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",38,"^Q",["^K",[["^M","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",160,"^H",160,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"~$throw-invalid-unicode-char",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",127,"^G",7,"^H",127,"^I",33,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid-unicode-char","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",33,"^Q",["^K",[["^M","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",127,"^H",127,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^1A"]]]]]],"~$throw-bad-escape-char",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",185,"^G",7,"^H",185,"^I",28,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-bad-escape-char","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",28,"^Q",["^K",[["^M","^N"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",185,"^H",185,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"~$throw-no-dispatch",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",124,"^G",7,"^H",124,"^I",24,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-no-dispatch","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",24,"^Q",["^K",[["^M","^N"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",124,"^H",124,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^N"]]]]]],"~$throw-eof-at-start",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",105,"^G",7,"^H",105,"^I",25,"^J",["^K",["^L",["^K",[["^M","^Y"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-eof-at-start","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",25,"^Q",["^K",[["^M","^Y"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",105,"^H",105,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^Y"]]]]]],"~$ex-details",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",14,"^G",8,"^H",14,"^I",18,"^14",true,"^J",["^K",["^L",["^K",[["^M","~$ex-type"]]]]]],"^14",true,"^7","~$cljs.tools.reader.impl.errors/ex-details","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",18,"^Q",["^K",[["^M","^2Y"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",14,"^H",14,"^T",2,"^U",true,"^J",["^K",["^L",["^K",[["^M","^2Y"]]]]]],"~$throw-ex",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",26,"^G",8,"^H",26,"^I",16,"^14",true,"^J",["^K",["^L",["^K",[["^M","^2Y","~$&","^15"]]]]],"^1E","Throw an ex-info error.","^1F",["^ ","^P",true,"^T",2,"^Q",[["^K",["^M","^2Y","^15"]]],"^J",["^K",[["^M","^2Y","~$&","^15"]]],"^S",["^K",[null]]]],"^14",true,"^7","~$cljs.tools.reader.impl.errors/throw-ex","^P",true,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",16,"^1F",["^ ","^P",true,"^T",2,"^Q",[["^K",["^M","^2Y","^15"]]],"^J",["^K",[["^M","^2Y","~$&","^15"]]],"^S",["^K",[null]]],"^Q",[["^K",["^M","^2Y","^15"]]],"^R",null,"^S",["^K",[null]],"^G",1,"^F",26,"^H",26,"^T",2,"^U",true,"^J",["^K",[["^M","^2Y","~$&","^15"]]],"^1E","Throw an ex-info error."],"~$throw-invalid",["^ ","^C",null,"^D",["^ ","^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^F",102,"^G",7,"^H",102,"^I",20,"^J",["^K",["^L",["^K",[["^M","^Y","^1A"]]]]]],"^7","~$cljs.tools.reader.impl.errors/throw-invalid","^P",false,"^E","/home/julien/.cljs/.aot_cache/1.10.329/19938CB/cljs/tools/reader/impl/errors.cljs","^I",20,"^Q",["^K",[["^M","^Y","^1A"]]],"^R",null,"^S",["^K",[null,null]],"^G",1,"^F",102,"^H",102,"^T",3,"^U",true,"^J",["^K",["^L",["^K",[["^M","^Y","^1A"]]]]]]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^6",["~:ex-kind","~:reader-error","~:reader-exception","^E","~:type","~:illegal-argument","^F","~:col","~:eof"]],"~:order",["^3:","^37","^39","^E","^F","^3<","^38","^3;","^3="]],"^1E",null] \ No newline at end of file diff --git a/js/cljs/tools/reader/impl/errors.js b/js/cljs/tools/reader/impl/errors.js new file mode 100644 index 0000000..fbef2fb --- /dev/null +++ b/js/cljs/tools/reader/impl/errors.js @@ -0,0 +1,422 @@ +// Compiled by ClojureScript 1.10.329 {:static-fns true, :optimize-constants true, :target :nodejs} +goog.provide('cljs.tools.reader.impl.errors'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +goog.require('cljs.tools.reader.reader_types'); +goog.require('clojure.string'); +goog.require('cljs.tools.reader.impl.inspect'); +cljs.tools.reader.impl.errors.ex_details = (function cljs$tools$reader$impl$errors$ex_details(rdr,ex_type){ +var details = new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$type,cljs.core.cst$kw$reader_DASH_exception,cljs.core.cst$kw$ex_DASH_kind,ex_type], null); +if(cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(rdr))){ +return cljs.core.assoc.cljs$core$IFn$_invoke$arity$variadic(details,cljs.core.cst$kw$file,cljs.tools.reader.reader_types.get_file_name(rdr),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$line,cljs.tools.reader.reader_types.get_line_number(rdr),cljs.core.cst$kw$col,cljs.tools.reader.reader_types.get_column_number(rdr)], 0)); +} else { +return details; +} +}); +/** + * Throw an ex-info error. + */ +cljs.tools.reader.impl.errors.throw_ex = (function cljs$tools$reader$impl$errors$throw_ex(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1869 = arguments.length; +var i__4519__auto___1870 = (0); +while(true){ +if((i__4519__auto___1870 < len__4518__auto___1869)){ +args__4521__auto__.push((arguments[i__4519__auto___1870])); + +var G__1871 = (i__4519__auto___1870 + (1)); +i__4519__auto___1870 = G__1871; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((2) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((2)),(0),null)):null); +return cljs.tools.reader.impl.errors.throw_ex.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4522__auto__); +}); + +cljs.tools.reader.impl.errors.throw_ex.cljs$core$IFn$_invoke$arity$variadic = (function (rdr,ex_type,msg){ +var details = cljs.tools.reader.impl.errors.ex_details(rdr,ex_type); +var file = cljs.core.cst$kw$file.cljs$core$IFn$_invoke$arity$1(details); +var line = cljs.core.cst$kw$line.cljs$core$IFn$_invoke$arity$1(details); +var col = cljs.core.cst$kw$col.cljs$core$IFn$_invoke$arity$1(details); +var msg1 = (cljs.core.truth_(file)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(file)," "].join(''):null); +var msg2 = (cljs.core.truth_(line)?["[line ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(line),", col ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(col),"]"].join(''):null); +var msg3 = (cljs.core.truth_((function (){var or__3936__auto__ = msg1; +if(cljs.core.truth_(or__3936__auto__)){ +return or__3936__auto__; +} else { +return msg2; +} +})())?" ":null); +var full_msg = cljs.core.apply.cljs$core$IFn$_invoke$arity$5(cljs.core.str,msg1,msg2,msg3,msg); +throw cljs.core.ex_info.cljs$core$IFn$_invoke$arity$2(full_msg,details); +}); + +cljs.tools.reader.impl.errors.throw_ex.cljs$lang$maxFixedArity = (2); + +/** @this {Function} */ +cljs.tools.reader.impl.errors.throw_ex.cljs$lang$applyTo = (function (seq1866){ +var G__1867 = cljs.core.first(seq1866); +var seq1866__$1 = cljs.core.next(seq1866); +var G__1868 = cljs.core.first(seq1866__$1); +var seq1866__$2 = cljs.core.next(seq1866__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1867,G__1868,seq1866__$2); +}); + +/** + * Throws an ExceptionInfo with the given message. + * If rdr is an IndexingReader, additional information about column and line number is provided + */ +cljs.tools.reader.impl.errors.reader_error = (function cljs$tools$reader$impl$errors$reader_error(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1874 = arguments.length; +var i__4519__auto___1875 = (0); +while(true){ +if((i__4519__auto___1875 < len__4518__auto___1874)){ +args__4521__auto__.push((arguments[i__4519__auto___1875])); + +var G__1876 = (i__4519__auto___1875 + (1)); +i__4519__auto___1875 = G__1876; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic = (function (rdr,msgs){ +return cljs.tools.reader.impl.errors.throw_ex.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.cst$kw$reader_DASH_error,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,msgs)], 0)); +}); + +cljs.tools.reader.impl.errors.reader_error.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.tools.reader.impl.errors.reader_error.cljs$lang$applyTo = (function (seq1872){ +var G__1873 = cljs.core.first(seq1872); +var seq1872__$1 = cljs.core.next(seq1872); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1873,seq1872__$1); +}); + +/** + * Throws an ExceptionInfo with the given message. + * If rdr is an IndexingReader, additional information about column and line number is provided + */ +cljs.tools.reader.impl.errors.illegal_arg_error = (function cljs$tools$reader$impl$errors$illegal_arg_error(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1879 = arguments.length; +var i__4519__auto___1880 = (0); +while(true){ +if((i__4519__auto___1880 < len__4518__auto___1879)){ +args__4521__auto__.push((arguments[i__4519__auto___1880])); + +var G__1881 = (i__4519__auto___1880 + (1)); +i__4519__auto___1880 = G__1881; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.tools.reader.impl.errors.illegal_arg_error.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.tools.reader.impl.errors.illegal_arg_error.cljs$core$IFn$_invoke$arity$variadic = (function (rdr,msgs){ +return cljs.tools.reader.impl.errors.throw_ex.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.cst$kw$illegal_DASH_argument,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,msgs)], 0)); +}); + +cljs.tools.reader.impl.errors.illegal_arg_error.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.tools.reader.impl.errors.illegal_arg_error.cljs$lang$applyTo = (function (seq1877){ +var G__1878 = cljs.core.first(seq1877); +var seq1877__$1 = cljs.core.next(seq1877); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1878,seq1877__$1); +}); + +/** + * Throws an ExceptionInfo with the given message. + * If rdr is an IndexingReader, additional information about column and line number is provided + */ +cljs.tools.reader.impl.errors.eof_error = (function cljs$tools$reader$impl$errors$eof_error(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1884 = arguments.length; +var i__4519__auto___1885 = (0); +while(true){ +if((i__4519__auto___1885 < len__4518__auto___1884)){ +args__4521__auto__.push((arguments[i__4519__auto___1885])); + +var G__1886 = (i__4519__auto___1885 + (1)); +i__4519__auto___1885 = G__1886; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((1) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((1)),(0),null)):null); +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__4522__auto__); +}); + +cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic = (function (rdr,msgs){ +return cljs.tools.reader.impl.errors.throw_ex.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.cst$kw$eof,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,msgs)], 0)); +}); + +cljs.tools.reader.impl.errors.eof_error.cljs$lang$maxFixedArity = (1); + +/** @this {Function} */ +cljs.tools.reader.impl.errors.eof_error.cljs$lang$applyTo = (function (seq1882){ +var G__1883 = cljs.core.first(seq1882); +var seq1882__$1 = cljs.core.next(seq1882); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1883,seq1882__$1); +}); + +cljs.tools.reader.impl.errors.throw_eof_delimited = (function cljs$tools$reader$impl$errors$throw_eof_delimited(var_args){ +var G__1888 = arguments.length; +switch (G__1888) { +case 4: +return cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)])); + +break; +case 5: +return cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$core$IFn$_invoke$arity$4 = (function (rdr,kind,column,line){ +return cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$core$IFn$_invoke$arity$5(rdr,kind,line,column,null); +}); + +cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$core$IFn$_invoke$arity$5 = (function (rdr,kind,line,column,n){ +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unexpected EOF while reading ",(cljs.core.truth_(n)?["item ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(n)," of "].join(''):null),cljs.core.name(kind),(cljs.core.truth_(line)?[", starting at line ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(line)," and column ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(column)].join(''):null),"."], 0)); +}); + +cljs.tools.reader.impl.errors.throw_eof_delimited.cljs$lang$maxFixedArity = 5; + +cljs.tools.reader.impl.errors.throw_odd_map = (function cljs$tools$reader$impl$errors$throw_odd_map(rdr,line,col,elements){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["The map literal starting with ",cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1(cljs.core.first(elements)),(cljs.core.truth_(line)?[" on line ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(line)," column ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(col)].join(''):null)," contains ",cljs.core.count(elements)," form(s). Map literals must contain an even number of forms."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_number = (function cljs$tools$reader$impl$errors$throw_invalid_number(rdr,token){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid number: ",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_unicode_literal = (function cljs$tools$reader$impl$errors$throw_invalid_unicode_literal(rdr,token){ +throw cljs.tools.reader.impl.errors.illegal_arg_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid unicode literal: \\",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_unicode_escape = (function cljs$tools$reader$impl$errors$throw_invalid_unicode_escape(rdr,ch){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid unicode escape: \\u",ch,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid = (function cljs$tools$reader$impl$errors$throw_invalid(rdr,kind,token){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid ",cljs.core.name(kind),": ",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_eof_at_start = (function cljs$tools$reader$impl$errors$throw_eof_at_start(rdr,kind){ +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unexpected EOF while reading start of ",cljs.core.name(kind),"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_char = (function cljs$tools$reader$impl$errors$throw_bad_char(rdr,kind,ch){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid character: ",ch," found while reading ",cljs.core.name(kind),"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_eof_at_dispatch = (function cljs$tools$reader$impl$errors$throw_eof_at_dispatch(rdr){ +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unexpected EOF while reading dispatch character."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_dispatch = (function cljs$tools$reader$impl$errors$throw_bad_dispatch(rdr,ch){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["No dispatch macro for ",ch,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_unmatch_delimiter = (function cljs$tools$reader$impl$errors$throw_unmatch_delimiter(rdr,ch){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unmatched delimiter ",ch,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_eof_reading = (function cljs$tools$reader$impl$errors$throw_eof_reading(var_args){ +var args__4521__auto__ = []; +var len__4518__auto___1894 = arguments.length; +var i__4519__auto___1895 = (0); +while(true){ +if((i__4519__auto___1895 < len__4518__auto___1894)){ +args__4521__auto__.push((arguments[i__4519__auto___1895])); + +var G__1896 = (i__4519__auto___1895 + (1)); +i__4519__auto___1895 = G__1896; +continue; +} else { +} +break; +} + +var argseq__4522__auto__ = ((((2) < args__4521__auto__.length))?(new cljs.core.IndexedSeq(args__4521__auto__.slice((2)),(0),null)):null); +return cljs.tools.reader.impl.errors.throw_eof_reading.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4522__auto__); +}); + +cljs.tools.reader.impl.errors.throw_eof_reading.cljs$core$IFn$_invoke$arity$variadic = (function (rdr,kind,start){ +var init = (function (){var G__1893 = kind; +var G__1893__$1 = (((G__1893 instanceof cljs.core.Keyword))?G__1893.fqn:null); +switch (G__1893__$1) { +case "regex": +return "#\""; + +break; +case "string": +return "\""; + +break; +default: +throw (new Error(["No matching clause: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__1893__$1)].join(''))); + +} +})(); +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unexpected EOF reading ",cljs.core.name(kind)," starting ",cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.str,init,start),"."], 0)); +}); + +cljs.tools.reader.impl.errors.throw_eof_reading.cljs$lang$maxFixedArity = (2); + +/** @this {Function} */ +cljs.tools.reader.impl.errors.throw_eof_reading.cljs$lang$applyTo = (function (seq1890){ +var G__1891 = cljs.core.first(seq1890); +var seq1890__$1 = cljs.core.next(seq1890); +var G__1892 = cljs.core.first(seq1890__$1); +var seq1890__$2 = cljs.core.next(seq1890__$1); +var self__4505__auto__ = this; +return self__4505__auto__.cljs$core$IFn$_invoke$arity$variadic(G__1891,G__1892,seq1890__$2); +}); + +cljs.tools.reader.impl.errors.throw_no_dispatch = (function cljs$tools$reader$impl$errors$throw_no_dispatch(rdr,ch){ +return cljs.tools.reader.impl.errors.throw_bad_dispatch(rdr,ch); +}); +cljs.tools.reader.impl.errors.throw_invalid_unicode_char = (function cljs$tools$reader$impl$errors$throw_invalid_unicode_char(rdr,token){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid unicode character \\",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_unicode_digit_in_token = (function cljs$tools$reader$impl$errors$throw_invalid_unicode_digit_in_token(rdr,ch,token){ +return cljs.tools.reader.impl.errors.illegal_arg_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid digit ",ch," in unicode character \\",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_unicode_digit = (function cljs$tools$reader$impl$errors$throw_invalid_unicode_digit(rdr,ch){ +return cljs.tools.reader.impl.errors.illegal_arg_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid digit ",ch," in unicode character."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_unicode_len = (function cljs$tools$reader$impl$errors$throw_invalid_unicode_len(rdr,actual,expected){ +return cljs.tools.reader.impl.errors.illegal_arg_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid unicode literal. Unicode literals should be ",expected,"characters long. ","value suppled is ",actual,"characters long."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_character_literal = (function cljs$tools$reader$impl$errors$throw_invalid_character_literal(rdr,token){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid character literal \\u",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_invalid_octal_len = (function cljs$tools$reader$impl$errors$throw_invalid_octal_len(rdr,token){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid octal escape sequence in a character literal:",token,". Octal escape sequences must be 3 or fewer digits."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_octal_number = (function cljs$tools$reader$impl$errors$throw_bad_octal_number(rdr){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Octal escape sequence must be in range [0, 377]."], 0)); +}); +cljs.tools.reader.impl.errors.throw_unsupported_character = (function cljs$tools$reader$impl$errors$throw_unsupported_character(rdr,token){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unsupported character: ",token,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_eof_in_character = (function cljs$tools$reader$impl$errors$throw_eof_in_character(rdr){ +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unexpected EOF while reading character."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_escape_char = (function cljs$tools$reader$impl$errors$throw_bad_escape_char(rdr,ch){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Unsupported escape character: \\",ch,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_single_colon = (function cljs$tools$reader$impl$errors$throw_single_colon(rdr){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["A single colon is not a valid keyword."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_metadata = (function cljs$tools$reader$impl$errors$throw_bad_metadata(rdr,x){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Metadata cannot be ",cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1(x),". Metadata must be a Symbol, Keyword, String or Map."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_metadata_target = (function cljs$tools$reader$impl$errors$throw_bad_metadata_target(rdr,target){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Metadata can not be applied to ",cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1(target),". ","Metadata can only be applied to IMetas."], 0)); +}); +cljs.tools.reader.impl.errors.throw_feature_not_keyword = (function cljs$tools$reader$impl$errors$throw_feature_not_keyword(rdr,feature){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Feature cannot be ",cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1(feature)," Features must be keywords."], 0)); +}); +cljs.tools.reader.impl.errors.throw_ns_map_no_map = (function cljs$tools$reader$impl$errors$throw_ns_map_no_map(rdr,ns_name){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Namespaced map with namespace ",ns_name," does not specify a map."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_ns = (function cljs$tools$reader$impl$errors$throw_bad_ns(rdr,ns_name){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid value used as namespace in namespaced map: ",ns_name,"."], 0)); +}); +cljs.tools.reader.impl.errors.throw_bad_reader_tag = (function cljs$tools$reader$impl$errors$throw_bad_reader_tag(rdr,tag){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["Invalid reader tag: ",cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1(tag),". Reader tags must be symbols."], 0)); +}); +cljs.tools.reader.impl.errors.throw_unknown_reader_tag = (function cljs$tools$reader$impl$errors$throw_unknown_reader_tag(rdr,tag){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["No reader function for tag ",cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1(tag),"."], 0)); +}); +cljs.tools.reader.impl.errors.duplicate_keys_error = (function cljs$tools$reader$impl$errors$duplicate_keys_error(msg,coll){ +var duplicates = (function cljs$tools$reader$impl$errors$duplicate_keys_error_$_duplicates(seq){ +var iter__4311__auto__ = (function cljs$tools$reader$impl$errors$duplicate_keys_error_$_duplicates_$_iter__1908(s__1909){ +return (new cljs.core.LazySeq(null,(function (){ +var s__1909__$1 = s__1909; +while(true){ +var temp__5457__auto__ = cljs.core.seq(s__1909__$1); +if(temp__5457__auto__){ +var s__1909__$2 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s__1909__$2)){ +var c__4309__auto__ = cljs.core.chunk_first(s__1909__$2); +var size__4310__auto__ = cljs.core.count(c__4309__auto__); +var b__1911 = cljs.core.chunk_buffer(size__4310__auto__); +if((function (){var i__1910 = (0); +while(true){ +if((i__1910 < size__4310__auto__)){ +var vec__1912 = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c__4309__auto__,i__1910); +var id = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1912,(0),null); +var freq = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1912,(1),null); +if((freq > (1))){ +cljs.core.chunk_append(b__1911,id); + +var G__1918 = (i__1910 + (1)); +i__1910 = G__1918; +continue; +} else { +var G__1919 = (i__1910 + (1)); +i__1910 = G__1919; +continue; +} +} else { +return true; +} +break; +} +})()){ +return cljs.core.chunk_cons(cljs.core.chunk(b__1911),cljs$tools$reader$impl$errors$duplicate_keys_error_$_duplicates_$_iter__1908(cljs.core.chunk_rest(s__1909__$2))); +} else { +return cljs.core.chunk_cons(cljs.core.chunk(b__1911),null); +} +} else { +var vec__1915 = cljs.core.first(s__1909__$2); +var id = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1915,(0),null); +var freq = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1915,(1),null); +if((freq > (1))){ +return cljs.core.cons(id,cljs$tools$reader$impl$errors$duplicate_keys_error_$_duplicates_$_iter__1908(cljs.core.rest(s__1909__$2))); +} else { +var G__1920 = cljs.core.rest(s__1909__$2); +s__1909__$1 = G__1920; +continue; +} +} +} else { +return null; +} +break; +} +}),null,null)); +}); +return iter__4311__auto__(cljs.core.frequencies(seq)); +}); +var dups = duplicates(coll); +return cljs.core.apply.cljs$core$IFn$_invoke$arity$5(cljs.core.str,msg,(((cljs.core.count(dups) > (1)))?"s":null),": ",cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(", ",dups)); +}); +cljs.tools.reader.impl.errors.throw_dup_keys = (function cljs$tools$reader$impl$errors$throw_dup_keys(rdr,kind,ks){ +return cljs.tools.reader.impl.errors.reader_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.tools.reader.impl.errors.duplicate_keys_error([cljs.core.str.cljs$core$IFn$_invoke$arity$1(clojure.string.capitalize(cljs.core.name(kind)))," literal contains duplicate key"].join(''),ks)], 0)); +}); +cljs.tools.reader.impl.errors.throw_eof_error = (function cljs$tools$reader$impl$errors$throw_eof_error(rdr,line){ +if(cljs.core.truth_(line)){ +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["EOF while reading, starting at line ",line,"."], 0)); +} else { +return cljs.tools.reader.impl.errors.eof_error.cljs$core$IFn$_invoke$arity$variadic(rdr,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2(["EOF while reading."], 0)); +} +}); diff --git a/js/cljs/tools/reader/impl/inspect.cljs b/js/cljs/tools/reader/impl/inspect.cljs new file mode 100644 index 0000000..ae1711e --- /dev/null +++ b/js/cljs/tools/reader/impl/inspect.cljs @@ -0,0 +1,90 @@ +;; Copyright (c) Russ Olsen, Nicola Mometto, Rich Hickey & contributors. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns cljs.tools.reader.impl.inspect) + +(declare inspect*) + +(defn- inspect*-col [truncate col start end] + (let [n (count col) + l (if truncate 0 (min 10 n)) + elements (map (partial inspect* true) (take l col)) + content (apply str (interpose " " elements)) + suffix (if (< l n) "...")] + (str start content suffix end))) + +(defn- dispatch-inspect + [_ x] + (cond + (nil? x) :nil + (string? x) :string + (keyword? x) :strable + (number? x) :strable + (symbol? x) :strable + (vector? x) :vector + (list? x) :list + (map? x) :map + (set? x) :set + (= x true) :strable + (= x false) :strable + :default (type x))) + +(defmulti inspect* dispatch-inspect) + +(defmethod inspect* :string [truncate ^String x] + (let [n (if truncate 5 20) + suffix (if (> (.-length x) n) "...\"" "\"")] + (str + \" + (.substring ^String x 0 (min n (.-length x))) + suffix))) + +(defmethod inspect* :strable [truncate x] (str x)) + +(defmethod inspect* cljs.core/IndexedSeq [truncate x] + "") + +(defmethod inspect* cljs.core/PersistentArrayMapSeq [truncate x] + "") + +(defmethod inspect* cljs.core/NodeSeq [truncate x] + "") + +(defmethod inspect* cljs.core/Cons [truncate x] "") + +(defmethod inspect* cljs.core/LazySeq [truncate x] "") + +(defmethod inspect* :nil [_ _] "nil") + +(defmethod inspect* :list [truncate col] + (inspect*-col truncate col \( \))) + +(defmethod inspect* :map [truncate m] + (let [len (count m) + n-shown (if truncate 0 len) + contents (apply concat (take n-shown m)) + suffix (if (> len n-shown) "...}" \})] + (inspect*-col truncate contents \{ suffix))) + +(defmethod inspect* :set [truncate col] + (inspect*-col truncate col "#{" \})) + +(defmethod inspect* :vector [truncate col] + (inspect*-col truncate col \[ \])) + +(defmethod inspect* :default [truncate x] + (pr-str (type x))) + +(defn inspect + "Return a string description of the value supplied. + May be the a string version of the value itself (e.g. \"true\") + or it may be a description (e.g. \"an instance of Foo\"). + If truncate is true then return a very terse version of + the inspection." + ([x] (inspect* false x)) + ([truncate x] (inspect* truncate x))) diff --git a/js/cljs/tools/reader/impl/inspect.cljs.cache.json b/js/cljs/tools/reader/impl/inspect.cljs.cache.json new file mode 100644 index 0000000..8d3e22b --- /dev/null +++ b/js/cljs/tools/reader/impl/inspect.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$Error",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",[]],"~:name","~$cljs.tools.reader.impl.inspect","~:imports",null,"~:requires",null,"~:cljs.spec/speced-vars",[],"~:uses",null,"~:defs",["^ ","~$inspect*",["^ ","^7","~$cljs.tools.reader.impl.inspect/inspect*","~:file","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","~:line",37,"~:column",1,"~:end-line",37,"~:end-column",19,"~:meta",["^ ","^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^A",37,"^B",11,"^C",37,"^D",19],"~:tag","~$cljs.core/MultiFn"],"~$inspect*-col",["^ ","~:protocol-inline",null,"^E",["^ ","^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^A",13,"^B",8,"^C",13,"^D",20,"~:private",true,"~:arglists",["~#list",["~$quote",["^L",[["~$truncate","~$col","~$start","~$end"]]]]]],"^J",true,"^7","~$cljs.tools.reader.impl.inspect/inspect*-col","~:variadic",false,"^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^D",20,"~:method-params",["^L",[["^N","^O","^P","^Q"]]],"~:protocol-impl",null,"~:arglists-meta",["^L",[null,null]],"^B",1,"^A",13,"^C",13,"~:max-fixed-arity",4,"~:fn-var",true,"^K",["^L",["^M",["^L",[["^N","^O","^P","^Q"]]]]]],"~$dispatch-inspect",["^ ","^I",null,"^E",["^ ","^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^A",21,"^B",8,"^C",21,"^D",24,"^J",true,"^K",["^L",["^M",["^L",[["~$_","~$x"]]]]]],"^J",true,"^7","~$cljs.tools.reader.impl.inspect/dispatch-inspect","^S",false,"^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^D",24,"^T",["^L",[["~$_","~$x"]]],"^U",null,"^V",["^L",[null,null]],"^B",1,"^A",21,"^C",21,"^W",2,"^X",true,"^K",["^L",["^M",["^L",[["~$_","~$x"]]]]]],"~$inspect",["^ ","^I",null,"^E",["^ ","^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^A",83,"^B",7,"^C",83,"^D",14,"^K",["^L",["^M",["^L",[["~$x"],["^N","~$x"]]]]],"~:doc","Return a string description of the value supplied.\n May be the a string version of the value itself (e.g. \"true\")\n or it may be a description (e.g. \"an instance of Foo\").\n If truncate is true then return a very terse version of\n the inspection.","~:top-fn",["^ ","^S",false,"^W",2,"^T",["^L",[["~$x"],["^N","~$x"]]],"^K",["^L",[["~$x"],["^N","~$x"]]],"^V",["^L",[null,null]]]],"^7","~$cljs.tools.reader.impl.inspect/inspect","^S",false,"^@","/home/julien/.cljs/.aot_cache/1.10.329/110E9FF/cljs/tools/reader/impl/inspect.cljs","^D",14,"^11",["^ ","^S",false,"^W",2,"^T",["^L",[["~$x"],["^N","~$x"]]],"^K",["^L",[["~$x"],["^N","~$x"]]],"^V",["^L",[null,null]]],"^T",["^L",[["~$x"],["^N","~$x"]]],"^U",null,"^V",["^L",[null,null]],"^B",1,"^A",83,"^C",83,"^W",2,"^X",true,"^K",["^L",[["~$x"],["^N","~$x"]]],"^10","Return a string description of the value supplied.\n May be the a string version of the value itself (e.g. \"true\")\n or it may be a description (e.g. \"an instance of Foo\").\n If truncate is true then return a very terse version of\n the inspection."]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^6",["~:default","~:string","~:vector","~:strable","~:list","~:nil","~:set","~:hierarchy","~:map"]],"~:order",["^1<","^18","^1:","^19","^1;","^1?","^1=","^17","^1>"]],"^10",null] \ No newline at end of file diff --git a/js/cljs/tools/reader/impl/inspect.js b/js/cljs/tools/reader/impl/inspect.js new file mode 100644 index 0000000..31dd734 --- /dev/null +++ b/js/cljs/tools/reader/impl/inspect.js @@ -0,0 +1,155 @@ +// Compiled by ClojureScript 1.10.329 {:static-fns true, :optimize-constants true, :target :nodejs} +goog.provide('cljs.tools.reader.impl.inspect'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +cljs.tools.reader.impl.inspect.inspect_STAR__col = (function cljs$tools$reader$impl$inspect$inspect_STAR__col(truncate,col,start,end){ +var n = cljs.core.count(col); +var l = (cljs.core.truth_(truncate)?(0):(function (){var x__4027__auto__ = (10); +var y__4028__auto__ = n; +return ((x__4027__auto__ < y__4028__auto__) ? x__4027__auto__ : y__4028__auto__); +})()); +var elements = cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(cljs.tools.reader.impl.inspect.inspect_STAR_,true),cljs.core.take.cljs$core$IFn$_invoke$arity$2(l,col)); +var content = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(" ",elements)); +var suffix = (((l < n))?"...":null); +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(start),cljs.core.str.cljs$core$IFn$_invoke$arity$1(content),cljs.core.str.cljs$core$IFn$_invoke$arity$1(suffix),cljs.core.str.cljs$core$IFn$_invoke$arity$1(end)].join(''); +}); +cljs.tools.reader.impl.inspect.dispatch_inspect = (function cljs$tools$reader$impl$inspect$dispatch_inspect(_,x){ +if((x == null)){ +return cljs.core.cst$kw$nil; +} else { +if(typeof x === 'string'){ +return cljs.core.cst$kw$string; +} else { +if((x instanceof cljs.core.Keyword)){ +return cljs.core.cst$kw$strable; +} else { +if(typeof x === 'number'){ +return cljs.core.cst$kw$strable; +} else { +if((x instanceof cljs.core.Symbol)){ +return cljs.core.cst$kw$strable; +} else { +if(cljs.core.vector_QMARK_(x)){ +return cljs.core.cst$kw$vector; +} else { +if(cljs.core.list_QMARK_(x)){ +return cljs.core.cst$kw$list; +} else { +if(cljs.core.map_QMARK_(x)){ +return cljs.core.cst$kw$map; +} else { +if(cljs.core.set_QMARK_(x)){ +return cljs.core.cst$kw$set; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,true)){ +return cljs.core.cst$kw$strable; +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(x,false)){ +return cljs.core.cst$kw$strable; +} else { +return cljs.core.type(x); + +} +} +} +} +} +} +} +} +} +} +} +}); +if((typeof cljs !== 'undefined') && (typeof cljs.tools !== 'undefined') && (typeof cljs.tools.reader !== 'undefined') && (typeof cljs.tools.reader.impl !== 'undefined') && (typeof cljs.tools.reader.impl.inspect !== 'undefined') && (typeof cljs.tools.reader.impl.inspect.inspect_STAR_ !== 'undefined')){ +} else { +cljs.tools.reader.impl.inspect.inspect_STAR_ = (function (){var method_table__4401__auto__ = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +var prefer_table__4402__auto__ = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +var method_cache__4403__auto__ = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +var cached_hierarchy__4404__auto__ = cljs.core.atom.cljs$core$IFn$_invoke$arity$1(cljs.core.PersistentArrayMap.EMPTY); +var hierarchy__4405__auto__ = cljs.core.get.cljs$core$IFn$_invoke$arity$3(cljs.core.PersistentArrayMap.EMPTY,cljs.core.cst$kw$hierarchy,cljs.core.get_global_hierarchy()); +return (new cljs.core.MultiFn(cljs.core.symbol.cljs$core$IFn$_invoke$arity$2("cljs.tools.reader.impl.inspect","inspect*"),cljs.tools.reader.impl.inspect.dispatch_inspect,cljs.core.cst$kw$default,hierarchy__4405__auto__,method_table__4401__auto__,prefer_table__4402__auto__,method_cache__4403__auto__,cached_hierarchy__4404__auto__)); +})(); +} +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$string,(function (truncate,x){ +var n = (cljs.core.truth_(truncate)?(5):(20)); +var suffix = (((x.length > n))?"...\"":"\""); +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1("\""),cljs.core.str.cljs$core$IFn$_invoke$arity$1(x.substring((0),(function (){var x__4027__auto__ = n; +var y__4028__auto__ = x.length; +return ((x__4027__auto__ < y__4028__auto__) ? x__4027__auto__ : y__4028__auto__); +})())),cljs.core.str.cljs$core$IFn$_invoke$arity$1(suffix)].join(''); +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$strable,(function (truncate,x){ +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(x)].join(''); +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.IndexedSeq,(function (truncate,x){ +return ""; +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.PersistentArrayMapSeq,(function (truncate,x){ +return ""; +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.NodeSeq,(function (truncate,x){ +return ""; +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.Cons,(function (truncate,x){ +return ""; +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.LazySeq,(function (truncate,x){ +return ""; +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$nil,(function (_,___$1){ +return "nil"; +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$list,(function (truncate,col){ +return cljs.tools.reader.impl.inspect.inspect_STAR__col(truncate,col,"(",")"); +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$map,(function (truncate,m){ +var len = cljs.core.count(m); +var n_shown = (cljs.core.truth_(truncate)?(0):len); +var contents = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,cljs.core.take.cljs$core$IFn$_invoke$arity$2(n_shown,m)); +var suffix = (((len > n_shown))?"...}":"}"); +return cljs.tools.reader.impl.inspect.inspect_STAR__col(truncate,contents,"{",suffix); +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$set,(function (truncate,col){ +return cljs.tools.reader.impl.inspect.inspect_STAR__col(truncate,col,"#{","}"); +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$vector,(function (truncate,col){ +return cljs.tools.reader.impl.inspect.inspect_STAR__col(truncate,col,"[","]"); +})); +cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IMultiFn$_add_method$arity$3(null,cljs.core.cst$kw$default,(function (truncate,x){ +return cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.type(x)], 0)); +})); +/** + * Return a string description of the value supplied. + * May be the a string version of the value itself (e.g. "true") + * or it may be a description (e.g. "an instance of Foo"). + * If truncate is true then return a very terse version of + * the inspection. + */ +cljs.tools.reader.impl.inspect.inspect = (function cljs$tools$reader$impl$inspect$inspect(var_args){ +var G__1862 = arguments.length; +switch (G__1862) { +case 1: +return cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$1 = (function (x){ +return (cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IFn$_invoke$arity$2 ? cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IFn$_invoke$arity$2(false,x) : cljs.tools.reader.impl.inspect.inspect_STAR_.call(null,false,x)); +}); + +cljs.tools.reader.impl.inspect.inspect.cljs$core$IFn$_invoke$arity$2 = (function (truncate,x){ +return (cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IFn$_invoke$arity$2 ? cljs.tools.reader.impl.inspect.inspect_STAR_.cljs$core$IFn$_invoke$arity$2(truncate,x) : cljs.tools.reader.impl.inspect.inspect_STAR_.call(null,truncate,x)); +}); + +cljs.tools.reader.impl.inspect.inspect.cljs$lang$maxFixedArity = 2; + diff --git a/js/cljs/tools/reader/impl/utils.cljs b/js/cljs/tools/reader/impl/utils.cljs new file mode 100644 index 0000000..46e2d99 --- /dev/null +++ b/js/cljs/tools/reader/impl/utils.cljs @@ -0,0 +1,97 @@ +;; Copyright (c) Nicola Mometto, Rich Hickey & contributors. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns cljs.tools.reader.impl.utils + (:refer-clojure :exclude [char]) + (:require + [clojure.string :as string] + [goog.string :as gstring])) + +(defn char [x] + (when-not (nil? x) + (cljs.core/char x))) + +(defn ^boolean ex-info? [ex] + (instance? cljs.core.ExceptionInfo ex)) + +(defrecord ReaderConditional [splicing? form]) + +(defn ^boolean reader-conditional? + "Return true if the value is the data representation of a reader conditional" + [value] + (instance? ReaderConditional value)) + +(defn reader-conditional + "Construct a data representation of a reader conditional. + If true, splicing? indicates read-cond-splicing." + [form splicing?] + (ReaderConditional. splicing? form)) + +(extend-protocol IPrintWithWriter + ReaderConditional + (-pr-writer [coll writer opts] + (-write writer (str "#?" (when (:splicing? coll) "@"))) + (pr-writer (:form coll) writer opts))) + +(def ws-rx #"[\s]") + +(defn ^boolean whitespace? + "Checks whether a given character is whitespace" + [ch] + (when-not (nil? ch) + (if (identical? ch \,) + true + (.test ws-rx ch)))) + +(defn ^boolean numeric? + "Checks whether a given character is numeric" + [ch] + (when-not (nil? ch) + (gstring/isNumeric ch))) + +(defn ^boolean newline? + "Checks whether the character is a newline" + [c] + (or (identical? \newline c) + (identical? "\n" c) + (nil? c))) + +(defn desugar-meta + "Resolves syntactical sugar in metadata" ;; could be combined with some other desugar? + [f] + (cond + (keyword? f) {f true} + (symbol? f) {:tag f} + (string? f) {:tag f} + :else f)) + +(def last-id (atom 0)) + +(defn next-id + [] + (swap! last-id inc)) + +(defn namespace-keys [ns keys] + (for [key keys] + (if (or (symbol? key) + (keyword? key)) + (let [[key-ns key-name] ((juxt namespace name) key) + ->key (if (symbol? key) symbol keyword)] + (cond + (nil? key-ns) + (->key ns key-name) + + (= "_" key-ns) + (->key key-name) + + :else + key)) + key))) + +(defn second' [[a b]] + (when-not a b)) diff --git a/js/cljs/tools/reader/impl/utils.cljs.cache.json b/js/cljs/tools/reader/impl/utils.cljs.cache.json new file mode 100644 index 0000000..b3eb65a --- /dev/null +++ b/js/cljs/tools/reader/impl/utils.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:use-macros",["^ "],"~:excludes",["~#set",["~$char"]],"~:name","~$cljs.tools.reader.impl.utils","~:imports",null,"~:requires",["^ ","~$string","~$clojure.string","^;","^;","~$gstring","~$goog.string","^=","^="],"~:cljs.spec/speced-vars",[],"~:uses",null,"~:defs",["^ ","~$reader-conditional",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:file","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","~:line",29,"~:column",7,"~:end-line",29,"~:end-column",25,"~:arglists",["~#list",["~$quote",["^J",[["~$form","~$splicing?"]]]]],"~:doc","Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing."],"^6","~$cljs.tools.reader.impl.utils/reader-conditional","~:variadic",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",25,"~:method-params",["^J",[["^L","^M"]]],"~:protocol-impl",null,"~:arglists-meta",["^J",[null,null]],"^F",1,"^E",29,"^G",29,"~:max-fixed-arity",2,"~:fn-var",true,"^I",["^J",["^K",["^J",[["^L","^M"]]]]],"^N","Construct a data representation of a reader conditional.\n If true, splicing? indicates read-cond-splicing."],"~$whitespace?",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",43,"^F",16,"^G",43,"^H",27,"~:tag","~$boolean","^I",["^J",["^K",["^J",[["~$ch"]]]]],"^N","Checks whether a given character is whitespace"],"^6","~$cljs.tools.reader.impl.utils/whitespace?","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",27,"^Q",["^J",[["^Y"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",43,"~:ret-tag","^X","^G",43,"^T",1,"^W","^X","^U",true,"^I",["^J",["^K",["^J",[["^Y"]]]]],"^N","Checks whether a given character is whitespace"],"~$last-id",["^ ","^6","~$cljs.tools.reader.impl.utils/last-id","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",73,"^F",1,"^G",73,"^H",13,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",73,"^F",6,"^G",73,"^H",13],"^W","~$any"],"^5",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",15,"^F",7,"^G",15,"^H",11,"^I",["^J",["^K",["^J",[["~$x"]]]]]],"^6","~$cljs.tools.reader.impl.utils/char","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",11,"^Q",["^J",[["~$x"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",15,"^G",15,"^T",1,"^U",true,"^I",["^J",["^K",["^J",[["~$x"]]]]]],"~$numeric?",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",51,"^F",16,"^G",51,"^H",24,"^W","^X","^I",["^J",["^K",["^J",[["^Y"]]]]],"^N","Checks whether a given character is numeric"],"^6","~$cljs.tools.reader.impl.utils/numeric?","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",24,"^Q",["^J",[["^Y"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",51,"^[","^X","^G",51,"^T",1,"^W","^X","^U",true,"^I",["^J",["^K",["^J",[["^Y"]]]]],"^N","Checks whether a given character is numeric"],"~$ReaderConditional",["^ ","~:num-fields",2,"~:protocols",["^4",["~$cljs.core/IRecord","~$cljs.core/IEquiv","~$cljs.core/IHash","~$cljs.core/ICollection","~$cljs.core/ICounted","~$cljs.core/ISeqable","~$cljs.core/IMeta","~$cljs.core/ICloneable","~$cljs.core/IPrintWithWriter","~$cljs.core/IIterable","~$cljs.core/IWithMeta","~$cljs.core/IAssociative","~$cljs.core/IMap","~$cljs.core/ILookup"]],"^6","~$cljs.tools.reader.impl.utils/ReaderConditional","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",29,"~:type",true,"^F",12,"~:internal-ctor",true,"^E",22,"~:record",true,"^G",22,"^W","~$function","~:skip-protocol-flag",["^4",["^19","^1:","^1;","^1<","^1=","^1>","^1?","^1@","^1A","^1B","^1C","^1D","^1E","^1F"]]],"~$second'",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",96,"^F",7,"^G",96,"^H",14,"^I",["^J",["^K",["^J",[[["~$a","~$b"]]]]]]],"^6","~$cljs.tools.reader.impl.utils/second'","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",14,"^Q",["^J",[["~$p__1840"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",96,"^G",96,"^T",1,"^U",true,"^I",["^J",["^K",["^J",[[["~$a","~$b"]]]]]]],"~$desugar-meta",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",64,"^F",7,"^G",64,"^H",19,"^I",["^J",["^K",["^J",[["~$f"]]]]],"^N","Resolves syntactical sugar in metadata"],"^6","~$cljs.tools.reader.impl.utils/desugar-meta","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",19,"^Q",["^J",[["~$f"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",64,"^G",64,"^T",1,"^U",true,"^I",["^J",["^K",["^J",[["~$f"]]]]],"^N","Resolves syntactical sugar in metadata"],"~$->ReaderConditional",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",22,"^F",12,"^G",22,"^H",29,"^1I",true,"~:factory","~:positional","^I",["^J",["^K",["^J",[["^M","^L"]]]]],"^N","Positional factory function for cljs.tools.reader.impl.utils/ReaderConditional."],"^6","~$cljs.tools.reader.impl.utils/->ReaderConditional","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",29,"^Q",["^J",[["^M","^L"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^1I",true,"^1S","^1T","^E",22,"^G",22,"^T",2,"^U",true,"^I",["^J",["^K",["^J",[["^M","^L"]]]]],"^N","Positional factory function for cljs.tools.reader.impl.utils/ReaderConditional."],"~$next-id",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",75,"^F",7,"^G",75,"^H",14,"^I",["^J",["^K",["^J",[[]]]]]],"^6","~$cljs.tools.reader.impl.utils/next-id","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",14,"^Q",["^J",[[]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",75,"^G",75,"^T",0,"^U",true,"^I",["^J",["^K",["^J",[[]]]]]],"~$map->ReaderConditional",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",22,"^F",12,"^G",22,"^H",29,"^1I",true,"^1S","~:map","^I",["^J",["^K",["^J",[["~$G__1815"]]]]],"^N","Factory function for cljs.tools.reader.impl.utils/ReaderConditional, taking a map of keywords to field values."],"^6","~$cljs.tools.reader.impl.utils/map->ReaderConditional","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",29,"^Q",["^J",[["^1Z"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^1I",true,"^1S","^1Y","^E",22,"^G",22,"^T",1,"^U",true,"^I",["^J",["^K",["^J",[["^1Z"]]]]],"^N","Factory function for cljs.tools.reader.impl.utils/ReaderConditional, taking a map of keywords to field values."],"~$ex-info?",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",19,"^F",16,"^G",19,"^H",24,"^W","^X","^I",["^J",["^K",["^J",[["~$ex"]]]]]],"^6","~$cljs.tools.reader.impl.utils/ex-info?","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",24,"^Q",["^J",[["^21"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",19,"^[","^X","^G",19,"^T",1,"^W","^X","^U",true,"^I",["^J",["^K",["^J",[["^21"]]]]]],"~$reader-conditional?",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",24,"^F",16,"^G",24,"^H",35,"^W","^X","^I",["^J",["^K",["^J",[["~$value"]]]]],"^N","Return true if the value is the data representation of a reader conditional"],"^6","~$cljs.tools.reader.impl.utils/reader-conditional?","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",35,"^Q",["^J",[["^24"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",24,"^[","^X","^G",24,"^T",1,"^W","^X","^U",true,"^I",["^J",["^K",["^J",[["^24"]]]]],"^N","Return true if the value is the data representation of a reader conditional"],"~$newline?",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",57,"^F",16,"^G",57,"^H",24,"^W","^X","^I",["^J",["^K",["^J",[["~$c"]]]]],"^N","Checks whether the character is a newline"],"^6","~$cljs.tools.reader.impl.utils/newline?","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",24,"^Q",["^J",[["~$c"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",57,"^[","^X","^G",57,"^T",1,"^W","^X","^U",true,"^I",["^J",["^K",["^J",[["~$c"]]]]],"^N","Checks whether the character is a newline"],"~$namespace-keys",["^ ","^B",null,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",79,"^F",7,"^G",79,"^H",21,"^I",["^J",["^K",["^J",[["~$ns","~$keys"]]]]]],"^6","~$cljs.tools.reader.impl.utils/namespace-keys","^P",false,"^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^H",21,"^Q",["^J",[["^29","^2:"]]],"^R",null,"^S",["^J",[null,null]],"^F",1,"^E",79,"^G",79,"^T",2,"^U",true,"^I",["^J",["^K",["^J",[["^29","^2:"]]]]]],"~$ws-rx",["^ ","^6","~$cljs.tools.reader.impl.utils/ws-rx","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",41,"^F",1,"^G",41,"^H",11,"^C",["^ ","^D","/home/julien/.cljs/.aot_cache/1.10.329/EF19CBF/cljs/tools/reader/impl/utils.cljs","^E",41,"^F",6,"^G",41,"^H",11],"^W","^12"]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^4",["^L","~:else","~:splicing?","^M","~:form","^W"]],"~:order",["^2C","^2D","^M","^L","^W","^2B"]],"^N",null] \ No newline at end of file diff --git a/js/cljs/tools/reader/impl/utils.js b/js/cljs/tools/reader/impl/utils.js new file mode 100644 index 0000000..806d796 --- /dev/null +++ b/js/cljs/tools/reader/impl/utils.js @@ -0,0 +1,380 @@ +// Compiled by ClojureScript 1.10.329 {:static-fns true, :optimize-constants true, :target :nodejs} +goog.provide('cljs.tools.reader.impl.utils'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +goog.require('clojure.string'); +goog.require('goog.string'); +cljs.tools.reader.impl.utils.char$ = (function cljs$tools$reader$impl$utils$char(x){ +if((x == null)){ +return null; +} else { +return cljs.core.char$(x); +} +}); +cljs.tools.reader.impl.utils.ex_info_QMARK_ = (function cljs$tools$reader$impl$utils$ex_info_QMARK_(ex){ +return (ex instanceof cljs.core.ExceptionInfo); +}); + +/** +* @constructor + * @implements {cljs.core.IRecord} + * @implements {cljs.core.IEquiv} + * @implements {cljs.core.IHash} + * @implements {cljs.core.ICollection} + * @implements {cljs.core.ICounted} + * @implements {cljs.core.ISeqable} + * @implements {cljs.core.IMeta} + * @implements {cljs.core.ICloneable} + * @implements {cljs.core.IPrintWithWriter} + * @implements {cljs.core.IIterable} + * @implements {cljs.core.IWithMeta} + * @implements {cljs.core.IAssociative} + * @implements {cljs.core.IMap} + * @implements {cljs.core.ILookup} +*/ +cljs.tools.reader.impl.utils.ReaderConditional = (function (splicing_QMARK_,form,__meta,__extmap,__hash){ +this.splicing_QMARK_ = splicing_QMARK_; +this.form = form; +this.__meta = __meta; +this.__extmap = __extmap; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 2229667594; +this.cljs$lang$protocol_mask$partition1$ = 139264; +}); +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$ILookup$_lookup$arity$2 = (function (this__4190__auto__,k__4191__auto__){ +var self__ = this; +var this__4190__auto____$1 = this; +return this__4190__auto____$1.cljs$core$ILookup$_lookup$arity$3(null,k__4191__auto__,null); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$ILookup$_lookup$arity$3 = (function (this__4192__auto__,k1812,else__4193__auto__){ +var self__ = this; +var this__4192__auto____$1 = this; +var G__1816 = k1812; +var G__1816__$1 = (((G__1816 instanceof cljs.core.Keyword))?G__1816.fqn:null); +switch (G__1816__$1) { +case "splicing?": +return self__.splicing_QMARK_; + +break; +case "form": +return self__.form; + +break; +default: +return cljs.core.get.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k1812,else__4193__auto__); + +} +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (this__4204__auto__,writer__4205__auto__,opts__4206__auto__){ +var self__ = this; +var this__4204__auto____$1 = this; +var pr_pair__4207__auto__ = ((function (this__4204__auto____$1){ +return (function (keyval__4208__auto__){ +return cljs.core.pr_sequential_writer(writer__4205__auto__,cljs.core.pr_writer,""," ","",opts__4206__auto__,keyval__4208__auto__); +});})(this__4204__auto____$1)) +; +return cljs.core.pr_sequential_writer(writer__4205__auto__,pr_pair__4207__auto__,"#cljs.tools.reader.impl.utils.ReaderConditional{",", ","}",opts__4206__auto__,cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.cst$kw$splicing_QMARK_,self__.splicing_QMARK_],null)),(new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.cst$kw$form,self__.form],null))], null),self__.__extmap)); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IIterable$_iterator$arity$1 = (function (G__1811){ +var self__ = this; +var G__1811__$1 = this; +return (new cljs.core.RecordIter((0),G__1811__$1,2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$kw$splicing_QMARK_,cljs.core.cst$kw$form], null),(cljs.core.truth_(self__.__extmap)?cljs.core._iterator(self__.__extmap):cljs.core.nil_iter()))); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IMeta$_meta$arity$1 = (function (this__4188__auto__){ +var self__ = this; +var this__4188__auto____$1 = this; +return self__.__meta; +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$ICloneable$_clone$arity$1 = (function (this__4185__auto__){ +var self__ = this; +var this__4185__auto____$1 = this; +return (new cljs.tools.reader.impl.utils.ReaderConditional(self__.splicing_QMARK_,self__.form,self__.__meta,self__.__extmap,self__.__hash)); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$ICounted$_count$arity$1 = (function (this__4194__auto__){ +var self__ = this; +var this__4194__auto____$1 = this; +return (2 + cljs.core.count(self__.__extmap)); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IHash$_hash$arity$1 = (function (this__4186__auto__){ +var self__ = this; +var this__4186__auto____$1 = this; +var h__4048__auto__ = self__.__hash; +if(!((h__4048__auto__ == null))){ +return h__4048__auto__; +} else { +var h__4048__auto____$1 = (function (){var fexpr__1817 = ((function (h__4048__auto__,this__4186__auto____$1){ +return (function (coll__4187__auto__){ +return (-209062840 ^ cljs.core.hash_unordered_coll(coll__4187__auto__)); +});})(h__4048__auto__,this__4186__auto____$1)) +; +return fexpr__1817(this__4186__auto____$1); +})(); +self__.__hash = h__4048__auto____$1; + +return h__4048__auto____$1; +} +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IEquiv$_equiv$arity$2 = (function (this1813,other1814){ +var self__ = this; +var this1813__$1 = this; +return ((!((other1814 == null))) && ((this1813__$1.constructor === other1814.constructor)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this1813__$1.splicing_QMARK_,other1814.splicing_QMARK_)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this1813__$1.form,other1814.form)) && (cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(this1813__$1.__extmap,other1814.__extmap))); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IMap$_dissoc$arity$2 = (function (this__4199__auto__,k__4200__auto__){ +var self__ = this; +var this__4199__auto____$1 = this; +if(cljs.core.contains_QMARK_(new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$splicing_QMARK_,null,cljs.core.cst$kw$form,null], null), null),k__4200__auto__)){ +return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(cljs.core._with_meta(cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,this__4199__auto____$1),self__.__meta),k__4200__auto__); +} else { +return (new cljs.tools.reader.impl.utils.ReaderConditional(self__.splicing_QMARK_,self__.form,self__.__meta,cljs.core.not_empty(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(self__.__extmap,k__4200__auto__)),null)); +} +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IAssociative$_assoc$arity$3 = (function (this__4197__auto__,k__4198__auto__,G__1811){ +var self__ = this; +var this__4197__auto____$1 = this; +var pred__1818 = cljs.core.keyword_identical_QMARK_; +var expr__1819 = k__4198__auto__; +if(cljs.core.truth_((function (){var G__1821 = cljs.core.cst$kw$splicing_QMARK_; +var G__1822 = expr__1819; +return (pred__1818.cljs$core$IFn$_invoke$arity$2 ? pred__1818.cljs$core$IFn$_invoke$arity$2(G__1821,G__1822) : pred__1818.call(null,G__1821,G__1822)); +})())){ +return (new cljs.tools.reader.impl.utils.ReaderConditional(G__1811,self__.form,self__.__meta,self__.__extmap,null)); +} else { +if(cljs.core.truth_((function (){var G__1823 = cljs.core.cst$kw$form; +var G__1824 = expr__1819; +return (pred__1818.cljs$core$IFn$_invoke$arity$2 ? pred__1818.cljs$core$IFn$_invoke$arity$2(G__1823,G__1824) : pred__1818.call(null,G__1823,G__1824)); +})())){ +return (new cljs.tools.reader.impl.utils.ReaderConditional(self__.splicing_QMARK_,G__1811,self__.__meta,self__.__extmap,null)); +} else { +return (new cljs.tools.reader.impl.utils.ReaderConditional(self__.splicing_QMARK_,self__.form,self__.__meta,cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(self__.__extmap,k__4198__auto__,G__1811),null)); +} +} +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$ISeqable$_seq$arity$1 = (function (this__4202__auto__){ +var self__ = this; +var this__4202__auto____$1 = this; +return cljs.core.seq(cljs.core.concat.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(new cljs.core.MapEntry(cljs.core.cst$kw$splicing_QMARK_,self__.splicing_QMARK_,null)),(new cljs.core.MapEntry(cljs.core.cst$kw$form,self__.form,null))], null),self__.__extmap)); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (this__4189__auto__,G__1811){ +var self__ = this; +var this__4189__auto____$1 = this; +return (new cljs.tools.reader.impl.utils.ReaderConditional(self__.splicing_QMARK_,self__.form,G__1811,self__.__extmap,self__.__hash)); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$ICollection$_conj$arity$2 = (function (this__4195__auto__,entry__4196__auto__){ +var self__ = this; +var this__4195__auto____$1 = this; +if(cljs.core.vector_QMARK_(entry__4196__auto__)){ +return this__4195__auto____$1.cljs$core$IAssociative$_assoc$arity$3(null,cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry__4196__auto__,(0)),cljs.core._nth.cljs$core$IFn$_invoke$arity$2(entry__4196__auto__,(1))); +} else { +return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(cljs.core._conj,this__4195__auto____$1,entry__4196__auto__); +} +}); + +cljs.tools.reader.impl.utils.ReaderConditional.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$splicing_QMARK_,cljs.core.cst$sym$form], null); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.cljs$lang$type = true; + +cljs.tools.reader.impl.utils.ReaderConditional.cljs$lang$ctorPrSeq = (function (this__4227__auto__){ +return (new cljs.core.List(null,"cljs.tools.reader.impl.utils/ReaderConditional",null,(1),null)); +}); + +cljs.tools.reader.impl.utils.ReaderConditional.cljs$lang$ctorPrWriter = (function (this__4227__auto__,writer__4228__auto__){ +return cljs.core._write(writer__4228__auto__,"cljs.tools.reader.impl.utils/ReaderConditional"); +}); + +/** + * Positional factory function for cljs.tools.reader.impl.utils/ReaderConditional. + */ +cljs.tools.reader.impl.utils.__GT_ReaderConditional = (function cljs$tools$reader$impl$utils$__GT_ReaderConditional(splicing_QMARK_,form){ +return (new cljs.tools.reader.impl.utils.ReaderConditional(splicing_QMARK_,form,null,null,null)); +}); + +/** + * Factory function for cljs.tools.reader.impl.utils/ReaderConditional, taking a map of keywords to field values. + */ +cljs.tools.reader.impl.utils.map__GT_ReaderConditional = (function cljs$tools$reader$impl$utils$map__GT_ReaderConditional(G__1815){ +var extmap__4223__auto__ = (function (){var G__1825 = cljs.core.dissoc.cljs$core$IFn$_invoke$arity$variadic(G__1815,cljs.core.cst$kw$splicing_QMARK_,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.cst$kw$form], 0)); +if(cljs.core.record_QMARK_(G__1815)){ +return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,G__1825); +} else { +return G__1825; +} +})(); +return (new cljs.tools.reader.impl.utils.ReaderConditional(cljs.core.cst$kw$splicing_QMARK_.cljs$core$IFn$_invoke$arity$1(G__1815),cljs.core.cst$kw$form.cljs$core$IFn$_invoke$arity$1(G__1815),null,cljs.core.not_empty(extmap__4223__auto__),null)); +}); + +/** + * Return true if the value is the data representation of a reader conditional + */ +cljs.tools.reader.impl.utils.reader_conditional_QMARK_ = (function cljs$tools$reader$impl$utils$reader_conditional_QMARK_(value){ +return (value instanceof cljs.tools.reader.impl.utils.ReaderConditional); +}); +/** + * Construct a data representation of a reader conditional. + * If true, splicing? indicates read-cond-splicing. + */ +cljs.tools.reader.impl.utils.reader_conditional = (function cljs$tools$reader$impl$utils$reader_conditional(form,splicing_QMARK_){ +return (new cljs.tools.reader.impl.utils.ReaderConditional(splicing_QMARK_,form,null,null,null)); +}); +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IPrintWithWriter$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.impl.utils.ReaderConditional.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = (function (coll,writer,opts){ +var coll__$1 = this; +cljs.core._write(writer,["#?",cljs.core.str.cljs$core$IFn$_invoke$arity$1((cljs.core.truth_(cljs.core.cst$kw$splicing_QMARK_.cljs$core$IFn$_invoke$arity$1(coll__$1))?"@":null))].join('')); + +return cljs.core.pr_writer(cljs.core.cst$kw$form.cljs$core$IFn$_invoke$arity$1(coll__$1),writer,opts); +}); +cljs.tools.reader.impl.utils.ws_rx = /[\s]/; +/** + * Checks whether a given character is whitespace + */ +cljs.tools.reader.impl.utils.whitespace_QMARK_ = (function cljs$tools$reader$impl$utils$whitespace_QMARK_(ch){ +if((ch == null)){ +return null; +} else { +if((ch === ",")){ +return true; +} else { +return cljs.tools.reader.impl.utils.ws_rx.test(ch); +} +} +}); +/** + * Checks whether a given character is numeric + */ +cljs.tools.reader.impl.utils.numeric_QMARK_ = (function cljs$tools$reader$impl$utils$numeric_QMARK_(ch){ +if((ch == null)){ +return null; +} else { +return goog.string.isNumeric(ch); +} +}); +/** + * Checks whether the character is a newline + */ +cljs.tools.reader.impl.utils.newline_QMARK_ = (function cljs$tools$reader$impl$utils$newline_QMARK_(c){ +return ((("\n" === c)) || (("\n" === c)) || ((c == null))); +}); +/** + * Resolves syntactical sugar in metadata + */ +cljs.tools.reader.impl.utils.desugar_meta = (function cljs$tools$reader$impl$utils$desugar_meta(f){ +if((f instanceof cljs.core.Keyword)){ +return cljs.core.PersistentArrayMap.createAsIfByAssoc([f,true]); +} else { +if((f instanceof cljs.core.Symbol)){ +return new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,f], null); +} else { +if(typeof f === 'string'){ +return new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,f], null); +} else { +return f; + +} +} +} +}); +cljs.tools.reader.impl.utils.last_id = cljs.core.atom.cljs$core$IFn$_invoke$arity$1((0)); +cljs.tools.reader.impl.utils.next_id = (function cljs$tools$reader$impl$utils$next_id(){ +return cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$2(cljs.tools.reader.impl.utils.last_id,cljs.core.inc); +}); +cljs.tools.reader.impl.utils.namespace_keys = (function cljs$tools$reader$impl$utils$namespace_keys(ns,keys){ +var iter__4311__auto__ = (function cljs$tools$reader$impl$utils$namespace_keys_$_iter__1827(s__1828){ +return (new cljs.core.LazySeq(null,(function (){ +var s__1828__$1 = s__1828; +while(true){ +var temp__5457__auto__ = cljs.core.seq(s__1828__$1); +if(temp__5457__auto__){ +var s__1828__$2 = temp__5457__auto__; +if(cljs.core.chunked_seq_QMARK_(s__1828__$2)){ +var c__4309__auto__ = cljs.core.chunk_first(s__1828__$2); +var size__4310__auto__ = cljs.core.count(c__4309__auto__); +var b__1830 = cljs.core.chunk_buffer(size__4310__auto__); +if((function (){var i__1829 = (0); +while(true){ +if((i__1829 < size__4310__auto__)){ +var key = cljs.core._nth.cljs$core$IFn$_invoke$arity$2(c__4309__auto__,i__1829); +cljs.core.chunk_append(b__1830,(((((key instanceof cljs.core.Symbol)) || ((key instanceof cljs.core.Keyword))))?(function (){var vec__1831 = (function (){var fexpr__1834 = cljs.core.juxt.cljs$core$IFn$_invoke$arity$2(cljs.core.namespace,cljs.core.name); +return (fexpr__1834.cljs$core$IFn$_invoke$arity$1 ? fexpr__1834.cljs$core$IFn$_invoke$arity$1(key) : fexpr__1834.call(null,key)); +})(); +var key_ns = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1831,(0),null); +var key_name = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1831,(1),null); +var __GT_key = (((key instanceof cljs.core.Symbol))?cljs.core.symbol:cljs.core.keyword); +if((key_ns == null)){ +return (__GT_key.cljs$core$IFn$_invoke$arity$2 ? __GT_key.cljs$core$IFn$_invoke$arity$2(ns,key_name) : __GT_key.call(null,ns,key_name)); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2("_",key_ns)){ +return (__GT_key.cljs$core$IFn$_invoke$arity$1 ? __GT_key.cljs$core$IFn$_invoke$arity$1(key_name) : __GT_key.call(null,key_name)); +} else { +return key; + +} +} +})():key)); + +var G__1839 = (i__1829 + (1)); +i__1829 = G__1839; +continue; +} else { +return true; +} +break; +} +})()){ +return cljs.core.chunk_cons(cljs.core.chunk(b__1830),cljs$tools$reader$impl$utils$namespace_keys_$_iter__1827(cljs.core.chunk_rest(s__1828__$2))); +} else { +return cljs.core.chunk_cons(cljs.core.chunk(b__1830),null); +} +} else { +var key = cljs.core.first(s__1828__$2); +return cljs.core.cons((((((key instanceof cljs.core.Symbol)) || ((key instanceof cljs.core.Keyword))))?(function (){var vec__1835 = (function (){var fexpr__1838 = cljs.core.juxt.cljs$core$IFn$_invoke$arity$2(cljs.core.namespace,cljs.core.name); +return (fexpr__1838.cljs$core$IFn$_invoke$arity$1 ? fexpr__1838.cljs$core$IFn$_invoke$arity$1(key) : fexpr__1838.call(null,key)); +})(); +var key_ns = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1835,(0),null); +var key_name = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1835,(1),null); +var __GT_key = (((key instanceof cljs.core.Symbol))?cljs.core.symbol:cljs.core.keyword); +if((key_ns == null)){ +return (__GT_key.cljs$core$IFn$_invoke$arity$2 ? __GT_key.cljs$core$IFn$_invoke$arity$2(ns,key_name) : __GT_key.call(null,ns,key_name)); +} else { +if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2("_",key_ns)){ +return (__GT_key.cljs$core$IFn$_invoke$arity$1 ? __GT_key.cljs$core$IFn$_invoke$arity$1(key_name) : __GT_key.call(null,key_name)); +} else { +return key; + +} +} +})():key),cljs$tools$reader$impl$utils$namespace_keys_$_iter__1827(cljs.core.rest(s__1828__$2))); +} +} else { +return null; +} +break; +} +}),null,null)); +}); +return iter__4311__auto__(keys); +}); +cljs.tools.reader.impl.utils.second_SINGLEQUOTE_ = (function cljs$tools$reader$impl$utils$second_SINGLEQUOTE_(p__1840){ +var vec__1841 = p__1840; +var a = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1841,(0),null); +var b = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__1841,(1),null); +if(cljs.core.truth_(a)){ +return null; +} else { +return b; +} +}); diff --git a/js/cljs/tools/reader/reader_types.cljs b/js/cljs/tools/reader/reader_types.cljs new file mode 100644 index 0000000..ec51be2 --- /dev/null +++ b/js/cljs/tools/reader/reader_types.cljs @@ -0,0 +1,283 @@ +;; Copyright (c) Nicola Mometto, Rich Hickey & contributors. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "Protocols and default Reader types implementation" + :author "Bronsa"} + cljs.tools.reader.reader-types + (:refer-clojure :exclude [char read-line]) + (:require [cljs.tools.reader.impl.utils :refer [char whitespace? newline?]] + [goog.string]) + (:import goog.string.StringBuffer)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; reader protocols +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defprotocol Reader + (read-char [reader] + "Returns the next char from the Reader, nil if the end of stream has been reached") + (peek-char [reader] + "Returns the next char from the Reader without removing it from the reader stream")) + +(defprotocol IPushbackReader + (unread [reader ch] + "Pushes back a single character on to the stream")) + +(defprotocol IndexingReader + (get-line-number [reader] + "Returns the line number of the next character to be read from the stream") + (get-column-number [reader] + "Returns the column number of the next character to be read from the stream") + (get-file-name [reader] + "Returns the file name the reader is reading from, or nil")) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; reader deftypes +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(deftype StringReader + [s s-len ^:mutable s-pos] + Reader + (read-char [reader] + (when (> s-len s-pos) + (let [r (.charAt s s-pos)] + (set! s-pos (inc s-pos)) + r))) + (peek-char [reader] + (when (> s-len s-pos) + (.charAt s s-pos)))) + +(deftype NodeReadableReader [readable ^:mutable buf] + Reader + (read-char [reader] + (if buf + (let [c (aget buf 0)] + (set! buf nil) + (char c)) + (let [c (str (.read readable 1))] + (when c + (char c))))) + (peek-char [reader] + (when-not buf + (set! buf (str (.read readable 1)))) + (when buf + (char (aget buf 0))))) + +(deftype PushbackReader + [^not-native rdr buf buf-len ^:mutable buf-pos] + Reader + (read-char [reader] + (let [c (if (< buf-pos buf-len) + (aget buf buf-pos) + (read-char rdr))] + (when (< buf-pos buf-len) + (set! buf-pos (inc buf-pos))) + (char c))) + (peek-char [reader] + (let [c (if (< buf-pos buf-len) + (aget buf buf-pos) + (peek-char rdr))] + (char c))) + IPushbackReader + (unread [reader ch] + (when ch + (if (zero? buf-pos) (throw (js/Error. "Pushback buffer is full"))) + (set! buf-pos (dec buf-pos)) + (aset buf buf-pos ch)))) + +(defn- normalize-newline [^not-native rdr ch] + (if (identical? \return ch) + (let [c (peek-char rdr)] + (when (or (identical? \formfeed c) + (identical? \newline c)) + (read-char rdr)) + \newline) + ch)) + +(deftype IndexingPushbackReader + [^not-native rdr ^:mutable line ^:mutable column + ^:mutable line-start? ^:mutable prev + ^:mutable prev-column file-name] + Reader + (read-char [reader] + (when-let [ch (read-char rdr)] + (let [ch (normalize-newline rdr ch)] + (set! prev line-start?) + (set! line-start? (newline? ch)) + (when line-start? + (set! prev-column column) + (set! column 0) + (set! line (inc line))) + (set! column (inc column)) + ch))) + + (peek-char [reader] + (peek-char rdr)) + + IPushbackReader + (unread [reader ch] + (if line-start? + (do (set! line (dec line)) + (set! column prev-column)) + (set! column (dec column))) + (set! line-start? prev) + (unread rdr ch)) + + IndexingReader + (get-line-number [reader] (int line)) + (get-column-number [reader] (int column)) + (get-file-name [reader] file-name)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Source Logging support +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defn merge-meta + "Returns an object of the same type and value as `obj`, with its +metadata merged over `m`." + [obj m] + (let [orig-meta (meta obj)] + (with-meta obj (merge m (dissoc orig-meta :source))))) + +(defn- peek-source-log + "Returns a string containing the contents of the top most source +logging frame." + [frames] + (subs (str (:buffer frames)) (first (:offset frames)))) + +(defn- log-source-char + "Logs `char` to all currently active source logging frames." + [frames char] + (when-let [buffer (:buffer frames)] + (.append buffer char))) + +(defn- drop-last-logged-char + "Removes the last logged character from all currently active source +logging frames. Called when pushing a character back." + [frames] + (when-let [buffer (:buffer frames)] + (.set buffer (subs (str buffer) 0 (dec (.getLength buffer)))))) + +(deftype SourceLoggingPushbackReader + [^not-native rdr ^:mutable line ^:mutable column + ^:mutable line-start? ^:mutable prev + ^:mutable prev-column file-name frames] + Reader + (read-char [reader] + (when-let [ch (read-char rdr)] + (let [ch (normalize-newline rdr ch)] + (set! prev line-start?) + (set! line-start? (newline? ch)) + (when line-start? + (set! prev-column column) + (set! column 0) + (set! line (inc line))) + (set! column (inc column)) + (log-source-char @frames ch) + ch))) + + (peek-char [reader] + (peek-char rdr)) + + IPushbackReader + (unread [reader ch] + (if line-start? + (do (set! line (dec line)) + (set! column prev-column)) + (set! column (dec column))) + (set! line-start? prev) + (when ch + (drop-last-logged-char @frames)) + (unread rdr ch)) + + IndexingReader + (get-line-number [reader] (int line)) + (get-column-number [reader] (int column)) + (get-file-name [reader] file-name)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Public API +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; fast check for provided implementations +(defn indexing-reader? + "Returns true if the reader satisfies IndexingReader" + [rdr] + (implements? IndexingReader rdr)) + +(defn string-reader + "Creates a StringReader from a given string" + ([s] + (StringReader. s (count s) 0))) + +(defn string-push-back-reader + "Creates a PushbackReader from a given string" + ([s] + (string-push-back-reader s 1)) + ([s buf-len] + (PushbackReader. (string-reader s) (object-array buf-len) buf-len buf-len))) + +(defn node-readable-push-back-reader [readable] + (PushbackReader. (NodeReadableReader. readable nil) (object-array 1) 1 1)) + +(defn indexing-push-back-reader + "Creates an IndexingPushbackReader from a given string or PushbackReader" + ([s-or-rdr] + (indexing-push-back-reader s-or-rdr 1)) + ([s-or-rdr buf-len] + (indexing-push-back-reader s-or-rdr buf-len nil)) + ([s-or-rdr buf-len file-name] + (IndexingPushbackReader. + (if (string? s-or-rdr) (string-push-back-reader s-or-rdr buf-len) s-or-rdr) 1 1 true nil 0 file-name))) + +(defn source-logging-push-back-reader + "Creates a SourceLoggingPushbackReader from a given string or PushbackReader" + ([s-or-rdr] + (source-logging-push-back-reader s-or-rdr 1)) + ([s-or-rdr buf-len] + (source-logging-push-back-reader s-or-rdr buf-len nil)) + ([s-or-rdr buf-len file-name] + (SourceLoggingPushbackReader. + (if (string? s-or-rdr) (string-push-back-reader s-or-rdr buf-len) s-or-rdr) + 1 + 1 + true + nil + 0 + file-name + (atom {:buffer (StringBuffer.) :offset '(0)})))) + +(defn read-line + "Reads a line from the reader or from *in* if no reader is specified" + ([^not-native rdr] + (loop [c (read-char rdr) s (StringBuffer.)] + (if (newline? c) + (str s) + (recur (read-char rdr) (.append s c)))))) + +(defn ^boolean source-logging-reader? + [rdr] + (instance? SourceLoggingPushbackReader rdr)) + +(defn ^boolean line-start? + "Returns true if rdr is an IndexingReader and the current char starts a new line" + [^not-native rdr] + (when (indexing-reader? rdr) + (== 1 (get-column-number rdr)))) + +(defn log-source* + [reader f] + (let [buffer (:buffer @(.-frames reader))] + (try + (swap! (.-frames reader) update-in [:offset] conj (.getLength buffer)) + (let [ret (f)] + (if (implements? IMeta ret) + (merge-meta ret {:source (peek-source-log @ (.-frames reader))}) + ret)) + (finally + (swap! (.-frames reader) update-in [:offset] rest))))) + diff --git a/js/cljs/tools/reader/reader_types.cljs.cache.json b/js/cljs/tools/reader/reader_types.cljs.cache.json new file mode 100644 index 0000000..4a7bfd0 --- /dev/null +++ b/js/cljs/tools/reader/reader_types.cljs.cache.json @@ -0,0 +1 @@ +["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$Error",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",["~$char","~$read-line"]],"~:name","~$cljs.tools.reader.reader-types","~:imports",["^ ","~$StringBuffer","~$goog.string.StringBuffer"],"~:requires",["^ ","~$cljs.tools.reader.impl.utils","^?","~$goog.string","^@","^<","^="],"~:cljs.spec/speced-vars",[],"~:uses",["^ ","~$whitespace?","^?","^7","^?","~$newline?","^?"],"~:defs",["^ ","~$indexing-push-back-reader",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:file","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","~:line",227,"~:column",7,"~:end-line",227,"~:end-column",32,"~:arglists",["~#list",["~$quote",["^O",[["~$s-or-rdr"],["^Q","~$buf-len"],["^Q","^R","~$file-name"]]]]],"~:doc","Creates an IndexingPushbackReader from a given string or PushbackReader","~:top-fn",["^ ","~:variadic",false,"~:max-fixed-arity",3,"~:method-params",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^N",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"~:arglists-meta",["^O",[null,null,null]]]],"^9","~$cljs.tools.reader.reader-types/indexing-push-back-reader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",32,"^U",["^ ","^V",false,"^W",3,"^X",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^N",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^Y",["^O",[null,null,null]]],"^X",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"~:protocol-impl",null,"^Y",["^O",[null,null,null]],"^K",1,"^J",227,"^L",227,"^W",3,"~:fn-var",true,"^N",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^T","Creates an IndexingPushbackReader from a given string or PushbackReader"],"~$log-source*",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",272,"^K",7,"^L",272,"^M",18,"^N",["^O",["^P",["^O",[["~$reader","~$f"]]]]]],"^9","~$cljs.tools.reader.reader-types/log-source*","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",18,"^X",["^O",[["^12","~$f"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",272,"^L",272,"^W",2,"^10",true,"^N",["^O",["^P",["^O",[["^12","~$f"]]]]]],"~$merge-meta",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",139,"^K",7,"^L",139,"^M",17,"^N",["^O",["^P",["^O",[["~$obj","~$m"]]]]],"^T","Returns an object of the same type and value as `obj`, with its\nmetadata merged over `m`."],"^9","~$cljs.tools.reader.reader-types/merge-meta","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",17,"^X",["^O",[["^15","~$m"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",139,"^L",139,"^W",2,"^10",true,"^N",["^O",["^P",["^O",[["^15","~$m"]]]]],"^T","Returns an object of the same type and value as `obj`, with its\nmetadata merged over `m`."],"~$PushbackReader",["^ ","~:num-fields",4,"~:protocols",["^6",["~$cljs.tools.reader.reader-types/Reader","~$cljs.tools.reader.reader-types/IPushbackReader"]],"^9","~$cljs.tools.reader.reader-types/PushbackReader","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",24,"~:type",true,"^K",10,"^J",71,"~:record",false,"^L",71,"~:tag","~$function","~:skip-protocol-flag",null],"~$->StringReader",["^ ","^G",null,"^H",["^ ","^19",["^6",["^1:"]],"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",22,"^K",10,"~:factory","~:positional","^J",43,"^L",43,"^N",["^O",["^P",["^O",[["~$s","~$s-len","~$s-pos"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/StringReader."],"^19",["^6",["^1:"]],"^9","~$cljs.tools.reader.reader-types/->StringReader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",22,"^X",["^O",[["~$s","^1E","^1F"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^1C","^1D","^J",43,"^L",43,"^W",3,"^10",true,"^N",["^O",["^P",["^O",[["~$s","^1E","^1F"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/StringReader."],"~$normalize-newline",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",93,"^K",8,"^L",93,"^M",25,"~:private",true,"^N",["^O",["^P",["^O",[["~$rdr","~$ch"]]]]]],"^1I",true,"^9","~$cljs.tools.reader.reader-types/normalize-newline","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",25,"^X",["^O",[["^1J","^1K"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",93,"^L",93,"^W",2,"^10",true,"^N",["^O",["^P",["^O",[["^1J","^1K"]]]]]],"~$peek-source-log",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",146,"^K",8,"^L",146,"^M",23,"^1I",true,"^N",["^O",["^P",["^O",[["~$frames"]]]]],"^T","Returns a string containing the contents of the top most source\nlogging frame."],"^1I",true,"^9","~$cljs.tools.reader.reader-types/peek-source-log","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",23,"^X",["^O",[["^1N"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",146,"^L",146,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^1N"]]]]],"^T","Returns a string containing the contents of the top most source\nlogging frame."],"~$IndexingPushbackReader",["^ ","^18",7,"^19",["^6",["~$cljs.tools.reader.reader-types/IndexingReader","^1:","^1;"]],"^9","~$cljs.tools.reader.reader-types/IndexingPushbackReader","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",32,"^1=",true,"^K",10,"^J",102,"^1>",false,"^L",102,"^1?","^1@","^1A",null],"~$StringReader",["^ ","^18",3,"^19",["^6",["^1:"]],"^9","~$cljs.tools.reader.reader-types/StringReader","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",22,"^1=",true,"^K",10,"^J",43,"^1>",false,"^L",43,"^1?","^1@","^1A",null],"~$Reader",["^ ","^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",21,"^K",14,"^L",21,"^M",20,"^T",null,"~:protocol-symbol",true,"~:jsdoc",["^O",["@interface"]],"~:protocol-info",["^ ","~:methods",["^ ","~$read-char",[["^12"]],"~$peek-char",[["^12"]]]]],"^1V",true,"^9","^1:","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",20,"^K",1,"^J",21,"^1X",["^ ","^1Y",["^ ","^1Z",[["^12"]],"^1[",[["^12"]]]],"~:info",null,"^L",21,"^1?","~$any","~:impls",["^6",["~$cljs.tools.reader.reader-types/SourceLoggingPushbackReader","^1R","~$cljs.tools.reader.reader-types/NodeReadableReader","^1T","^1<"]],"^T",null,"^1W",["^O",["@interface"]]],"~$source-logging-push-back-reader",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",237,"^K",7,"^L",237,"^M",38,"^N",["^O",["^P",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]]]],"^T","Creates a SourceLoggingPushbackReader from a given string or PushbackReader","^U",["^ ","^V",false,"^W",3,"^X",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^N",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^Y",["^O",[null,null,null]]]],"^9","~$cljs.tools.reader.reader-types/source-logging-push-back-reader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",38,"^U",["^ ","^V",false,"^W",3,"^X",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^N",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^Y",["^O",[null,null,null]]],"^X",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^[",null,"^Y",["^O",[null,null,null]],"^K",1,"^J",237,"^L",237,"^W",3,"^10",true,"^N",["^O",[["^Q"],["^Q","^R"],["^Q","^R","^S"]]],"^T","Creates a SourceLoggingPushbackReader from a given string or PushbackReader"],"~$unread",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",28,"^K",4,"^L",28,"^M",10,"~:protocol","^1;","^T","Pushes back a single character on to the stream","^N",["^O",["^P",["^O",[["^12","^1K"]]]]]],"^28","^1;","^9","~$cljs.tools.reader.reader-types/unread","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",10,"^X",["^O",[["^12","^1K"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",27,"^L",28,"^W",2,"^10",true,"^N",["^O",["^P",["^O",[["^12","^1K"]]]]],"^T","Pushes back a single character on to the stream"],"^1[",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",24,"^K",4,"^L",24,"^M",13,"^28","^1:","^T","Returns the next char from the Reader without removing it from the reader stream","^N",["^O",["^P",["^O",[["^12"]]]]]],"^28","^1:","^9","~$cljs.tools.reader.reader-types/peek-char","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",13,"^X",["^O",[["^12"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",21,"^L",24,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^12"]]]]],"^T","Returns the next char from the Reader without removing it from the reader stream"],"~$IPushbackReader",["^ ","^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",27,"^K",14,"^L",27,"^M",29,"^T",null,"^1V",true,"^1W",["^O",["@interface"]],"^1X",["^ ","^1Y",["^ ","^27",[["^12","^1K"]]]]],"^1V",true,"^9","^1;","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",29,"^K",1,"^J",27,"^1X",["^ ","^1Y",["^ ","^27",[["^12","^1K"]]]],"^20",null,"^L",27,"^1?","^21","^22",["^6",["^23","^1R","^1<"]],"^T",null,"^1W",["^O",["@interface"]]],"~$->NodeReadableReader",["^ ","^G",null,"^H",["^ ","^19",["^6",["^1:"]],"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",28,"^K",10,"^1C","^1D","^J",55,"^L",55,"^N",["^O",["^P",["^O",[["~$readable","~$buf"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/NodeReadableReader."],"^19",["^6",["^1:"]],"^9","~$cljs.tools.reader.reader-types/->NodeReadableReader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",28,"^X",["^O",[["^2=","^2>"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^1C","^1D","^J",55,"^L",55,"^W",2,"^10",true,"^N",["^O",["^P",["^O",[["^2=","^2>"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/NodeReadableReader."],"~$indexing-reader?",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",207,"^K",7,"^L",207,"^M",23,"^N",["^O",["^P",["^O",[["^1J"]]]]],"^T","Returns true if the reader satisfies IndexingReader"],"^9","~$cljs.tools.reader.reader-types/indexing-reader?","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",23,"^X",["^O",[["^1J"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",207,"^L",207,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^1J"]]]]],"^T","Returns true if the reader satisfies IndexingReader"],"~$string-reader",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",212,"^K",7,"^L",212,"^M",20,"^N",["^O",["^P",["^O",[["~$s"]]]]],"^T","Creates a StringReader from a given string"],"^9","~$cljs.tools.reader.reader-types/string-reader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",20,"^X",["^O",[["~$s"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",212,"^L",212,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["~$s"]]]]],"^T","Creates a StringReader from a given string"],"^1Z",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",22,"^K",4,"^L",22,"^M",13,"^28","^1:","^T","Returns the next char from the Reader, nil if the end of stream has been reached","^N",["^O",["^P",["^O",[["^12"]]]]]],"^28","^1:","^9","~$cljs.tools.reader.reader-types/read-char","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",13,"^X",["^O",[["^12"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",21,"^L",22,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^12"]]]]],"^T","Returns the next char from the Reader, nil if the end of stream has been reached"],"~$get-column-number",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",34,"^K",4,"^L",34,"^M",21,"^28","^1Q","^T","Returns the column number of the next character to be read from the stream","^N",["^O",["^P",["^O",[["^12"]]]]]],"^28","^1Q","^9","~$cljs.tools.reader.reader-types/get-column-number","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",21,"^X",["^O",[["^12"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",31,"^L",34,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^12"]]]]],"^T","Returns the column number of the next character to be read from the stream"],"~$get-file-name",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",36,"^K",4,"^L",36,"^M",17,"^28","^1Q","^T","Returns the file name the reader is reading from, or nil","^N",["^O",["^P",["^O",[["^12"]]]]]],"^28","^1Q","^9","~$cljs.tools.reader.reader-types/get-file-name","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",17,"^X",["^O",[["^12"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",31,"^L",36,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^12"]]]]],"^T","Returns the file name the reader is reading from, or nil"],"^8",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",254,"^K",7,"^L",254,"^M",16,"^N",["^O",["^P",["^O",[["^1J"]]]]],"^T","Reads a line from the reader or from *in* if no reader is specified"],"^9","~$cljs.tools.reader.reader-types/read-line","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",16,"^X",["^O",[["^1J"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",254,"^L",254,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^1J"]]]]],"^T","Reads a line from the reader or from *in* if no reader is specified"],"~$->PushbackReader",["^ ","^G",null,"^H",["^ ","^19",["^6",["^1:","^1;"]],"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",24,"^K",10,"^1C","^1D","^J",71,"^L",71,"^N",["^O",["^P",["^O",[["^1J","^2>","^R","~$buf-pos"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/PushbackReader."],"^19",["^6",["^1:","^1;"]],"^9","~$cljs.tools.reader.reader-types/->PushbackReader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",24,"^X",["^O",[["^1J","^2>","^R","^2K"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^1C","^1D","^J",71,"^L",71,"^W",4,"^10",true,"^N",["^O",["^P",["^O",[["^1J","^2>","^R","^2K"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/PushbackReader."],"~$log-source-char",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",152,"^K",8,"^L",152,"^M",23,"^1I",true,"^N",["^O",["^P",["^O",[["^1N","^7"]]]]],"^T","Logs `char` to all currently active source logging frames."],"^1I",true,"^9","~$cljs.tools.reader.reader-types/log-source-char","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",23,"^X",["^O",[["^1N","^7"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",152,"^L",152,"^W",2,"^10",true,"^N",["^O",["^P",["^O",[["^1N","^7"]]]]],"^T","Logs `char` to all currently active source logging frames."],"~$string-push-back-reader",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",217,"^K",7,"^L",217,"^M",30,"^N",["^O",["^P",["^O",[["~$s"],["~$s","^R"]]]]],"^T","Creates a PushbackReader from a given string","^U",["^ ","^V",false,"^W",2,"^X",["^O",[["~$s"],["~$s","^R"]]],"^N",["^O",[["~$s"],["~$s","^R"]]],"^Y",["^O",[null,null]]]],"^9","~$cljs.tools.reader.reader-types/string-push-back-reader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",30,"^U",["^ ","^V",false,"^W",2,"^X",["^O",[["~$s"],["~$s","^R"]]],"^N",["^O",[["~$s"],["~$s","^R"]]],"^Y",["^O",[null,null]]],"^X",["^O",[["~$s"],["~$s","^R"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",217,"^L",217,"^W",2,"^10",true,"^N",["^O",[["~$s"],["~$s","^R"]]],"^T","Creates a PushbackReader from a given string"],"~$drop-last-logged-char",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",158,"^K",8,"^L",158,"^M",29,"^1I",true,"^N",["^O",["^P",["^O",[["^1N"]]]]],"^T","Removes the last logged character from all currently active source\nlogging frames. Called when pushing a character back."],"^1I",true,"^9","~$cljs.tools.reader.reader-types/drop-last-logged-char","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",29,"^X",["^O",[["^1N"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",158,"^L",158,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^1N"]]]]],"^T","Removes the last logged character from all currently active source\nlogging frames. Called when pushing a character back."],"~$->SourceLoggingPushbackReader",["^ ","^G",null,"^H",["^ ","^19",["^6",["^1Q","^1:","^1;"]],"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",37,"^K",10,"^1C","^1D","^J",165,"^L",165,"^N",["^O",["^P",["^O",[["^1J","~$line","~$column","~$line-start?","~$prev","~$prev-column","^S","^1N"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/SourceLoggingPushbackReader."],"^19",["^6",["^1Q","^1:","^1;"]],"^9","~$cljs.tools.reader.reader-types/->SourceLoggingPushbackReader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",37,"^X",["^O",[["^1J","^2T","^2U","^2V","^2W","^2X","^S","^1N"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^1C","^1D","^J",165,"^L",165,"^W",8,"^10",true,"^N",["^O",["^P",["^O",[["^1J","^2T","^2U","^2V","^2W","^2X","^S","^1N"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/SourceLoggingPushbackReader."],"^2V",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",266,"^K",16,"^L",266,"^M",27,"^1?","~$boolean","^N",["^O",["^P",["^O",[["^1J"]]]]],"^T","Returns true if rdr is an IndexingReader and the current char starts a new line"],"^9","~$cljs.tools.reader.reader-types/line-start?","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",27,"^X",["^O",[["^1J"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",266,"~:ret-tag","^2Z","^L",266,"^W",1,"^1?","^2Z","^10",true,"^N",["^O",["^P",["^O",[["^1J"]]]]],"^T","Returns true if rdr is an IndexingReader and the current char starts a new line"],"~$source-logging-reader?",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",262,"^K",16,"^L",262,"^M",38,"^1?","^2Z","^N",["^O",["^P",["^O",[["^1J"]]]]]],"^9","~$cljs.tools.reader.reader-types/source-logging-reader?","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",38,"^X",["^O",[["^1J"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",262,"^30","^2Z","^L",262,"^W",1,"^1?","^2Z","^10",true,"^N",["^O",["^P",["^O",[["^1J"]]]]]],"~$IndexingReader",["^ ","^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",31,"^K",14,"^L",31,"^M",28,"^T",null,"^1V",true,"^1W",["^O",["@interface"]],"^1X",["^ ","^1Y",["^ ","~$get-line-number",[["^12"]],"^2E",[["^12"]],"^2G",[["^12"]]]]],"^1V",true,"^9","^1Q","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",28,"^K",1,"^J",31,"^1X",["^ ","^1Y",["^ ","^34",[["^12"]],"^2E",[["^12"]],"^2G",[["^12"]]]],"^20",null,"^L",31,"^1?","^21","^22",["^6",["^23","^1R"]],"^T",null,"^1W",["^O",["@interface"]]],"~$node-readable-push-back-reader",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",224,"^K",7,"^L",224,"^M",37,"^N",["^O",["^P",["^O",[["^2="]]]]]],"^9","~$cljs.tools.reader.reader-types/node-readable-push-back-reader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",37,"^X",["^O",[["^2="]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",224,"^L",224,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^2="]]]]]],"~$SourceLoggingPushbackReader",["^ ","^18",8,"^19",["^6",["^1Q","^1:","^1;"]],"^9","^23","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",37,"^1=",true,"^K",10,"^J",165,"^1>",false,"^L",165,"^1?","^1@","^1A",null],"^34",["^ ","^G",null,"^H",["^ ","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^J",32,"^K",4,"^L",32,"^M",19,"^28","^1Q","^T","Returns the line number of the next character to be read from the stream","^N",["^O",["^P",["^O",[["^12"]]]]]],"^28","^1Q","^9","~$cljs.tools.reader.reader-types/get-line-number","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",19,"^X",["^O",[["^12"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^J",31,"^L",32,"^W",1,"^10",true,"^N",["^O",["^P",["^O",[["^12"]]]]],"^T","Returns the line number of the next character to be read from the stream"],"~$NodeReadableReader",["^ ","^18",2,"^19",["^6",["^1:"]],"^9","^24","^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",28,"^1=",true,"^K",10,"^J",55,"^1>",false,"^L",55,"^1?","^1@","^1A",null],"~$->IndexingPushbackReader",["^ ","^G",null,"^H",["^ ","^19",["^6",["^1Q","^1:","^1;"]],"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",32,"^K",10,"^1C","^1D","^J",102,"^L",102,"^N",["^O",["^P",["^O",[["^1J","^2T","^2U","^2V","^2W","^2X","^S"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/IndexingPushbackReader."],"^19",["^6",["^1Q","^1:","^1;"]],"^9","~$cljs.tools.reader.reader-types/->IndexingPushbackReader","^V",false,"^I","/home/julien/.cljs/.aot_cache/1.10.329/6A8E61E/cljs/tools/reader/reader_types.cljs","^M",32,"^X",["^O",[["^1J","^2T","^2U","^2V","^2W","^2X","^S"]]],"^[",null,"^Y",["^O",[null,null]],"^K",1,"^1C","^1D","^J",102,"^L",102,"^W",7,"^10",true,"^N",["^O",["^P",["^O",[["^1J","^2T","^2U","^2V","^2W","^2X","^S"]]]]],"^1A",null,"^T","Positional factory function for cljs.tools.reader.reader-types/IndexingPushbackReader."]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^6",["^1F","^2X","~:offset","^1J","^2>","~:source","^2=","^1N","~$not-native","~$s","^2U","^2K","^1?","~:mutable","^2V","^2T","^1E","^S","^2W","^R","~:buffer"]],"~:order",["~$s","^1E","^1F","^3C","^2=","^2>","^1J","^1?","^3B","^R","^2K","^2T","^2U","^2V","^2W","^2X","^S","^3A","^3D","^3@","^1N"]],"^T","Protocols and default Reader types implementation"] \ No newline at end of file diff --git a/js/cljs/tools/reader/reader_types.js b/js/cljs/tools/reader/reader_types.js new file mode 100644 index 0000000..2d2abfd --- /dev/null +++ b/js/cljs/tools/reader/reader_types.js @@ -0,0 +1,797 @@ +// Compiled by ClojureScript 1.10.329 {:static-fns true, :optimize-constants true, :target :nodejs} +goog.provide('cljs.tools.reader.reader_types'); +goog.require('cljs.core'); +goog.require('cljs.core.constants'); +goog.require('cljs.tools.reader.impl.utils'); +goog.require('goog.string'); +goog.require('goog.string.StringBuffer'); + +/** + * @interface + */ +cljs.tools.reader.reader_types.Reader = function(){}; + +/** + * Returns the next char from the Reader, nil if the end of stream has been reached + */ +cljs.tools.reader.reader_types.read_char = (function cljs$tools$reader$reader_types$read_char(reader){ +if(((!((reader == null))) && (!((reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1 == null))))){ +return reader.cljs$tools$reader$reader_types$Reader$read_char$arity$1(reader); +} else { +var x__4230__auto__ = (((reader == null))?null:reader); +var m__4231__auto__ = (cljs.tools.reader.reader_types.read_char[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto__.call(null,reader)); +} else { +var m__4231__auto____$1 = (cljs.tools.reader.reader_types.read_char["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto____$1.call(null,reader)); +} else { +throw cljs.core.missing_protocol("Reader.read-char",reader); +} +} +} +}); + +/** + * Returns the next char from the Reader without removing it from the reader stream + */ +cljs.tools.reader.reader_types.peek_char = (function cljs$tools$reader$reader_types$peek_char(reader){ +if(((!((reader == null))) && (!((reader.cljs$tools$reader$reader_types$Reader$peek_char$arity$1 == null))))){ +return reader.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(reader); +} else { +var x__4230__auto__ = (((reader == null))?null:reader); +var m__4231__auto__ = (cljs.tools.reader.reader_types.peek_char[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto__.call(null,reader)); +} else { +var m__4231__auto____$1 = (cljs.tools.reader.reader_types.peek_char["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto____$1.call(null,reader)); +} else { +throw cljs.core.missing_protocol("Reader.peek-char",reader); +} +} +} +}); + + +/** + * @interface + */ +cljs.tools.reader.reader_types.IPushbackReader = function(){}; + +/** + * Pushes back a single character on to the stream + */ +cljs.tools.reader.reader_types.unread = (function cljs$tools$reader$reader_types$unread(reader,ch){ +if(((!((reader == null))) && (!((reader.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2 == null))))){ +return reader.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2(reader,ch); +} else { +var x__4230__auto__ = (((reader == null))?null:reader); +var m__4231__auto__ = (cljs.tools.reader.reader_types.unread[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$2(reader,ch) : m__4231__auto__.call(null,reader,ch)); +} else { +var m__4231__auto____$1 = (cljs.tools.reader.reader_types.unread["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$2(reader,ch) : m__4231__auto____$1.call(null,reader,ch)); +} else { +throw cljs.core.missing_protocol("IPushbackReader.unread",reader); +} +} +} +}); + + +/** + * @interface + */ +cljs.tools.reader.reader_types.IndexingReader = function(){}; + +/** + * Returns the line number of the next character to be read from the stream + */ +cljs.tools.reader.reader_types.get_line_number = (function cljs$tools$reader$reader_types$get_line_number(reader){ +if(((!((reader == null))) && (!((reader.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1 == null))))){ +return reader.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1(reader); +} else { +var x__4230__auto__ = (((reader == null))?null:reader); +var m__4231__auto__ = (cljs.tools.reader.reader_types.get_line_number[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto__.call(null,reader)); +} else { +var m__4231__auto____$1 = (cljs.tools.reader.reader_types.get_line_number["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto____$1.call(null,reader)); +} else { +throw cljs.core.missing_protocol("IndexingReader.get-line-number",reader); +} +} +} +}); + +/** + * Returns the column number of the next character to be read from the stream + */ +cljs.tools.reader.reader_types.get_column_number = (function cljs$tools$reader$reader_types$get_column_number(reader){ +if(((!((reader == null))) && (!((reader.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1 == null))))){ +return reader.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1(reader); +} else { +var x__4230__auto__ = (((reader == null))?null:reader); +var m__4231__auto__ = (cljs.tools.reader.reader_types.get_column_number[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto__.call(null,reader)); +} else { +var m__4231__auto____$1 = (cljs.tools.reader.reader_types.get_column_number["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto____$1.call(null,reader)); +} else { +throw cljs.core.missing_protocol("IndexingReader.get-column-number",reader); +} +} +} +}); + +/** + * Returns the file name the reader is reading from, or nil + */ +cljs.tools.reader.reader_types.get_file_name = (function cljs$tools$reader$reader_types$get_file_name(reader){ +if(((!((reader == null))) && (!((reader.cljs$tools$reader$reader_types$IndexingReader$get_file_name$arity$1 == null))))){ +return reader.cljs$tools$reader$reader_types$IndexingReader$get_file_name$arity$1(reader); +} else { +var x__4230__auto__ = (((reader == null))?null:reader); +var m__4231__auto__ = (cljs.tools.reader.reader_types.get_file_name[goog.typeOf(x__4230__auto__)]); +if(!((m__4231__auto__ == null))){ +return (m__4231__auto__.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto__.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto__.call(null,reader)); +} else { +var m__4231__auto____$1 = (cljs.tools.reader.reader_types.get_file_name["_"]); +if(!((m__4231__auto____$1 == null))){ +return (m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1 ? m__4231__auto____$1.cljs$core$IFn$_invoke$arity$1(reader) : m__4231__auto____$1.call(null,reader)); +} else { +throw cljs.core.missing_protocol("IndexingReader.get-file-name",reader); +} +} +} +}); + + +/** +* @constructor + * @implements {cljs.tools.reader.reader_types.Reader} +*/ +cljs.tools.reader.reader_types.StringReader = (function (s,s_len,s_pos){ +this.s = s; +this.s_len = s_len; +this.s_pos = s_pos; +}); +cljs.tools.reader.reader_types.StringReader.prototype.cljs$tools$reader$reader_types$Reader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.StringReader.prototype.cljs$tools$reader$reader_types$Reader$read_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +if((self__.s_len > self__.s_pos)){ +var r = self__.s.charAt(self__.s_pos); +self__.s_pos = (self__.s_pos + (1)); + +return r; +} else { +return null; +} +}); + +cljs.tools.reader.reader_types.StringReader.prototype.cljs$tools$reader$reader_types$Reader$peek_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +if((self__.s_len > self__.s_pos)){ +return self__.s.charAt(self__.s_pos); +} else { +return null; +} +}); + +cljs.tools.reader.reader_types.StringReader.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$s,cljs.core.cst$sym$s_DASH_len,cljs.core.with_meta(cljs.core.cst$sym$s_DASH_pos,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.tools.reader.reader_types.StringReader.cljs$lang$type = true; + +cljs.tools.reader.reader_types.StringReader.cljs$lang$ctorStr = "cljs.tools.reader.reader-types/StringReader"; + +cljs.tools.reader.reader_types.StringReader.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.tools.reader.reader-types/StringReader"); +}); + +/** + * Positional factory function for cljs.tools.reader.reader-types/StringReader. + */ +cljs.tools.reader.reader_types.__GT_StringReader = (function cljs$tools$reader$reader_types$__GT_StringReader(s,s_len,s_pos){ +return (new cljs.tools.reader.reader_types.StringReader(s,s_len,s_pos)); +}); + + +/** +* @constructor + * @implements {cljs.tools.reader.reader_types.Reader} +*/ +cljs.tools.reader.reader_types.NodeReadableReader = (function (readable,buf){ +this.readable = readable; +this.buf = buf; +}); +cljs.tools.reader.reader_types.NodeReadableReader.prototype.cljs$tools$reader$reader_types$Reader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.NodeReadableReader.prototype.cljs$tools$reader$reader_types$Reader$read_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +if(cljs.core.truth_(self__.buf)){ +var c = (self__.buf[(0)]); +self__.buf = null; + +return cljs.tools.reader.impl.utils.char$(c); +} else { +var c = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.readable.read((1)))].join(''); +if(cljs.core.truth_(c)){ +return cljs.tools.reader.impl.utils.char$(c); +} else { +return null; +} +} +}); + +cljs.tools.reader.reader_types.NodeReadableReader.prototype.cljs$tools$reader$reader_types$Reader$peek_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +if(cljs.core.truth_(self__.buf)){ +} else { +self__.buf = [cljs.core.str.cljs$core$IFn$_invoke$arity$1(self__.readable.read((1)))].join(''); +} + +if(cljs.core.truth_(self__.buf)){ +return cljs.tools.reader.impl.utils.char$((self__.buf[(0)])); +} else { +return null; +} +}); + +cljs.tools.reader.reader_types.NodeReadableReader.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$sym$readable,cljs.core.with_meta(cljs.core.cst$sym$buf,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.tools.reader.reader_types.NodeReadableReader.cljs$lang$type = true; + +cljs.tools.reader.reader_types.NodeReadableReader.cljs$lang$ctorStr = "cljs.tools.reader.reader-types/NodeReadableReader"; + +cljs.tools.reader.reader_types.NodeReadableReader.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.tools.reader.reader-types/NodeReadableReader"); +}); + +/** + * Positional factory function for cljs.tools.reader.reader-types/NodeReadableReader. + */ +cljs.tools.reader.reader_types.__GT_NodeReadableReader = (function cljs$tools$reader$reader_types$__GT_NodeReadableReader(readable,buf){ +return (new cljs.tools.reader.reader_types.NodeReadableReader(readable,buf)); +}); + + +/** +* @constructor + * @implements {cljs.tools.reader.reader_types.Reader} + * @implements {cljs.tools.reader.reader_types.IPushbackReader} +*/ +cljs.tools.reader.reader_types.PushbackReader = (function (rdr,buf,buf_len,buf_pos){ +this.rdr = rdr; +this.buf = buf; +this.buf_len = buf_len; +this.buf_pos = buf_pos; +}); +cljs.tools.reader.reader_types.PushbackReader.prototype.cljs$tools$reader$reader_types$Reader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.PushbackReader.prototype.cljs$tools$reader$reader_types$Reader$read_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +var c = (((self__.buf_pos < self__.buf_len))?(self__.buf[self__.buf_pos]):self__.rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null)); +if((self__.buf_pos < self__.buf_len)){ +self__.buf_pos = (self__.buf_pos + (1)); +} else { +} + +return cljs.tools.reader.impl.utils.char$(c); +}); + +cljs.tools.reader.reader_types.PushbackReader.prototype.cljs$tools$reader$reader_types$Reader$peek_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +var c = (((self__.buf_pos < self__.buf_len))?(self__.buf[self__.buf_pos]):self__.rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null)); +return cljs.tools.reader.impl.utils.char$(c); +}); + +cljs.tools.reader.reader_types.PushbackReader.prototype.cljs$tools$reader$reader_types$IPushbackReader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.PushbackReader.prototype.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2 = (function (reader,ch){ +var self__ = this; +var reader__$1 = this; +if(cljs.core.truth_(ch)){ +if((self__.buf_pos === (0))){ +throw (new Error("Pushback buffer is full")); +} else { +} + +self__.buf_pos = (self__.buf_pos - (1)); + +return (self__.buf[self__.buf_pos] = ch); +} else { +return null; +} +}); + +cljs.tools.reader.reader_types.PushbackReader.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 4, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$rdr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$not_DASH_native], null)),cljs.core.cst$sym$buf,cljs.core.cst$sym$buf_DASH_len,cljs.core.with_meta(cljs.core.cst$sym$buf_DASH_pos,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null))], null); +}); + +cljs.tools.reader.reader_types.PushbackReader.cljs$lang$type = true; + +cljs.tools.reader.reader_types.PushbackReader.cljs$lang$ctorStr = "cljs.tools.reader.reader-types/PushbackReader"; + +cljs.tools.reader.reader_types.PushbackReader.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.tools.reader.reader-types/PushbackReader"); +}); + +/** + * Positional factory function for cljs.tools.reader.reader-types/PushbackReader. + */ +cljs.tools.reader.reader_types.__GT_PushbackReader = (function cljs$tools$reader$reader_types$__GT_PushbackReader(rdr,buf,buf_len,buf_pos){ +return (new cljs.tools.reader.reader_types.PushbackReader(rdr,buf,buf_len,buf_pos)); +}); + +cljs.tools.reader.reader_types.normalize_newline = (function cljs$tools$reader$reader_types$normalize_newline(rdr,ch){ +if(("\r" === ch)){ +var c = rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null); +if(((("\f" === c)) || (("\n" === c)))){ +rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +} else { +} + +return "\n"; +} else { +return ch; +} +}); + +/** +* @constructor + * @implements {cljs.tools.reader.reader_types.IndexingReader} + * @implements {cljs.tools.reader.reader_types.Reader} + * @implements {cljs.tools.reader.reader_types.IPushbackReader} +*/ +cljs.tools.reader.reader_types.IndexingPushbackReader = (function (rdr,line,column,line_start_QMARK_,prev,prev_column,file_name){ +this.rdr = rdr; +this.line = line; +this.column = column; +this.line_start_QMARK_ = line_start_QMARK_; +this.prev = prev; +this.prev_column = prev_column; +this.file_name = file_name; +}); +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$Reader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$Reader$read_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +var temp__5457__auto__ = self__.rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(cljs.core.truth_(temp__5457__auto__)){ +var ch = temp__5457__auto__; +var ch__$1 = cljs.tools.reader.reader_types.normalize_newline(self__.rdr,ch); +self__.prev = self__.line_start_QMARK_; + +self__.line_start_QMARK_ = cljs.tools.reader.impl.utils.newline_QMARK_(ch__$1); + +if(cljs.core.truth_(self__.line_start_QMARK_)){ +self__.prev_column = self__.column; + +self__.column = (0); + +self__.line = (self__.line + (1)); +} else { +} + +self__.column = (self__.column + (1)); + +return ch__$1; +} else { +return null; +} +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$Reader$peek_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return self__.rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null); +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$IPushbackReader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2 = (function (reader,ch){ +var self__ = this; +var reader__$1 = this; +if(cljs.core.truth_(self__.line_start_QMARK_)){ +self__.line = (self__.line - (1)); + +self__.column = self__.prev_column; +} else { +self__.column = (self__.column - (1)); +} + +self__.line_start_QMARK_ = self__.prev; + +return self__.rdr.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2(null,ch); +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return (self__.line | (0)); +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return (self__.column | (0)); +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$get_file_name$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return self__.file_name; +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 7, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$rdr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$not_DASH_native], null)),cljs.core.with_meta(cljs.core.cst$sym$line,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$column,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$line_DASH_start_QMARK_,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$prev,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$prev_DASH_column,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$file_DASH_name], null); +}); + +cljs.tools.reader.reader_types.IndexingPushbackReader.cljs$lang$type = true; + +cljs.tools.reader.reader_types.IndexingPushbackReader.cljs$lang$ctorStr = "cljs.tools.reader.reader-types/IndexingPushbackReader"; + +cljs.tools.reader.reader_types.IndexingPushbackReader.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.tools.reader.reader-types/IndexingPushbackReader"); +}); + +/** + * Positional factory function for cljs.tools.reader.reader-types/IndexingPushbackReader. + */ +cljs.tools.reader.reader_types.__GT_IndexingPushbackReader = (function cljs$tools$reader$reader_types$__GT_IndexingPushbackReader(rdr,line,column,line_start_QMARK_,prev,prev_column,file_name){ +return (new cljs.tools.reader.reader_types.IndexingPushbackReader(rdr,line,column,line_start_QMARK_,prev,prev_column,file_name)); +}); + +/** + * Returns an object of the same type and value as `obj`, with its + * metadata merged over `m`. + */ +cljs.tools.reader.reader_types.merge_meta = (function cljs$tools$reader$reader_types$merge_meta(obj,m){ +var orig_meta = cljs.core.meta(obj); +return cljs.core.with_meta(obj,cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([m,cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(orig_meta,cljs.core.cst$kw$source)], 0))); +}); +/** + * Returns a string containing the contents of the top most source + * logging frame. + */ +cljs.tools.reader.reader_types.peek_source_log = (function cljs$tools$reader$reader_types$peek_source_log(frames){ +return cljs.core.subs.cljs$core$IFn$_invoke$arity$2([cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.cst$kw$buffer.cljs$core$IFn$_invoke$arity$1(frames))].join(''),cljs.core.first(cljs.core.cst$kw$offset.cljs$core$IFn$_invoke$arity$1(frames))); +}); +/** + * Logs `char` to all currently active source logging frames. + */ +cljs.tools.reader.reader_types.log_source_char = (function cljs$tools$reader$reader_types$log_source_char(frames,char$){ +var temp__5457__auto__ = cljs.core.cst$kw$buffer.cljs$core$IFn$_invoke$arity$1(frames); +if(cljs.core.truth_(temp__5457__auto__)){ +var buffer = temp__5457__auto__; +return buffer.append(char$); +} else { +return null; +} +}); +/** + * Removes the last logged character from all currently active source + * logging frames. Called when pushing a character back. + */ +cljs.tools.reader.reader_types.drop_last_logged_char = (function cljs$tools$reader$reader_types$drop_last_logged_char(frames){ +var temp__5457__auto__ = cljs.core.cst$kw$buffer.cljs$core$IFn$_invoke$arity$1(frames); +if(cljs.core.truth_(temp__5457__auto__)){ +var buffer = temp__5457__auto__; +return buffer.set(cljs.core.subs.cljs$core$IFn$_invoke$arity$3([cljs.core.str.cljs$core$IFn$_invoke$arity$1(buffer)].join(''),(0),(buffer.getLength() - (1)))); +} else { +return null; +} +}); + +/** +* @constructor + * @implements {cljs.tools.reader.reader_types.IndexingReader} + * @implements {cljs.tools.reader.reader_types.Reader} + * @implements {cljs.tools.reader.reader_types.IPushbackReader} +*/ +cljs.tools.reader.reader_types.SourceLoggingPushbackReader = (function (rdr,line,column,line_start_QMARK_,prev,prev_column,file_name,frames){ +this.rdr = rdr; +this.line = line; +this.column = column; +this.line_start_QMARK_ = line_start_QMARK_; +this.prev = prev; +this.prev_column = prev_column; +this.file_name = file_name; +this.frames = frames; +}); +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$Reader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$Reader$read_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +var temp__5457__auto__ = self__.rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +if(cljs.core.truth_(temp__5457__auto__)){ +var ch = temp__5457__auto__; +var ch__$1 = cljs.tools.reader.reader_types.normalize_newline(self__.rdr,ch); +self__.prev = self__.line_start_QMARK_; + +self__.line_start_QMARK_ = cljs.tools.reader.impl.utils.newline_QMARK_(ch__$1); + +if(cljs.core.truth_(self__.line_start_QMARK_)){ +self__.prev_column = self__.column; + +self__.column = (0); + +self__.line = (self__.line + (1)); +} else { +} + +self__.column = (self__.column + (1)); + +cljs.tools.reader.reader_types.log_source_char(cljs.core.deref(self__.frames),ch__$1); + +return ch__$1; +} else { +return null; +} +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$Reader$peek_char$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return self__.rdr.cljs$tools$reader$reader_types$Reader$peek_char$arity$1(null); +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$IPushbackReader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2 = (function (reader,ch){ +var self__ = this; +var reader__$1 = this; +if(cljs.core.truth_(self__.line_start_QMARK_)){ +self__.line = (self__.line - (1)); + +self__.column = self__.prev_column; +} else { +self__.column = (self__.column - (1)); +} + +self__.line_start_QMARK_ = self__.prev; + +if(cljs.core.truth_(ch)){ +cljs.tools.reader.reader_types.drop_last_logged_char(cljs.core.deref(self__.frames)); +} else { +} + +return self__.rdr.cljs$tools$reader$reader_types$IPushbackReader$unread$arity$2(null,ch); +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$ = cljs.core.PROTOCOL_SENTINEL; + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$get_line_number$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return (self__.line | (0)); +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return (self__.column | (0)); +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.prototype.cljs$tools$reader$reader_types$IndexingReader$get_file_name$arity$1 = (function (reader){ +var self__ = this; +var reader__$1 = this; +return self__.file_name; +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.getBasis = (function (){ +return new cljs.core.PersistentVector(null, 8, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.with_meta(cljs.core.cst$sym$rdr,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$tag,cljs.core.cst$sym$not_DASH_native], null)),cljs.core.with_meta(cljs.core.cst$sym$line,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$column,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$line_DASH_start_QMARK_,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$prev,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.with_meta(cljs.core.cst$sym$prev_DASH_column,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$mutable,true], null)),cljs.core.cst$sym$file_DASH_name,cljs.core.cst$sym$frames], null); +}); + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.cljs$lang$type = true; + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.cljs$lang$ctorStr = "cljs.tools.reader.reader-types/SourceLoggingPushbackReader"; + +cljs.tools.reader.reader_types.SourceLoggingPushbackReader.cljs$lang$ctorPrWriter = (function (this__4179__auto__,writer__4180__auto__,opt__4181__auto__){ +return cljs.core._write(writer__4180__auto__,"cljs.tools.reader.reader-types/SourceLoggingPushbackReader"); +}); + +/** + * Positional factory function for cljs.tools.reader.reader-types/SourceLoggingPushbackReader. + */ +cljs.tools.reader.reader_types.__GT_SourceLoggingPushbackReader = (function cljs$tools$reader$reader_types$__GT_SourceLoggingPushbackReader(rdr,line,column,line_start_QMARK_,prev,prev_column,file_name,frames){ +return (new cljs.tools.reader.reader_types.SourceLoggingPushbackReader(rdr,line,column,line_start_QMARK_,prev,prev_column,file_name,frames)); +}); + +/** + * Returns true if the reader satisfies IndexingReader + */ +cljs.tools.reader.reader_types.indexing_reader_QMARK_ = (function cljs$tools$reader$reader_types$indexing_reader_QMARK_(rdr){ +if(!((rdr == null))){ +if(((false) || ((cljs.core.PROTOCOL_SENTINEL === rdr.cljs$tools$reader$reader_types$IndexingReader$)))){ +return true; +} else { +return false; +} +} else { +return false; +} +}); +/** + * Creates a StringReader from a given string + */ +cljs.tools.reader.reader_types.string_reader = (function cljs$tools$reader$reader_types$string_reader(s){ +return (new cljs.tools.reader.reader_types.StringReader(s,cljs.core.count(s),(0))); +}); +/** + * Creates a PushbackReader from a given string + */ +cljs.tools.reader.reader_types.string_push_back_reader = (function cljs$tools$reader$reader_types$string_push_back_reader(var_args){ +var G__1848 = arguments.length; +switch (G__1848) { +case 1: +return cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$1 = (function (s){ +return cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$2(s,(1)); +}); + +cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$2 = (function (s,buf_len){ +return (new cljs.tools.reader.reader_types.PushbackReader(cljs.tools.reader.reader_types.string_reader(s),cljs.core.object_array.cljs$core$IFn$_invoke$arity$1(buf_len),buf_len,buf_len)); +}); + +cljs.tools.reader.reader_types.string_push_back_reader.cljs$lang$maxFixedArity = 2; + +cljs.tools.reader.reader_types.node_readable_push_back_reader = (function cljs$tools$reader$reader_types$node_readable_push_back_reader(readable){ +return (new cljs.tools.reader.reader_types.PushbackReader((new cljs.tools.reader.reader_types.NodeReadableReader(readable,null)),cljs.core.object_array.cljs$core$IFn$_invoke$arity$1((1)),(1),(1))); +}); +/** + * Creates an IndexingPushbackReader from a given string or PushbackReader + */ +cljs.tools.reader.reader_types.indexing_push_back_reader = (function cljs$tools$reader$reader_types$indexing_push_back_reader(var_args){ +var G__1851 = arguments.length; +switch (G__1851) { +case 1: +return cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$1 = (function (s_or_rdr){ +return cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$2(s_or_rdr,(1)); +}); + +cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$2 = (function (s_or_rdr,buf_len){ +return cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$3(s_or_rdr,buf_len,null); +}); + +cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$core$IFn$_invoke$arity$3 = (function (s_or_rdr,buf_len,file_name){ +return (new cljs.tools.reader.reader_types.IndexingPushbackReader(((typeof s_or_rdr === 'string')?cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$2(s_or_rdr,buf_len):s_or_rdr),(1),(1),true,null,(0),file_name)); +}); + +cljs.tools.reader.reader_types.indexing_push_back_reader.cljs$lang$maxFixedArity = 3; + +/** + * Creates a SourceLoggingPushbackReader from a given string or PushbackReader + */ +cljs.tools.reader.reader_types.source_logging_push_back_reader = (function cljs$tools$reader$reader_types$source_logging_push_back_reader(var_args){ +var G__1854 = arguments.length; +switch (G__1854) { +case 1: +return cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); + +break; +case 2: +return cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); + +break; +case 3: +return cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); + +break; +default: +throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); + +} +}); + +cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$1 = (function (s_or_rdr){ +return cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$2(s_or_rdr,(1)); +}); + +cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$2 = (function (s_or_rdr,buf_len){ +return cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$3(s_or_rdr,buf_len,null); +}); + +cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$core$IFn$_invoke$arity$3 = (function (s_or_rdr,buf_len,file_name){ +return (new cljs.tools.reader.reader_types.SourceLoggingPushbackReader(((typeof s_or_rdr === 'string')?cljs.tools.reader.reader_types.string_push_back_reader.cljs$core$IFn$_invoke$arity$2(s_or_rdr,buf_len):s_or_rdr),(1),(1),true,null,(0),file_name,cljs.core.atom.cljs$core$IFn$_invoke$arity$1(new cljs.core.PersistentArrayMap(null, 2, [cljs.core.cst$kw$buffer,(new goog.string.StringBuffer()),cljs.core.cst$kw$offset,cljs.core.list((0))], null)))); +}); + +cljs.tools.reader.reader_types.source_logging_push_back_reader.cljs$lang$maxFixedArity = 3; + +/** + * Reads a line from the reader or from *in* if no reader is specified + */ +cljs.tools.reader.reader_types.read_line = (function cljs$tools$reader$reader_types$read_line(rdr){ +var c = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +var s = (new goog.string.StringBuffer()); +while(true){ +if(cljs.tools.reader.impl.utils.newline_QMARK_(c)){ +return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(s)].join(''); +} else { +var G__1856 = rdr.cljs$tools$reader$reader_types$Reader$read_char$arity$1(null); +var G__1857 = s.append(c); +c = G__1856; +s = G__1857; +continue; +} +break; +} +}); +cljs.tools.reader.reader_types.source_logging_reader_QMARK_ = (function cljs$tools$reader$reader_types$source_logging_reader_QMARK_(rdr){ +return (rdr instanceof cljs.tools.reader.reader_types.SourceLoggingPushbackReader); +}); +/** + * Returns true if rdr is an IndexingReader and the current char starts a new line + */ +cljs.tools.reader.reader_types.line_start_QMARK_ = (function cljs$tools$reader$reader_types$line_start_QMARK_(rdr){ +if(cljs.core.truth_(cljs.tools.reader.reader_types.indexing_reader_QMARK_(rdr))){ +return ((1) === rdr.cljs$tools$reader$reader_types$IndexingReader$get_column_number$arity$1(null)); +} else { +return null; +} +}); +cljs.tools.reader.reader_types.log_source_STAR_ = (function cljs$tools$reader$reader_types$log_source_STAR_(reader,f){ +var buffer = cljs.core.cst$kw$buffer.cljs$core$IFn$_invoke$arity$1(cljs.core.deref(reader.frames)); +try{cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$variadic(reader.frames,cljs.core.update_in,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$kw$offset], null),cljs.core.conj,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([buffer.getLength()], 0)); + +var ret = (f.cljs$core$IFn$_invoke$arity$0 ? f.cljs$core$IFn$_invoke$arity$0() : f.call(null)); +if(((!((ret == null)))?(((((ret.cljs$lang$protocol_mask$partition0$ & (131072))) || ((cljs.core.PROTOCOL_SENTINEL === ret.cljs$core$IMeta$))))?true:false):false)){ +return cljs.tools.reader.reader_types.merge_meta(ret,new cljs.core.PersistentArrayMap(null, 1, [cljs.core.cst$kw$source,cljs.tools.reader.reader_types.peek_source_log(cljs.core.deref(reader.frames))], null)); +} else { +return ret; +} +}finally {cljs.core.swap_BANG_.cljs$core$IFn$_invoke$arity$4(reader.frames,cljs.core.update_in,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.cst$kw$offset], null),cljs.core.rest); +}}); diff --git a/js/cljsc_opts.edn b/js/cljsc_opts.edn new file mode 100644 index 0000000..0a08375 --- /dev/null +++ b/js/cljsc_opts.edn @@ -0,0 +1 @@ +{:target :nodejs, :optimizations :advanced, :output-dir "website/static/js", :output-to "website/static/pluto.js", :main pluto.reader, :aot-cache true} \ No newline at end of file diff --git a/js/cljsjs/create-react-class/production/create-react-class.min.inc.js b/js/cljsjs/create-react-class/production/create-react-class.min.inc.js new file mode 100644 index 0000000..0486cee --- /dev/null +++ b/js/cljsjs/create-react-class/production/create-react-class.min.inc.js @@ -0,0 +1,1298 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("react")); + else if(typeof define === 'function' && define.amd) + define(["react"], factory); + else if(typeof exports === 'object') + exports["createReactClass"] = factory(require("react")); + else + root["createReactClass"] = factory(root["React"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_1__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // identity function for calling harmony imports with the correct context +/******/ __webpack_require__.i = function(value) { return value; }; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { +/******/ configurable: false, +/******/ enumerable: true, +/******/ get: getter +/******/ }); +/******/ } +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 2); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var _assign = __webpack_require__(7); + +var emptyObject = __webpack_require__(4); +var _invariant = __webpack_require__(5); + +if (true) { + var warning = __webpack_require__(6); +} + +var MIXINS_KEY = 'mixins'; + +// Helper function to allow the creation of anonymous functions which do not +// have .name set to the name of the variable being assigned to. +function identity(fn) { + return fn; +} + +var ReactPropTypeLocationNames; +if (true) { + ReactPropTypeLocationNames = { + prop: 'prop', + context: 'context', + childContext: 'child context' + }; +} else { + ReactPropTypeLocationNames = {}; +} + +function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) { + /** + * Policies that describe methods in `ReactClassInterface`. + */ + + var injectedMixins = []; + + /** + * Composite components are higher-level components that compose other composite + * or host components. + * + * To create a new type of `ReactClass`, pass a specification of + * your new class to `React.createClass`. The only requirement of your class + * specification is that you implement a `render` method. + * + * var MyComponent = React.createClass({ + * render: function() { + * return
Hello World
; + * } + * }); + * + * The class specification supports a specific protocol of methods that have + * special meaning (e.g. `render`). See `ReactClassInterface` for + * more the comprehensive protocol. Any other properties and methods in the + * class specification will be available on the prototype. + * + * @interface ReactClassInterface + * @internal + */ + var ReactClassInterface = { + /** + * An array of Mixin objects to include when defining your component. + * + * @type {array} + * @optional + */ + mixins: 'DEFINE_MANY', + + /** + * An object containing properties and methods that should be defined on + * the component's constructor instead of its prototype (static methods). + * + * @type {object} + * @optional + */ + statics: 'DEFINE_MANY', + + /** + * Definition of prop types for this component. + * + * @type {object} + * @optional + */ + propTypes: 'DEFINE_MANY', + + /** + * Definition of context types for this component. + * + * @type {object} + * @optional + */ + contextTypes: 'DEFINE_MANY', + + /** + * Definition of context types this component sets for its children. + * + * @type {object} + * @optional + */ + childContextTypes: 'DEFINE_MANY', + + // ==== Definition methods ==== + + /** + * Invoked when the component is mounted. Values in the mapping will be set on + * `this.props` if that prop is not specified (i.e. using an `in` check). + * + * This method is invoked before `getInitialState` and therefore cannot rely + * on `this.state` or use `this.setState`. + * + * @return {object} + * @optional + */ + getDefaultProps: 'DEFINE_MANY_MERGED', + + /** + * Invoked once before the component is mounted. The return value will be used + * as the initial value of `this.state`. + * + * getInitialState: function() { + * return { + * isOn: false, + * fooBaz: new BazFoo() + * } + * } + * + * @return {object} + * @optional + */ + getInitialState: 'DEFINE_MANY_MERGED', + + /** + * @return {object} + * @optional + */ + getChildContext: 'DEFINE_MANY_MERGED', + + /** + * Uses props from `this.props` and state from `this.state` to render the + * structure of the component. + * + * No guarantees are made about when or how often this method is invoked, so + * it must not have side effects. + * + * render: function() { + * var name = this.props.name; + * return
Hello, {name}!
; + * } + * + * @return {ReactComponent} + * @required + */ + render: 'DEFINE_ONCE', + + // ==== Delegate methods ==== + + /** + * Invoked when the component is initially created and about to be mounted. + * This may have side effects, but any external subscriptions or data created + * by this method must be cleaned up in `componentWillUnmount`. + * + * @optional + */ + componentWillMount: 'DEFINE_MANY', + + /** + * Invoked when the component has been mounted and has a DOM representation. + * However, there is no guarantee that the DOM node is in the document. + * + * Use this as an opportunity to operate on the DOM when the component has + * been mounted (initialized and rendered) for the first time. + * + * @param {DOMElement} rootNode DOM element representing the component. + * @optional + */ + componentDidMount: 'DEFINE_MANY', + + /** + * Invoked before the component receives new props. + * + * Use this as an opportunity to react to a prop transition by updating the + * state using `this.setState`. Current props are accessed via `this.props`. + * + * componentWillReceiveProps: function(nextProps, nextContext) { + * this.setState({ + * likesIncreasing: nextProps.likeCount > this.props.likeCount + * }); + * } + * + * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop + * transition may cause a state change, but the opposite is not true. If you + * need it, you are probably looking for `componentWillUpdate`. + * + * @param {object} nextProps + * @optional + */ + componentWillReceiveProps: 'DEFINE_MANY', + + /** + * Invoked while deciding if the component should be updated as a result of + * receiving new props, state and/or context. + * + * Use this as an opportunity to `return false` when you're certain that the + * transition to the new props/state/context will not require a component + * update. + * + * shouldComponentUpdate: function(nextProps, nextState, nextContext) { + * return !equal(nextProps, this.props) || + * !equal(nextState, this.state) || + * !equal(nextContext, this.context); + * } + * + * @param {object} nextProps + * @param {?object} nextState + * @param {?object} nextContext + * @return {boolean} True if the component should update. + * @optional + */ + shouldComponentUpdate: 'DEFINE_ONCE', + + /** + * Invoked when the component is about to update due to a transition from + * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState` + * and `nextContext`. + * + * Use this as an opportunity to perform preparation before an update occurs. + * + * NOTE: You **cannot** use `this.setState()` in this method. + * + * @param {object} nextProps + * @param {?object} nextState + * @param {?object} nextContext + * @param {ReactReconcileTransaction} transaction + * @optional + */ + componentWillUpdate: 'DEFINE_MANY', + + /** + * Invoked when the component's DOM representation has been updated. + * + * Use this as an opportunity to operate on the DOM when the component has + * been updated. + * + * @param {object} prevProps + * @param {?object} prevState + * @param {?object} prevContext + * @param {DOMElement} rootNode DOM element representing the component. + * @optional + */ + componentDidUpdate: 'DEFINE_MANY', + + /** + * Invoked when the component is about to be removed from its parent and have + * its DOM representation destroyed. + * + * Use this as an opportunity to deallocate any external resources. + * + * NOTE: There is no `componentDidUnmount` since your component will have been + * destroyed by that point. + * + * @optional + */ + componentWillUnmount: 'DEFINE_MANY', + + // ==== Advanced methods ==== + + /** + * Updates the component's currently mounted DOM representation. + * + * By default, this implements React's rendering and reconciliation algorithm. + * Sophisticated clients may wish to override this. + * + * @param {ReactReconcileTransaction} transaction + * @internal + * @overridable + */ + updateComponent: 'OVERRIDE_BASE' + }; + + /** + * Mapping from class specification keys to special processing functions. + * + * Although these are declared like instance properties in the specification + * when defining classes using `React.createClass`, they are actually static + * and are accessible on the constructor instead of the prototype. Despite + * being static, they must be defined outside of the "statics" key under + * which all other static methods are defined. + */ + var RESERVED_SPEC_KEYS = { + displayName: function(Constructor, displayName) { + Constructor.displayName = displayName; + }, + mixins: function(Constructor, mixins) { + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + mixSpecIntoComponent(Constructor, mixins[i]); + } + } + }, + childContextTypes: function(Constructor, childContextTypes) { + if (true) { + validateTypeDef(Constructor, childContextTypes, 'childContext'); + } + Constructor.childContextTypes = _assign( + {}, + Constructor.childContextTypes, + childContextTypes + ); + }, + contextTypes: function(Constructor, contextTypes) { + if (true) { + validateTypeDef(Constructor, contextTypes, 'context'); + } + Constructor.contextTypes = _assign( + {}, + Constructor.contextTypes, + contextTypes + ); + }, + /** + * Special case getDefaultProps which should move into statics but requires + * automatic merging. + */ + getDefaultProps: function(Constructor, getDefaultProps) { + if (Constructor.getDefaultProps) { + Constructor.getDefaultProps = createMergedResultFunction( + Constructor.getDefaultProps, + getDefaultProps + ); + } else { + Constructor.getDefaultProps = getDefaultProps; + } + }, + propTypes: function(Constructor, propTypes) { + if (true) { + validateTypeDef(Constructor, propTypes, 'prop'); + } + Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes); + }, + statics: function(Constructor, statics) { + mixStaticSpecIntoComponent(Constructor, statics); + }, + autobind: function() {} + }; + + function validateTypeDef(Constructor, typeDef, location) { + for (var propName in typeDef) { + if (typeDef.hasOwnProperty(propName)) { + // use a warning instead of an _invariant so components + // don't show up in prod but only in __DEV__ + if (true) { + warning( + typeof typeDef[propName] === 'function', + '%s: %s type `%s` is invalid; it must be a function, usually from ' + + 'React.PropTypes.', + Constructor.displayName || 'ReactClass', + ReactPropTypeLocationNames[location], + propName + ); + } + } + } + } + + function validateMethodOverride(isAlreadyDefined, name) { + var specPolicy = ReactClassInterface.hasOwnProperty(name) + ? ReactClassInterface[name] + : null; + + // Disallow overriding of base class methods unless explicitly allowed. + if (ReactClassMixin.hasOwnProperty(name)) { + _invariant( + specPolicy === 'OVERRIDE_BASE', + 'ReactClassInterface: You are attempting to override ' + + '`%s` from your class specification. Ensure that your method names ' + + 'do not overlap with React methods.', + name + ); + } + + // Disallow defining methods more than once unless explicitly allowed. + if (isAlreadyDefined) { + _invariant( + specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED', + 'ReactClassInterface: You are attempting to define ' + + '`%s` on your component more than once. This conflict may be due ' + + 'to a mixin.', + name + ); + } + } + + /** + * Mixin helper which handles policy validation and reserved + * specification keys when building React classes. + */ + function mixSpecIntoComponent(Constructor, spec) { + if (!spec) { + if (true) { + var typeofSpec = typeof spec; + var isMixinValid = typeofSpec === 'object' && spec !== null; + + if (true) { + warning( + isMixinValid, + "%s: You're attempting to include a mixin that is either null " + + 'or not an object. Check the mixins included by the component, ' + + 'as well as any mixins they include themselves. ' + + 'Expected object but got %s.', + Constructor.displayName || 'ReactClass', + spec === null ? null : typeofSpec + ); + } + } + + return; + } + + _invariant( + typeof spec !== 'function', + "ReactClass: You're attempting to " + + 'use a component class or function as a mixin. Instead, just use a ' + + 'regular object.' + ); + _invariant( + !isValidElement(spec), + "ReactClass: You're attempting to " + + 'use a component as a mixin. Instead, just use a regular object.' + ); + + var proto = Constructor.prototype; + var autoBindPairs = proto.__reactAutoBindPairs; + + // By handling mixins before any other properties, we ensure the same + // chaining order is applied to methods with DEFINE_MANY policy, whether + // mixins are listed before or after these methods in the spec. + if (spec.hasOwnProperty(MIXINS_KEY)) { + RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins); + } + + for (var name in spec) { + if (!spec.hasOwnProperty(name)) { + continue; + } + + if (name === MIXINS_KEY) { + // We have already handled mixins in a special case above. + continue; + } + + var property = spec[name]; + var isAlreadyDefined = proto.hasOwnProperty(name); + validateMethodOverride(isAlreadyDefined, name); + + if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) { + RESERVED_SPEC_KEYS[name](Constructor, property); + } else { + // Setup methods on prototype: + // The following member methods should not be automatically bound: + // 1. Expected ReactClass methods (in the "interface"). + // 2. Overridden methods (that were mixed in). + var isReactClassMethod = ReactClassInterface.hasOwnProperty(name); + var isFunction = typeof property === 'function'; + var shouldAutoBind = + isFunction && + !isReactClassMethod && + !isAlreadyDefined && + spec.autobind !== false; + + if (shouldAutoBind) { + autoBindPairs.push(name, property); + proto[name] = property; + } else { + if (isAlreadyDefined) { + var specPolicy = ReactClassInterface[name]; + + // These cases should already be caught by validateMethodOverride. + _invariant( + isReactClassMethod && + (specPolicy === 'DEFINE_MANY_MERGED' || + specPolicy === 'DEFINE_MANY'), + 'ReactClass: Unexpected spec policy %s for key %s ' + + 'when mixing in component specs.', + specPolicy, + name + ); + + // For methods which are defined more than once, call the existing + // methods before calling the new property, merging if appropriate. + if (specPolicy === 'DEFINE_MANY_MERGED') { + proto[name] = createMergedResultFunction(proto[name], property); + } else if (specPolicy === 'DEFINE_MANY') { + proto[name] = createChainedFunction(proto[name], property); + } + } else { + proto[name] = property; + if (true) { + // Add verbose displayName to the function, which helps when looking + // at profiling tools. + if (typeof property === 'function' && spec.displayName) { + proto[name].displayName = spec.displayName + '_' + name; + } + } + } + } + } + } + } + + function mixStaticSpecIntoComponent(Constructor, statics) { + if (!statics) { + return; + } + for (var name in statics) { + var property = statics[name]; + if (!statics.hasOwnProperty(name)) { + continue; + } + + var isReserved = name in RESERVED_SPEC_KEYS; + _invariant( + !isReserved, + 'ReactClass: You are attempting to define a reserved ' + + 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + + 'as an instance property instead; it will still be accessible on the ' + + 'constructor.', + name + ); + + var isInherited = name in Constructor; + _invariant( + !isInherited, + 'ReactClass: You are attempting to define ' + + '`%s` on your component more than once. This conflict may be ' + + 'due to a mixin.', + name + ); + Constructor[name] = property; + } + } + + /** + * Merge two objects, but throw if both contain the same key. + * + * @param {object} one The first object, which is mutated. + * @param {object} two The second object + * @return {object} one after it has been mutated to contain everything in two. + */ + function mergeIntoWithNoDuplicateKeys(one, two) { + _invariant( + one && two && typeof one === 'object' && typeof two === 'object', + 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.' + ); + + for (var key in two) { + if (two.hasOwnProperty(key)) { + _invariant( + one[key] === undefined, + 'mergeIntoWithNoDuplicateKeys(): ' + + 'Tried to merge two objects with the same key: `%s`. This conflict ' + + 'may be due to a mixin; in particular, this may be caused by two ' + + 'getInitialState() or getDefaultProps() methods returning objects ' + + 'with clashing keys.', + key + ); + one[key] = two[key]; + } + } + return one; + } + + /** + * Creates a function that invokes two functions and merges their return values. + * + * @param {function} one Function to invoke first. + * @param {function} two Function to invoke second. + * @return {function} Function that invokes the two argument functions. + * @private + */ + function createMergedResultFunction(one, two) { + return function mergedResult() { + var a = one.apply(this, arguments); + var b = two.apply(this, arguments); + if (a == null) { + return b; + } else if (b == null) { + return a; + } + var c = {}; + mergeIntoWithNoDuplicateKeys(c, a); + mergeIntoWithNoDuplicateKeys(c, b); + return c; + }; + } + + /** + * Creates a function that invokes two functions and ignores their return vales. + * + * @param {function} one Function to invoke first. + * @param {function} two Function to invoke second. + * @return {function} Function that invokes the two argument functions. + * @private + */ + function createChainedFunction(one, two) { + return function chainedFunction() { + one.apply(this, arguments); + two.apply(this, arguments); + }; + } + + /** + * Binds a method to the component. + * + * @param {object} component Component whose method is going to be bound. + * @param {function} method Method to be bound. + * @return {function} The bound method. + */ + function bindAutoBindMethod(component, method) { + var boundMethod = method.bind(component); + if (true) { + boundMethod.__reactBoundContext = component; + boundMethod.__reactBoundMethod = method; + boundMethod.__reactBoundArguments = null; + var componentName = component.constructor.displayName; + var _bind = boundMethod.bind; + boundMethod.bind = function(newThis) { + for ( + var _len = arguments.length, + args = Array(_len > 1 ? _len - 1 : 0), + _key = 1; + _key < _len; + _key++ + ) { + args[_key - 1] = arguments[_key]; + } + + // User is trying to bind() an autobound method; we effectively will + // ignore the value of "this" that the user is trying to use, so + // let's warn. + if (newThis !== component && newThis !== null) { + if (true) { + warning( + false, + 'bind(): React component methods may only be bound to the ' + + 'component instance. See %s', + componentName + ); + } + } else if (!args.length) { + if (true) { + warning( + false, + 'bind(): You are binding a component method to the component. ' + + 'React does this for you automatically in a high-performance ' + + 'way, so you can safely remove this call. See %s', + componentName + ); + } + return boundMethod; + } + var reboundMethod = _bind.apply(boundMethod, arguments); + reboundMethod.__reactBoundContext = component; + reboundMethod.__reactBoundMethod = method; + reboundMethod.__reactBoundArguments = args; + return reboundMethod; + }; + } + return boundMethod; + } + + /** + * Binds all auto-bound methods in a component. + * + * @param {object} component Component whose method is going to be bound. + */ + function bindAutoBindMethods(component) { + var pairs = component.__reactAutoBindPairs; + for (var i = 0; i < pairs.length; i += 2) { + var autoBindKey = pairs[i]; + var method = pairs[i + 1]; + component[autoBindKey] = bindAutoBindMethod(component, method); + } + } + + var IsMountedPreMixin = { + componentDidMount: function() { + this.__isMounted = true; + } + }; + + var IsMountedPostMixin = { + componentWillUnmount: function() { + this.__isMounted = false; + } + }; + + /** + * Add more to the ReactClass base class. These are all legacy features and + * therefore not already part of the modern ReactComponent. + */ + var ReactClassMixin = { + /** + * TODO: This will be deprecated because state should always keep a consistent + * type signature and the only use case for this, is to avoid that. + */ + replaceState: function(newState, callback) { + this.updater.enqueueReplaceState(this, newState, callback); + }, + + /** + * Checks whether or not this composite component is mounted. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ + isMounted: function() { + if (true) { + warning( + this.__didWarnIsMounted, + '%s: isMounted is deprecated. Instead, make sure to clean up ' + + 'subscriptions and pending requests in componentWillUnmount to ' + + 'prevent memory leaks.', + (this.constructor && this.constructor.displayName) || + this.name || + 'Component' + ); + this.__didWarnIsMounted = true; + } + return !!this.__isMounted; + } + }; + + var ReactClassComponent = function() {}; + _assign( + ReactClassComponent.prototype, + ReactComponent.prototype, + ReactClassMixin + ); + + /** + * Creates a composite component class given a class specification. + * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass + * + * @param {object} spec Class specification (which must define `render`). + * @return {function} Component constructor function. + * @public + */ + function createClass(spec) { + // To keep our warnings more understandable, we'll use a little hack here to + // ensure that Constructor.name !== 'Constructor'. This makes sure we don't + // unnecessarily identify a class without displayName as 'Constructor'. + var Constructor = identity(function(props, context, updater) { + // This constructor gets overridden by mocks. The argument is used + // by mocks to assert on what gets mounted. + + if (true) { + warning( + this instanceof Constructor, + 'Something is calling a React component directly. Use a factory or ' + + 'JSX instead. See: https://fb.me/react-legacyfactory' + ); + } + + // Wire up auto-binding + if (this.__reactAutoBindPairs.length) { + bindAutoBindMethods(this); + } + + this.props = props; + this.context = context; + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + + this.state = null; + + // ReactClasses doesn't have constructors. Instead, they use the + // getInitialState and componentWillMount methods for initialization. + + var initialState = this.getInitialState ? this.getInitialState() : null; + if (true) { + // We allow auto-mocks to proceed as if they're returning null. + if ( + initialState === undefined && + this.getInitialState._isMockFunction + ) { + // This is probably bad practice. Consider warning here and + // deprecating this convenience. + initialState = null; + } + } + _invariant( + typeof initialState === 'object' && !Array.isArray(initialState), + '%s.getInitialState(): must return an object or null', + Constructor.displayName || 'ReactCompositeComponent' + ); + + this.state = initialState; + }); + Constructor.prototype = new ReactClassComponent(); + Constructor.prototype.constructor = Constructor; + Constructor.prototype.__reactAutoBindPairs = []; + + injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor)); + + mixSpecIntoComponent(Constructor, IsMountedPreMixin); + mixSpecIntoComponent(Constructor, spec); + mixSpecIntoComponent(Constructor, IsMountedPostMixin); + + // Initialize the defaultProps property after all mixins have been merged. + if (Constructor.getDefaultProps) { + Constructor.defaultProps = Constructor.getDefaultProps(); + } + + if (true) { + // This is a tag to indicate that the use of these method names is ok, + // since it's used with createClass. If it's not, then it's likely a + // mistake so we'll warn you to use the static property, property + // initializer or constructor respectively. + if (Constructor.getDefaultProps) { + Constructor.getDefaultProps.isReactClassApproved = {}; + } + if (Constructor.prototype.getInitialState) { + Constructor.prototype.getInitialState.isReactClassApproved = {}; + } + } + + _invariant( + Constructor.prototype.render, + 'createClass(...): Class specification must implement a `render` method.' + ); + + if (true) { + warning( + !Constructor.prototype.componentShouldUpdate, + '%s has a method called ' + + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + + 'The name is phrased as a question because the function is ' + + 'expected to return a value.', + spec.displayName || 'A component' + ); + warning( + !Constructor.prototype.componentWillRecieveProps, + '%s has a method called ' + + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', + spec.displayName || 'A component' + ); + } + + // Reduce time spent doing lookups by setting these on the prototype. + for (var methodName in ReactClassInterface) { + if (!Constructor.prototype[methodName]) { + Constructor.prototype[methodName] = null; + } + } + + return Constructor; + } + + return createClass; +} + +module.exports = factory; + + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE_1__; + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var React = __webpack_require__(1); +var factory = __webpack_require__(0); + +if (typeof React === 'undefined') { + throw Error( + 'create-react-class could not find the React object. If you are using script tags, ' + + 'make sure that React is being loaded before create-react-class.' + ); +} + +// Hack to grab NoopUpdateQueue from isomorphic React +var ReactNoopUpdateQueue = new React.Component().updater; + +module.exports = factory( + React.Component, + React.isValidElement, + ReactNoopUpdateQueue +); + + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + * + */ + +function makeEmptyFunction(arg) { + return function () { + return arg; + }; +} + +/** + * This function accepts and discards inputs; it has no side effects. This is + * primarily useful idiomatically for overridable function endpoints which + * always need to be callable, since JS lacks a null-call idiom ala Cocoa. + */ +var emptyFunction = function emptyFunction() {}; + +emptyFunction.thatReturns = makeEmptyFunction; +emptyFunction.thatReturnsFalse = makeEmptyFunction(false); +emptyFunction.thatReturnsTrue = makeEmptyFunction(true); +emptyFunction.thatReturnsNull = makeEmptyFunction(null); +emptyFunction.thatReturnsThis = function () { + return this; +}; +emptyFunction.thatReturnsArgument = function (arg) { + return arg; +}; + +module.exports = emptyFunction; + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + */ + + + +var emptyObject = {}; + +if (true) { + Object.freeze(emptyObject); +} + +module.exports = emptyObject; + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + */ + + + +/** + * Use invariant() to assert state which your program assumes to be true. + * + * Provide sprintf-style format (only %s is supported) and arguments + * to provide information about what broke and what you were + * expecting. + * + * The invariant message will be stripped in production, but the invariant + * will remain to ensure logic does not differ in production. + */ + +var validateFormat = function validateFormat(format) {}; + +if (true) { + validateFormat = function validateFormat(format) { + if (format === undefined) { + throw new Error('invariant requires an error message argument'); + } + }; +} + +function invariant(condition, format, a, b, c, d, e, f) { + validateFormat(format); + + if (!condition) { + var error; + if (format === undefined) { + error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); + } else { + var args = [a, b, c, d, e, f]; + var argIndex = 0; + error = new Error(format.replace(/%s/g, function () { + return args[argIndex++]; + })); + error.name = 'Invariant Violation'; + } + + error.framesToPop = 1; // we don't care about invariant's own frame + throw error; + } +} + +module.exports = invariant; + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright 2014-2015, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + */ + + + +var emptyFunction = __webpack_require__(3); + +/** + * Similar to invariant but only logs a warning if the condition is not met. + * This can be used to log issues in development environments in critical + * paths. Removing the logging code for production environments will keep the + * same logic and follow the same code paths. + */ + +var warning = emptyFunction; + +if (true) { + (function () { + var printWarning = function printWarning(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + var argIndex = 0; + var message = 'Warning: ' + format.replace(/%s/g, function () { + return args[argIndex++]; + }); + if (typeof console !== 'undefined') { + console.error(message); + } + try { + // --- Welcome to debugging React --- + // This error was thrown as a convenience so that you can use this stack + // to find the callsite that caused this warning to fire. + throw new Error(message); + } catch (x) {} + }; + + warning = function warning(condition, format) { + if (format === undefined) { + throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); + } + + if (format.indexOf('Failed Composite propType: ') === 0) { + return; // Ignore CompositeComponent proptype check. + } + + if (!condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } + + printWarning.apply(undefined, [format].concat(args)); + } + }; + })(); +} + +module.exports = warning; + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* +object-assign +(c) Sindre Sorhus +@license MIT +*/ + + +/* eslint-disable no-unused-vars */ +var getOwnPropertySymbols = Object.getOwnPropertySymbols; +var hasOwnProperty = Object.prototype.hasOwnProperty; +var propIsEnumerable = Object.prototype.propertyIsEnumerable; + +function toObject(val) { + if (val === null || val === undefined) { + throw new TypeError('Object.assign cannot be called with null or undefined'); + } + + return Object(val); +} + +function shouldUseNative() { + try { + if (!Object.assign) { + return false; + } + + // Detect buggy property enumeration order in older V8 versions. + + // https://bugs.chromium.org/p/v8/issues/detail?id=4118 + var test1 = new String('abc'); // eslint-disable-line no-new-wrappers + test1[5] = 'de'; + if (Object.getOwnPropertyNames(test1)[0] === '5') { + return false; + } + + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test2 = {}; + for (var i = 0; i < 10; i++) { + test2['_' + String.fromCharCode(i)] = i; + } + var order2 = Object.getOwnPropertyNames(test2).map(function (n) { + return test2[n]; + }); + if (order2.join('') !== '0123456789') { + return false; + } + + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test3 = {}; + 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { + test3[letter] = letter; + }); + if (Object.keys(Object.assign({}, test3)).join('') !== + 'abcdefghijklmnopqrst') { + return false; + } + + return true; + } catch (err) { + // We don't expect any of the above to throw, but better to be safe. + return false; + } +} + +module.exports = shouldUseNative() ? Object.assign : function (target, source) { + var from; + var to = toObject(target); + var symbols; + + for (var s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); + + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) { + if (propIsEnumerable.call(from, symbols[i])) { + to[symbols[i]] = from[symbols[i]]; + } + } + } + } + + return to; +}; + + +/***/ }) +/******/ ]); +}); \ No newline at end of file diff --git a/js/cljsjs/react-dom/production/react-dom.min.inc.js b/js/cljsjs/react-dom/production/react-dom.min.inc.js new file mode 100644 index 0000000..d461fae --- /dev/null +++ b/js/cljsjs/react-dom/production/react-dom.min.inc.js @@ -0,0 +1,17098 @@ +/** @license React v16.3.0 + * react-dom.development.js + * + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +'use strict'; + +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) : + typeof define === 'function' && define.amd ? define(['react'], factory) : + (global.ReactDOM = factory(global.React)); +}(this, (function (React) { 'use strict'; + +/** + * WARNING: DO NOT manually require this module. + * This is a replacement for `invariant(...)` used by the error code system + * and will _only_ be required by the corresponding babel pass. + * It always throws. + */ + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +/** + * Use invariant() to assert state which your program assumes to be true. + * + * Provide sprintf-style format (only %s is supported) and arguments + * to provide information about what broke and what you were + * expecting. + * + * The invariant message will be stripped in production, but the invariant + * will remain to ensure logic does not differ in production. + */ + +var validateFormat = function validateFormat(format) {}; + +{ + validateFormat = function validateFormat(format) { + if (format === undefined) { + throw new Error('invariant requires an error message argument'); + } + }; +} + +function invariant(condition, format, a, b, c, d, e, f) { + validateFormat(format); + + if (!condition) { + var error; + if (format === undefined) { + error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); + } else { + var args = [a, b, c, d, e, f]; + var argIndex = 0; + error = new Error(format.replace(/%s/g, function () { + return args[argIndex++]; + })); + error.name = 'Invariant Violation'; + } + + error.framesToPop = 1; // we don't care about invariant's own frame + throw error; + } +} + +var invariant_1 = invariant; + +!React ? invariant_1(false, 'ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.') : void 0; + +var invokeGuardedCallback = function (name, func, context, a, b, c, d, e, f) { + this._hasCaughtError = false; + this._caughtError = null; + var funcArgs = Array.prototype.slice.call(arguments, 3); + try { + func.apply(context, funcArgs); + } catch (error) { + this._caughtError = error; + this._hasCaughtError = true; + } +}; + +{ + // In DEV mode, we swap out invokeGuardedCallback for a special version + // that plays more nicely with the browser's DevTools. The idea is to preserve + // "Pause on exceptions" behavior. Because React wraps all user-provided + // functions in invokeGuardedCallback, and the production version of + // invokeGuardedCallback uses a try-catch, all user exceptions are treated + // like caught exceptions, and the DevTools won't pause unless the developer + // takes the extra step of enabling pause on caught exceptions. This is + // untintuitive, though, because even though React has caught the error, from + // the developer's perspective, the error is uncaught. + // + // To preserve the expected "Pause on exceptions" behavior, we don't use a + // try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake + // DOM node, and call the user-provided callback from inside an event handler + // for that fake event. If the callback throws, the error is "captured" using + // a global event handler. But because the error happens in a different + // event loop context, it does not interrupt the normal program flow. + // Effectively, this gives us try-catch behavior without actually using + // try-catch. Neat! + + // Check that the browser supports the APIs we need to implement our special + // DEV version of invokeGuardedCallback + if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') { + var fakeNode = document.createElement('react'); + + var invokeGuardedCallbackDev = function (name, func, context, a, b, c, d, e, f) { + // If document doesn't exist we know for sure we will crash in this method + // when we call document.createEvent(). However this can cause confusing + // errors: https://github.com/facebookincubator/create-react-app/issues/3482 + // So we preemptively throw with a better message instead. + !(typeof document !== 'undefined') ? invariant_1(false, 'The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous.') : void 0; + var evt = document.createEvent('Event'); + + // Keeps track of whether the user-provided callback threw an error. We + // set this to true at the beginning, then set it to false right after + // calling the function. If the function errors, `didError` will never be + // set to false. This strategy works even if the browser is flaky and + // fails to call our global error handler, because it doesn't rely on + // the error event at all. + var didError = true; + + // Create an event handler for our fake event. We will synchronously + // dispatch our fake event using `dispatchEvent`. Inside the handler, we + // call the user-provided callback. + var funcArgs = Array.prototype.slice.call(arguments, 3); + function callCallback() { + // We immediately remove the callback from event listeners so that + // nested `invokeGuardedCallback` calls do not clash. Otherwise, a + // nested call would trigger the fake event handlers of any call higher + // in the stack. + fakeNode.removeEventListener(evtType, callCallback, false); + func.apply(context, funcArgs); + didError = false; + } + + // Create a global error event handler. We use this to capture the value + // that was thrown. It's possible that this error handler will fire more + // than once; for example, if non-React code also calls `dispatchEvent` + // and a handler for that event throws. We should be resilient to most of + // those cases. Even if our error event handler fires more than once, the + // last error event is always used. If the callback actually does error, + // we know that the last error event is the correct one, because it's not + // possible for anything else to have happened in between our callback + // erroring and the code that follows the `dispatchEvent` call below. If + // the callback doesn't error, but the error event was fired, we know to + // ignore it because `didError` will be false, as described above. + var error = void 0; + // Use this to track whether the error event is ever called. + var didSetError = false; + var isCrossOriginError = false; + + function onError(event) { + error = event.error; + didSetError = true; + if (error === null && event.colno === 0 && event.lineno === 0) { + isCrossOriginError = true; + } + } + + // Create a fake event type. + var evtType = 'react-' + (name ? name : 'invokeguardedcallback'); + + // Attach our event handlers + window.addEventListener('error', onError); + fakeNode.addEventListener(evtType, callCallback, false); + + // Synchronously dispatch our fake event. If the user-provided function + // errors, it will trigger our global error handler. + evt.initEvent(evtType, false, false); + fakeNode.dispatchEvent(evt); + + if (didError) { + if (!didSetError) { + // The callback errored, but the error event never fired. + error = new Error('An error was thrown inside one of your components, but React ' + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + 'your browser. Try triggering the error in production mode, ' + 'or switching to a modern browser. If you suspect that this is ' + 'actually an issue with React, please file an issue.'); + } else if (isCrossOriginError) { + error = new Error("A cross-origin error was thrown. React doesn't have access to " + 'the actual error object in development. ' + 'See https://fb.me/react-crossorigin-error for more information.'); + } + this._hasCaughtError = true; + this._caughtError = error; + } else { + this._hasCaughtError = false; + this._caughtError = null; + } + + // Remove our event listeners + window.removeEventListener('error', onError); + }; + + invokeGuardedCallback = invokeGuardedCallbackDev; + } +} + +var invokeGuardedCallback$1 = invokeGuardedCallback; + +var ReactErrorUtils = { + // Used by Fiber to simulate a try-catch. + _caughtError: null, + _hasCaughtError: false, + + // Used by event system to capture/rethrow the first error. + _rethrowError: null, + _hasRethrowError: false, + + /** + * Call a function while guarding against errors that happens within it. + * Returns an error if it throws, otherwise null. + * + * In production, this is implemented using a try-catch. The reason we don't + * use a try-catch directly is so that we can swap out a different + * implementation in DEV mode. + * + * @param {String} name of the guard to use for logging or debugging + * @param {Function} func The function to invoke + * @param {*} context The context to use when calling the function + * @param {...*} args Arguments for function + */ + invokeGuardedCallback: function (name, func, context, a, b, c, d, e, f) { + invokeGuardedCallback$1.apply(ReactErrorUtils, arguments); + }, + + /** + * Same as invokeGuardedCallback, but instead of returning an error, it stores + * it in a global so it can be rethrown by `rethrowCaughtError` later. + * TODO: See if _caughtError and _rethrowError can be unified. + * + * @param {String} name of the guard to use for logging or debugging + * @param {Function} func The function to invoke + * @param {*} context The context to use when calling the function + * @param {...*} args Arguments for function + */ + invokeGuardedCallbackAndCatchFirstError: function (name, func, context, a, b, c, d, e, f) { + ReactErrorUtils.invokeGuardedCallback.apply(this, arguments); + if (ReactErrorUtils.hasCaughtError()) { + var error = ReactErrorUtils.clearCaughtError(); + if (!ReactErrorUtils._hasRethrowError) { + ReactErrorUtils._hasRethrowError = true; + ReactErrorUtils._rethrowError = error; + } + } + }, + + /** + * During execution of guarded functions we will capture the first error which + * we will rethrow to be handled by the top level error handler. + */ + rethrowCaughtError: function () { + return rethrowCaughtError.apply(ReactErrorUtils, arguments); + }, + + hasCaughtError: function () { + return ReactErrorUtils._hasCaughtError; + }, + + clearCaughtError: function () { + if (ReactErrorUtils._hasCaughtError) { + var error = ReactErrorUtils._caughtError; + ReactErrorUtils._caughtError = null; + ReactErrorUtils._hasCaughtError = false; + return error; + } else { + invariant_1(false, 'clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.'); + } + } +}; + +var rethrowCaughtError = function () { + if (ReactErrorUtils._hasRethrowError) { + var error = ReactErrorUtils._rethrowError; + ReactErrorUtils._rethrowError = null; + ReactErrorUtils._hasRethrowError = false; + throw error; + } +}; + +/** + * Injectable ordering of event plugins. + */ +var eventPluginOrder = null; + +/** + * Injectable mapping from names to event plugin modules. + */ +var namesToPlugins = {}; + +/** + * Recomputes the plugin list using the injected plugins and plugin ordering. + * + * @private + */ +function recomputePluginOrdering() { + if (!eventPluginOrder) { + // Wait until an `eventPluginOrder` is injected. + return; + } + for (var pluginName in namesToPlugins) { + var pluginModule = namesToPlugins[pluginName]; + var pluginIndex = eventPluginOrder.indexOf(pluginName); + !(pluginIndex > -1) ? invariant_1(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : void 0; + if (plugins[pluginIndex]) { + continue; + } + !pluginModule.extractEvents ? invariant_1(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : void 0; + plugins[pluginIndex] = pluginModule; + var publishedEvents = pluginModule.eventTypes; + for (var eventName in publishedEvents) { + !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? invariant_1(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : void 0; + } + } +} + +/** + * Publishes an event so that it can be dispatched by the supplied plugin. + * + * @param {object} dispatchConfig Dispatch configuration for the event. + * @param {object} PluginModule Plugin publishing the event. + * @return {boolean} True if the event was successfully published. + * @private + */ +function publishEventForPlugin(dispatchConfig, pluginModule, eventName) { + !!eventNameDispatchConfigs.hasOwnProperty(eventName) ? invariant_1(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : void 0; + eventNameDispatchConfigs[eventName] = dispatchConfig; + + var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames; + if (phasedRegistrationNames) { + for (var phaseName in phasedRegistrationNames) { + if (phasedRegistrationNames.hasOwnProperty(phaseName)) { + var phasedRegistrationName = phasedRegistrationNames[phaseName]; + publishRegistrationName(phasedRegistrationName, pluginModule, eventName); + } + } + return true; + } else if (dispatchConfig.registrationName) { + publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName); + return true; + } + return false; +} + +/** + * Publishes a registration name that is used to identify dispatched events. + * + * @param {string} registrationName Registration name to add. + * @param {object} PluginModule Plugin publishing the event. + * @private + */ +function publishRegistrationName(registrationName, pluginModule, eventName) { + !!registrationNameModules[registrationName] ? invariant_1(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : void 0; + registrationNameModules[registrationName] = pluginModule; + registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies; + + { + var lowerCasedName = registrationName.toLowerCase(); + possibleRegistrationNames[lowerCasedName] = registrationName; + + if (registrationName === 'onDoubleClick') { + possibleRegistrationNames.ondblclick = registrationName; + } + } +} + +/** + * Registers plugins so that they can extract and dispatch events. + * + * @see {EventPluginHub} + */ + +/** + * Ordered list of injected plugins. + */ +var plugins = []; + +/** + * Mapping from event name to dispatch config + */ +var eventNameDispatchConfigs = {}; + +/** + * Mapping from registration name to plugin module + */ +var registrationNameModules = {}; + +/** + * Mapping from registration name to event name + */ +var registrationNameDependencies = {}; + +/** + * Mapping from lowercase registration names to the properly cased version, + * used to warn in the case of missing event handlers. Available + * only in true. + * @type {Object} + */ +var possibleRegistrationNames = {}; +// Trust the developer to only use possibleRegistrationNames in true + +/** + * Injects an ordering of plugins (by plugin name). This allows the ordering + * to be decoupled from injection of the actual plugins so that ordering is + * always deterministic regardless of packaging, on-the-fly injection, etc. + * + * @param {array} InjectedEventPluginOrder + * @internal + * @see {EventPluginHub.injection.injectEventPluginOrder} + */ +function injectEventPluginOrder(injectedEventPluginOrder) { + !!eventPluginOrder ? invariant_1(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : void 0; + // Clone the ordering so it cannot be dynamically mutated. + eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder); + recomputePluginOrdering(); +} + +/** + * Injects plugins to be used by `EventPluginHub`. The plugin names must be + * in the ordering injected by `injectEventPluginOrder`. + * + * Plugins can be injected as part of page initialization or on-the-fly. + * + * @param {object} injectedNamesToPlugins Map from names to plugin modules. + * @internal + * @see {EventPluginHub.injection.injectEventPluginsByName} + */ +function injectEventPluginsByName(injectedNamesToPlugins) { + var isOrderingDirty = false; + for (var pluginName in injectedNamesToPlugins) { + if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) { + continue; + } + var pluginModule = injectedNamesToPlugins[pluginName]; + if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) { + !!namesToPlugins[pluginName] ? invariant_1(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : void 0; + namesToPlugins[pluginName] = pluginModule; + isOrderingDirty = true; + } + } + if (isOrderingDirty) { + recomputePluginOrdering(); + } +} + +var EventPluginRegistry = Object.freeze({ + plugins: plugins, + eventNameDispatchConfigs: eventNameDispatchConfigs, + registrationNameModules: registrationNameModules, + registrationNameDependencies: registrationNameDependencies, + possibleRegistrationNames: possibleRegistrationNames, + injectEventPluginOrder: injectEventPluginOrder, + injectEventPluginsByName: injectEventPluginsByName +}); + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * + */ + +function makeEmptyFunction(arg) { + return function () { + return arg; + }; +} + +/** + * This function accepts and discards inputs; it has no side effects. This is + * primarily useful idiomatically for overridable function endpoints which + * always need to be callable, since JS lacks a null-call idiom ala Cocoa. + */ +var emptyFunction = function emptyFunction() {}; + +emptyFunction.thatReturns = makeEmptyFunction; +emptyFunction.thatReturnsFalse = makeEmptyFunction(false); +emptyFunction.thatReturnsTrue = makeEmptyFunction(true); +emptyFunction.thatReturnsNull = makeEmptyFunction(null); +emptyFunction.thatReturnsThis = function () { + return this; +}; +emptyFunction.thatReturnsArgument = function (arg) { + return arg; +}; + +var emptyFunction_1 = emptyFunction; + +/** + * Copyright (c) 2014-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + + + +/** + * Similar to invariant but only logs a warning if the condition is not met. + * This can be used to log issues in development environments in critical + * paths. Removing the logging code for production environments will keep the + * same logic and follow the same code paths. + */ + +var warning = emptyFunction_1; + +{ + var printWarning = function printWarning(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + var argIndex = 0; + var message = 'Warning: ' + format.replace(/%s/g, function () { + return args[argIndex++]; + }); + if (typeof console !== 'undefined') { + console.error(message); + } + try { + // --- Welcome to debugging React --- + // This error was thrown as a convenience so that you can use this stack + // to find the callsite that caused this warning to fire. + throw new Error(message); + } catch (x) {} + }; + + warning = function warning(condition, format) { + if (format === undefined) { + throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); + } + + if (format.indexOf('Failed Composite propType: ') === 0) { + return; // Ignore CompositeComponent proptype check. + } + + if (!condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } + + printWarning.apply(undefined, [format].concat(args)); + } + }; +} + +var warning_1 = warning; + +var getFiberCurrentPropsFromNode = null; +var getInstanceFromNode = null; +var getNodeFromInstance = null; + +var injection$1 = { + injectComponentTree: function (Injected) { + getFiberCurrentPropsFromNode = Injected.getFiberCurrentPropsFromNode; + getInstanceFromNode = Injected.getInstanceFromNode; + getNodeFromInstance = Injected.getNodeFromInstance; + + { + warning_1(getNodeFromInstance && getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.'); + } + } +}; + + + + + + +var validateEventDispatches = void 0; +{ + validateEventDispatches = function (event) { + var dispatchListeners = event._dispatchListeners; + var dispatchInstances = event._dispatchInstances; + + var listenersIsArr = Array.isArray(dispatchListeners); + var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0; + + var instancesIsArr = Array.isArray(dispatchInstances); + var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0; + + warning_1(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.'); + }; +} + +/** + * Dispatch the event to the listener. + * @param {SyntheticEvent} event SyntheticEvent to handle + * @param {boolean} simulated If the event is simulated (changes exn behavior) + * @param {function} listener Application-level callback + * @param {*} inst Internal component instance + */ +function executeDispatch(event, simulated, listener, inst) { + var type = event.type || 'unknown-event'; + event.currentTarget = getNodeFromInstance(inst); + ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event); + event.currentTarget = null; +} + +/** + * Standard/simple iteration through an event's collected dispatches. + */ +function executeDispatchesInOrder(event, simulated) { + var dispatchListeners = event._dispatchListeners; + var dispatchInstances = event._dispatchInstances; + { + validateEventDispatches(event); + } + if (Array.isArray(dispatchListeners)) { + for (var i = 0; i < dispatchListeners.length; i++) { + if (event.isPropagationStopped()) { + break; + } + // Listeners and Instances are two parallel arrays that are always in sync. + executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); + } + } else if (dispatchListeners) { + executeDispatch(event, simulated, dispatchListeners, dispatchInstances); + } + event._dispatchListeners = null; + event._dispatchInstances = null; +} + +/** + * @see executeDispatchesInOrderStopAtTrueImpl + */ + + +/** + * Execution of a "direct" dispatch - there must be at most one dispatch + * accumulated on the event or it is considered an error. It doesn't really make + * sense for an event with multiple dispatches (bubbled) to keep track of the + * return values at each dispatch execution, but it does tend to make sense when + * dealing with "direct" dispatches. + * + * @return {*} The return value of executing the single dispatch. + */ + + +/** + * @param {SyntheticEvent} event + * @return {boolean} True iff number of dispatches accumulated is greater than 0. + */ + +/** + * Accumulates items that must not be null or undefined into the first one. This + * is used to conserve memory by avoiding array allocations, and thus sacrifices + * API cleanness. Since `current` can be null before being passed in and not + * null after this function, make sure to assign it back to `current`: + * + * `a = accumulateInto(a, b);` + * + * This API should be sparingly used. Try `accumulate` for something cleaner. + * + * @return {*|array<*>} An accumulation of items. + */ + +function accumulateInto(current, next) { + !(next != null) ? invariant_1(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : void 0; + + if (current == null) { + return next; + } + + // Both are not empty. Warning: Never call x.concat(y) when you are not + // certain that x is an Array (x could be a string with concat method). + if (Array.isArray(current)) { + if (Array.isArray(next)) { + current.push.apply(current, next); + return current; + } + current.push(next); + return current; + } + + if (Array.isArray(next)) { + // A bit too dangerous to mutate `next`. + return [current].concat(next); + } + + return [current, next]; +} + +/** + * @param {array} arr an "accumulation" of items which is either an Array or + * a single item. Useful when paired with the `accumulate` module. This is a + * simple utility that allows us to reason about a collection of items, but + * handling the case when there is exactly one item (and we do not need to + * allocate an array). + * @param {function} cb Callback invoked with each element or a collection. + * @param {?} [scope] Scope used as `this` in a callback. + */ +function forEachAccumulated(arr, cb, scope) { + if (Array.isArray(arr)) { + arr.forEach(cb, scope); + } else if (arr) { + cb.call(scope, arr); + } +} + +/** + * Internal queue of events that have accumulated their dispatches and are + * waiting to have their dispatches executed. + */ +var eventQueue = null; + +/** + * Dispatches an event and releases it back into the pool, unless persistent. + * + * @param {?object} event Synthetic event to be dispatched. + * @param {boolean} simulated If the event is simulated (changes exn behavior) + * @private + */ +var executeDispatchesAndRelease = function (event, simulated) { + if (event) { + executeDispatchesInOrder(event, simulated); + + if (!event.isPersistent()) { + event.constructor.release(event); + } + } +}; +var executeDispatchesAndReleaseSimulated = function (e) { + return executeDispatchesAndRelease(e, true); +}; +var executeDispatchesAndReleaseTopLevel = function (e) { + return executeDispatchesAndRelease(e, false); +}; + +function isInteractive(tag) { + return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea'; +} + +function shouldPreventMouseEvent(name, type, props) { + switch (name) { + case 'onClick': + case 'onClickCapture': + case 'onDoubleClick': + case 'onDoubleClickCapture': + case 'onMouseDown': + case 'onMouseDownCapture': + case 'onMouseMove': + case 'onMouseMoveCapture': + case 'onMouseUp': + case 'onMouseUpCapture': + return !!(props.disabled && isInteractive(type)); + default: + return false; + } +} + +/** + * This is a unified interface for event plugins to be installed and configured. + * + * Event plugins can implement the following properties: + * + * `extractEvents` {function(string, DOMEventTarget, string, object): *} + * Required. When a top-level event is fired, this method is expected to + * extract synthetic events that will in turn be queued and dispatched. + * + * `eventTypes` {object} + * Optional, plugins that fire events must publish a mapping of registration + * names that are used to register listeners. Values of this mapping must + * be objects that contain `registrationName` or `phasedRegistrationNames`. + * + * `executeDispatch` {function(object, function, string)} + * Optional, allows plugins to override how an event gets dispatched. By + * default, the listener is simply invoked. + * + * Each plugin that is injected into `EventsPluginHub` is immediately operable. + * + * @public + */ + +/** + * Methods for injecting dependencies. + */ +var injection = { + /** + * @param {array} InjectedEventPluginOrder + * @public + */ + injectEventPluginOrder: injectEventPluginOrder, + + /** + * @param {object} injectedNamesToPlugins Map from names to plugin modules. + */ + injectEventPluginsByName: injectEventPluginsByName +}; + +/** + * @param {object} inst The instance, which is the source of events. + * @param {string} registrationName Name of listener (e.g. `onClick`). + * @return {?function} The stored callback. + */ +function getListener(inst, registrationName) { + var listener = void 0; + + // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not + // live here; needs to be moved to a better place soon + var stateNode = inst.stateNode; + if (!stateNode) { + // Work in progress (ex: onload events in incremental mode). + return null; + } + var props = getFiberCurrentPropsFromNode(stateNode); + if (!props) { + // Work in progress. + return null; + } + listener = props[registrationName]; + if (shouldPreventMouseEvent(registrationName, inst.type, props)) { + return null; + } + !(!listener || typeof listener === 'function') ? invariant_1(false, 'Expected `%s` listener to be a function, instead got a value of `%s` type.', registrationName, typeof listener) : void 0; + return listener; +} + +/** + * Allows registered plugins an opportunity to extract events from top-level + * native browser events. + * + * @return {*} An accumulation of synthetic events. + * @internal + */ +function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var events = null; + for (var i = 0; i < plugins.length; i++) { + // Not every plugin in the ordering may be loaded at runtime. + var possiblePlugin = plugins[i]; + if (possiblePlugin) { + var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget); + if (extractedEvents) { + events = accumulateInto(events, extractedEvents); + } + } + } + return events; +} + +function runEventsInBatch(events, simulated) { + if (events !== null) { + eventQueue = accumulateInto(eventQueue, events); + } + + // Set `eventQueue` to null before processing it so that we can tell if more + // events get enqueued while processing. + var processingEventQueue = eventQueue; + eventQueue = null; + + if (!processingEventQueue) { + return; + } + + if (simulated) { + forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated); + } else { + forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel); + } + !!eventQueue ? invariant_1(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : void 0; + // This would be a good time to rethrow if any of the event handlers threw. + ReactErrorUtils.rethrowCaughtError(); +} + +function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget); + runEventsInBatch(events, false); +} + +var EventPluginHub = Object.freeze({ + injection: injection, + getListener: getListener, + runEventsInBatch: runEventsInBatch, + runExtractedEventsInBatch: runExtractedEventsInBatch +}); + +var IndeterminateComponent = 0; // Before we know whether it is functional or class +var FunctionalComponent = 1; +var ClassComponent = 2; +var HostRoot = 3; // Root of a host tree. Could be nested inside another node. +var HostPortal = 4; // A subtree. Could be an entry point to a different renderer. +var HostComponent = 5; +var HostText = 6; +var CallComponent = 7; +var CallHandlerPhase = 8; +var ReturnComponent = 9; +var Fragment = 10; +var Mode = 11; +var ContextConsumer = 12; +var ContextProvider = 13; +var ForwardRef = 14; + +var randomKey = Math.random().toString(36).slice(2); +var internalInstanceKey = '__reactInternalInstance$' + randomKey; +var internalEventHandlersKey = '__reactEventHandlers$' + randomKey; + +function precacheFiberNode$1(hostInst, node) { + node[internalInstanceKey] = hostInst; +} + +/** + * Given a DOM node, return the closest ReactDOMComponent or + * ReactDOMTextComponent instance ancestor. + */ +function getClosestInstanceFromNode(node) { + if (node[internalInstanceKey]) { + return node[internalInstanceKey]; + } + + while (!node[internalInstanceKey]) { + if (node.parentNode) { + node = node.parentNode; + } else { + // Top of the tree. This node must not be part of a React tree (or is + // unmounted, potentially). + return null; + } + } + + var inst = node[internalInstanceKey]; + if (inst.tag === HostComponent || inst.tag === HostText) { + // In Fiber, this will always be the deepest root. + return inst; + } + + return null; +} + +/** + * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent + * instance, or null if the node was not rendered by this React. + */ +function getInstanceFromNode$1(node) { + var inst = node[internalInstanceKey]; + if (inst) { + if (inst.tag === HostComponent || inst.tag === HostText) { + return inst; + } else { + return null; + } + } + return null; +} + +/** + * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding + * DOM node. + */ +function getNodeFromInstance$1(inst) { + if (inst.tag === HostComponent || inst.tag === HostText) { + // In Fiber this, is just the state node right now. We assume it will be + // a host component or host text. + return inst.stateNode; + } + + // Without this first invariant, passing a non-DOM-component triggers the next + // invariant for a missing parent, which is super confusing. + invariant_1(false, 'getNodeFromInstance: Invalid argument.'); +} + +function getFiberCurrentPropsFromNode$1(node) { + return node[internalEventHandlersKey] || null; +} + +function updateFiberProps$1(node, props) { + node[internalEventHandlersKey] = props; +} + +var ReactDOMComponentTree = Object.freeze({ + precacheFiberNode: precacheFiberNode$1, + getClosestInstanceFromNode: getClosestInstanceFromNode, + getInstanceFromNode: getInstanceFromNode$1, + getNodeFromInstance: getNodeFromInstance$1, + getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode$1, + updateFiberProps: updateFiberProps$1 +}); + +function getParent(inst) { + do { + inst = inst['return']; + // TODO: If this is a HostRoot we might want to bail out. + // That is depending on if we want nested subtrees (layers) to bubble + // events to their parent. We could also go through parentNode on the + // host node but that wouldn't work for React Native and doesn't let us + // do the portal feature. + } while (inst && inst.tag !== HostComponent); + if (inst) { + return inst; + } + return null; +} + +/** + * Return the lowest common ancestor of A and B, or null if they are in + * different trees. + */ +function getLowestCommonAncestor(instA, instB) { + var depthA = 0; + for (var tempA = instA; tempA; tempA = getParent(tempA)) { + depthA++; + } + var depthB = 0; + for (var tempB = instB; tempB; tempB = getParent(tempB)) { + depthB++; + } + + // If A is deeper, crawl up. + while (depthA - depthB > 0) { + instA = getParent(instA); + depthA--; + } + + // If B is deeper, crawl up. + while (depthB - depthA > 0) { + instB = getParent(instB); + depthB--; + } + + // Walk in lockstep until we find a match. + var depth = depthA; + while (depth--) { + if (instA === instB || instA === instB.alternate) { + return instA; + } + instA = getParent(instA); + instB = getParent(instB); + } + return null; +} + +/** + * Return if A is an ancestor of B. + */ + + +/** + * Return the parent instance of the passed-in instance. + */ +function getParentInstance(inst) { + return getParent(inst); +} + +/** + * Simulates the traversal of a two-phase, capture/bubble event dispatch. + */ +function traverseTwoPhase(inst, fn, arg) { + var path = []; + while (inst) { + path.push(inst); + inst = getParent(inst); + } + var i = void 0; + for (i = path.length; i-- > 0;) { + fn(path[i], 'captured', arg); + } + for (i = 0; i < path.length; i++) { + fn(path[i], 'bubbled', arg); + } +} + +/** + * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that + * should would receive a `mouseEnter` or `mouseLeave` event. + * + * Does not invoke the callback on the nearest common ancestor because nothing + * "entered" or "left" that element. + */ +function traverseEnterLeave(from, to, fn, argFrom, argTo) { + var common = from && to ? getLowestCommonAncestor(from, to) : null; + var pathFrom = []; + while (true) { + if (!from) { + break; + } + if (from === common) { + break; + } + var alternate = from.alternate; + if (alternate !== null && alternate === common) { + break; + } + pathFrom.push(from); + from = getParent(from); + } + var pathTo = []; + while (true) { + if (!to) { + break; + } + if (to === common) { + break; + } + var _alternate = to.alternate; + if (_alternate !== null && _alternate === common) { + break; + } + pathTo.push(to); + to = getParent(to); + } + for (var i = 0; i < pathFrom.length; i++) { + fn(pathFrom[i], 'bubbled', argFrom); + } + for (var _i = pathTo.length; _i-- > 0;) { + fn(pathTo[_i], 'captured', argTo); + } +} + +/** + * Some event types have a notion of different registration names for different + * "phases" of propagation. This finds listeners by a given phase. + */ +function listenerAtPhase(inst, event, propagationPhase) { + var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase]; + return getListener(inst, registrationName); +} + +/** + * A small set of propagation patterns, each of which will accept a small amount + * of information, and generate a set of "dispatch ready event objects" - which + * are sets of events that have already been annotated with a set of dispatched + * listener functions/ids. The API is designed this way to discourage these + * propagation strategies from actually executing the dispatches, since we + * always want to collect the entire set of dispatches before executing even a + * single one. + */ + +/** + * Tags a `SyntheticEvent` with dispatched listeners. Creating this function + * here, allows us to not have to bind or create functions for each event. + * Mutating the event's members allows us to not have to create a wrapping + * "dispatch" object that pairs the event with the listener. + */ +function accumulateDirectionalDispatches(inst, phase, event) { + { + warning_1(inst, 'Dispatching inst must not be null'); + } + var listener = listenerAtPhase(inst, event, phase); + if (listener) { + event._dispatchListeners = accumulateInto(event._dispatchListeners, listener); + event._dispatchInstances = accumulateInto(event._dispatchInstances, inst); + } +} + +/** + * Collect dispatches (must be entirely collected before dispatching - see unit + * tests). Lazily allocate the array to conserve memory. We must loop through + * each event and perform the traversal for each one. We cannot perform a + * single traversal for the entire collection of events because each event may + * have a different target. + */ +function accumulateTwoPhaseDispatchesSingle(event) { + if (event && event.dispatchConfig.phasedRegistrationNames) { + traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event); + } +} + +/** + * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID. + */ +function accumulateTwoPhaseDispatchesSingleSkipTarget(event) { + if (event && event.dispatchConfig.phasedRegistrationNames) { + var targetInst = event._targetInst; + var parentInst = targetInst ? getParentInstance(targetInst) : null; + traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event); + } +} + +/** + * Accumulates without regard to direction, does not look for phased + * registration names. Same as `accumulateDirectDispatchesSingle` but without + * requiring that the `dispatchMarker` be the same as the dispatched ID. + */ +function accumulateDispatches(inst, ignoredDirection, event) { + if (inst && event && event.dispatchConfig.registrationName) { + var registrationName = event.dispatchConfig.registrationName; + var listener = getListener(inst, registrationName); + if (listener) { + event._dispatchListeners = accumulateInto(event._dispatchListeners, listener); + event._dispatchInstances = accumulateInto(event._dispatchInstances, inst); + } + } +} + +/** + * Accumulates dispatches on an `SyntheticEvent`, but only for the + * `dispatchMarker`. + * @param {SyntheticEvent} event + */ +function accumulateDirectDispatchesSingle(event) { + if (event && event.dispatchConfig.registrationName) { + accumulateDispatches(event._targetInst, null, event); + } +} + +function accumulateTwoPhaseDispatches(events) { + forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle); +} + +function accumulateTwoPhaseDispatchesSkipTarget(events) { + forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget); +} + +function accumulateEnterLeaveDispatches(leave, enter, from, to) { + traverseEnterLeave(from, to, accumulateDispatches, leave, enter); +} + +function accumulateDirectDispatches(events) { + forEachAccumulated(events, accumulateDirectDispatchesSingle); +} + +var EventPropagators = Object.freeze({ + accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches, + accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget, + accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches, + accumulateDirectDispatches: accumulateDirectDispatches +}); + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); + +/** + * Simple, lightweight module assisting with the detection and context of + * Worker. Helps avoid circular dependencies and allows code to reason about + * whether or not they are in a Worker, even if they never include the main + * `ReactWorker` dependency. + */ +var ExecutionEnvironment = { + + canUseDOM: canUseDOM, + + canUseWorkers: typeof Worker !== 'undefined', + + canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent), + + canUseViewport: canUseDOM && !!window.screen, + + isInWorker: !canUseDOM // For now, this is true - might change in the future. + +}; + +var ExecutionEnvironment_1 = ExecutionEnvironment; + +var contentKey = null; + +/** + * Gets the key used to access text content on a DOM node. + * + * @return {?string} Key used to access text content. + * @internal + */ +function getTextContentAccessor() { + if (!contentKey && ExecutionEnvironment_1.canUseDOM) { + // Prefer textContent to innerText because many browsers support both but + // SVG elements don't support innerText even when
does. + contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText'; + } + return contentKey; +} + +/** + * This helper object stores information about text content of a target node, + * allowing comparison of content before and after a given event. + * + * Identify the node where selection currently begins, then observe + * both its text content and its current position in the DOM. Since the + * browser may natively replace the target node during composition, we can + * use its position to find its replacement. + * + * + */ +var compositionState = { + _root: null, + _startText: null, + _fallbackText: null +}; + +function initialize(nativeEventTarget) { + compositionState._root = nativeEventTarget; + compositionState._startText = getText(); + return true; +} + +function reset() { + compositionState._root = null; + compositionState._startText = null; + compositionState._fallbackText = null; +} + +function getData() { + if (compositionState._fallbackText) { + return compositionState._fallbackText; + } + + var start = void 0; + var startValue = compositionState._startText; + var startLength = startValue.length; + var end = void 0; + var endValue = getText(); + var endLength = endValue.length; + + for (start = 0; start < startLength; start++) { + if (startValue[start] !== endValue[start]) { + break; + } + } + + var minEnd = startLength - start; + for (end = 1; end <= minEnd; end++) { + if (startValue[startLength - end] !== endValue[endLength - end]) { + break; + } + } + + var sliceTail = end > 1 ? 1 - end : undefined; + compositionState._fallbackText = endValue.slice(start, sliceTail); + return compositionState._fallbackText; +} + +function getText() { + if ('value' in compositionState._root) { + return compositionState._root.value; + } + return compositionState._root[getTextContentAccessor()]; +} + +var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + +var _assign = ReactInternals.assign; + +/* eslint valid-typeof: 0 */ + +var didWarnForAddedNewProperty = false; +var EVENT_POOL_SIZE = 10; + +var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances']; + +/** + * @interface Event + * @see http://www.w3.org/TR/DOM-Level-3-Events/ + */ +var EventInterface = { + type: null, + target: null, + // currentTarget is set when dispatching; no use in copying it here + currentTarget: emptyFunction_1.thatReturnsNull, + eventPhase: null, + bubbles: null, + cancelable: null, + timeStamp: function (event) { + return event.timeStamp || Date.now(); + }, + defaultPrevented: null, + isTrusted: null +}; + +/** + * Synthetic events are dispatched by event plugins, typically in response to a + * top-level event delegation handler. + * + * These systems should generally use pooling to reduce the frequency of garbage + * collection. The system should check `isPersistent` to determine whether the + * event should be released into the pool after being dispatched. Users that + * need a persisted event should invoke `persist`. + * + * Synthetic events (and subclasses) implement the DOM Level 3 Events API by + * normalizing browser quirks. Subclasses do not necessarily have to implement a + * DOM interface; custom application-specific events can also subclass this. + * + * @param {object} dispatchConfig Configuration used to dispatch this event. + * @param {*} targetInst Marker identifying the event target. + * @param {object} nativeEvent Native browser event. + * @param {DOMEventTarget} nativeEventTarget Target node. + */ +function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) { + { + // these have a getter/setter for warnings + delete this.nativeEvent; + delete this.preventDefault; + delete this.stopPropagation; + } + + this.dispatchConfig = dispatchConfig; + this._targetInst = targetInst; + this.nativeEvent = nativeEvent; + + var Interface = this.constructor.Interface; + for (var propName in Interface) { + if (!Interface.hasOwnProperty(propName)) { + continue; + } + { + delete this[propName]; // this has a getter/setter for warnings + } + var normalize = Interface[propName]; + if (normalize) { + this[propName] = normalize(nativeEvent); + } else { + if (propName === 'target') { + this.target = nativeEventTarget; + } else { + this[propName] = nativeEvent[propName]; + } + } + } + + var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false; + if (defaultPrevented) { + this.isDefaultPrevented = emptyFunction_1.thatReturnsTrue; + } else { + this.isDefaultPrevented = emptyFunction_1.thatReturnsFalse; + } + this.isPropagationStopped = emptyFunction_1.thatReturnsFalse; + return this; +} + +_assign(SyntheticEvent.prototype, { + preventDefault: function () { + this.defaultPrevented = true; + var event = this.nativeEvent; + if (!event) { + return; + } + + if (event.preventDefault) { + event.preventDefault(); + } else if (typeof event.returnValue !== 'unknown') { + event.returnValue = false; + } + this.isDefaultPrevented = emptyFunction_1.thatReturnsTrue; + }, + + stopPropagation: function () { + var event = this.nativeEvent; + if (!event) { + return; + } + + if (event.stopPropagation) { + event.stopPropagation(); + } else if (typeof event.cancelBubble !== 'unknown') { + // The ChangeEventPlugin registers a "propertychange" event for + // IE. This event does not support bubbling or cancelling, and + // any references to cancelBubble throw "Member not found". A + // typeof check of "unknown" circumvents this issue (and is also + // IE specific). + event.cancelBubble = true; + } + + this.isPropagationStopped = emptyFunction_1.thatReturnsTrue; + }, + + /** + * We release all dispatched `SyntheticEvent`s after each event loop, adding + * them back into the pool. This allows a way to hold onto a reference that + * won't be added back into the pool. + */ + persist: function () { + this.isPersistent = emptyFunction_1.thatReturnsTrue; + }, + + /** + * Checks if this event should be released back into the pool. + * + * @return {boolean} True if this should not be released, false otherwise. + */ + isPersistent: emptyFunction_1.thatReturnsFalse, + + /** + * `PooledClass` looks for `destructor` on each instance it releases. + */ + destructor: function () { + var Interface = this.constructor.Interface; + for (var propName in Interface) { + { + Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName])); + } + } + for (var i = 0; i < shouldBeReleasedProperties.length; i++) { + this[shouldBeReleasedProperties[i]] = null; + } + { + Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null)); + Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction_1)); + Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction_1)); + } + } +}); + +SyntheticEvent.Interface = EventInterface; + +/** + * Helper to reduce boilerplate when creating subclasses. + */ +SyntheticEvent.extend = function (Interface) { + var Super = this; + + var E = function () {}; + E.prototype = Super.prototype; + var prototype = new E(); + + function Class() { + return Super.apply(this, arguments); + } + _assign(prototype, Class.prototype); + Class.prototype = prototype; + Class.prototype.constructor = Class; + + Class.Interface = _assign({}, Super.Interface, Interface); + Class.extend = Super.extend; + addEventPoolingTo(Class); + + return Class; +}; + +/** Proxying after everything set on SyntheticEvent + * to resolve Proxy issue on some WebKit browsers + * in which some Event properties are set to undefined (GH#10010) + */ +{ + var isProxySupported = typeof Proxy === 'function' && + // https://github.com/facebook/react/issues/12011 + !Object.isSealed(new Proxy({}, {})); + + if (isProxySupported) { + /*eslint-disable no-func-assign */ + SyntheticEvent = new Proxy(SyntheticEvent, { + construct: function (target, args) { + return this.apply(target, Object.create(target.prototype), args); + }, + apply: function (constructor, that, args) { + return new Proxy(constructor.apply(that, args), { + set: function (target, prop, value) { + if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) { + warning_1(didWarnForAddedNewProperty || target.isPersistent(), "This synthetic event is reused for performance reasons. If you're " + "seeing this, you're adding a new property in the synthetic event object. " + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.'); + didWarnForAddedNewProperty = true; + } + target[prop] = value; + return true; + } + }); + } + }); + /*eslint-enable no-func-assign */ + } +} + +addEventPoolingTo(SyntheticEvent); + +/** + * Helper to nullify syntheticEvent instance properties when destructing + * + * @param {String} propName + * @param {?object} getVal + * @return {object} defineProperty object + */ +function getPooledWarningPropertyDefinition(propName, getVal) { + var isFunction = typeof getVal === 'function'; + return { + configurable: true, + set: set, + get: get + }; + + function set(val) { + var action = isFunction ? 'setting the method' : 'setting the property'; + warn(action, 'This is effectively a no-op'); + return val; + } + + function get() { + var action = isFunction ? 'accessing the method' : 'accessing the property'; + var result = isFunction ? 'This is a no-op function' : 'This is set to null'; + warn(action, result); + return getVal; + } + + function warn(action, result) { + var warningCondition = false; + warning_1(warningCondition, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result); + } +} + +function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) { + var EventConstructor = this; + if (EventConstructor.eventPool.length) { + var instance = EventConstructor.eventPool.pop(); + EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst); + return instance; + } + return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst); +} + +function releasePooledEvent(event) { + var EventConstructor = this; + !(event instanceof EventConstructor) ? invariant_1(false, 'Trying to release an event instance into a pool of a different type.') : void 0; + event.destructor(); + if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) { + EventConstructor.eventPool.push(event); + } +} + +function addEventPoolingTo(EventConstructor) { + EventConstructor.eventPool = []; + EventConstructor.getPooled = getPooledEvent; + EventConstructor.release = releasePooledEvent; +} + +var SyntheticEvent$1 = SyntheticEvent; + +/** + * @interface Event + * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents + */ +var SyntheticCompositionEvent = SyntheticEvent$1.extend({ + data: null +}); + +/** + * @interface Event + * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105 + * /#events-inputevents + */ +var SyntheticInputEvent = SyntheticEvent$1.extend({ + data: null +}); + +var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space +var START_KEYCODE = 229; + +var canUseCompositionEvent = ExecutionEnvironment_1.canUseDOM && 'CompositionEvent' in window; + +var documentMode = null; +if (ExecutionEnvironment_1.canUseDOM && 'documentMode' in document) { + documentMode = document.documentMode; +} + +// Webkit offers a very useful `textInput` event that can be used to +// directly represent `beforeInput`. The IE `textinput` event is not as +// useful, so we don't use it. +var canUseTextInputEvent = ExecutionEnvironment_1.canUseDOM && 'TextEvent' in window && !documentMode; + +// In IE9+, we have access to composition events, but the data supplied +// by the native compositionend event may be incorrect. Japanese ideographic +// spaces, for instance (\u3000) are not recorded correctly. +var useFallbackCompositionData = ExecutionEnvironment_1.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11); + +var SPACEBAR_CODE = 32; +var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE); + +// Events and their corresponding property names. +var eventTypes = { + beforeInput: { + phasedRegistrationNames: { + bubbled: 'onBeforeInput', + captured: 'onBeforeInputCapture' + }, + dependencies: ['topCompositionEnd', 'topKeyPress', 'topTextInput', 'topPaste'] + }, + compositionEnd: { + phasedRegistrationNames: { + bubbled: 'onCompositionEnd', + captured: 'onCompositionEndCapture' + }, + dependencies: ['topBlur', 'topCompositionEnd', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown'] + }, + compositionStart: { + phasedRegistrationNames: { + bubbled: 'onCompositionStart', + captured: 'onCompositionStartCapture' + }, + dependencies: ['topBlur', 'topCompositionStart', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown'] + }, + compositionUpdate: { + phasedRegistrationNames: { + bubbled: 'onCompositionUpdate', + captured: 'onCompositionUpdateCapture' + }, + dependencies: ['topBlur', 'topCompositionUpdate', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown'] + } +}; + +// Track whether we've ever handled a keypress on the space key. +var hasSpaceKeypress = false; + +/** + * Return whether a native keypress event is assumed to be a command. + * This is required because Firefox fires `keypress` events for key commands + * (cut, copy, select-all, etc.) even though no character is inserted. + */ +function isKeypressCommand(nativeEvent) { + return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && + // ctrlKey && altKey is equivalent to AltGr, and is not a command. + !(nativeEvent.ctrlKey && nativeEvent.altKey); +} + +/** + * Translate native top level events into event types. + * + * @param {string} topLevelType + * @return {object} + */ +function getCompositionEventType(topLevelType) { + switch (topLevelType) { + case 'topCompositionStart': + return eventTypes.compositionStart; + case 'topCompositionEnd': + return eventTypes.compositionEnd; + case 'topCompositionUpdate': + return eventTypes.compositionUpdate; + } +} + +/** + * Does our fallback best-guess model think this event signifies that + * composition has begun? + * + * @param {string} topLevelType + * @param {object} nativeEvent + * @return {boolean} + */ +function isFallbackCompositionStart(topLevelType, nativeEvent) { + return topLevelType === 'topKeyDown' && nativeEvent.keyCode === START_KEYCODE; +} + +/** + * Does our fallback mode think that this event is the end of composition? + * + * @param {string} topLevelType + * @param {object} nativeEvent + * @return {boolean} + */ +function isFallbackCompositionEnd(topLevelType, nativeEvent) { + switch (topLevelType) { + case 'topKeyUp': + // Command keys insert or clear IME input. + return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1; + case 'topKeyDown': + // Expect IME keyCode on each keydown. If we get any other + // code we must have exited earlier. + return nativeEvent.keyCode !== START_KEYCODE; + case 'topKeyPress': + case 'topMouseDown': + case 'topBlur': + // Events are not possible without cancelling IME. + return true; + default: + return false; + } +} + +/** + * Google Input Tools provides composition data via a CustomEvent, + * with the `data` property populated in the `detail` object. If this + * is available on the event object, use it. If not, this is a plain + * composition event and we have nothing special to extract. + * + * @param {object} nativeEvent + * @return {?string} + */ +function getDataFromCustomEvent(nativeEvent) { + var detail = nativeEvent.detail; + if (typeof detail === 'object' && 'data' in detail) { + return detail.data; + } + return null; +} + +// Track the current IME composition status, if any. +var isComposing = false; + +/** + * @return {?object} A SyntheticCompositionEvent. + */ +function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var eventType = void 0; + var fallbackData = void 0; + + if (canUseCompositionEvent) { + eventType = getCompositionEventType(topLevelType); + } else if (!isComposing) { + if (isFallbackCompositionStart(topLevelType, nativeEvent)) { + eventType = eventTypes.compositionStart; + } + } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) { + eventType = eventTypes.compositionEnd; + } + + if (!eventType) { + return null; + } + + if (useFallbackCompositionData) { + // The current composition is stored statically and must not be + // overwritten while composition continues. + if (!isComposing && eventType === eventTypes.compositionStart) { + isComposing = initialize(nativeEventTarget); + } else if (eventType === eventTypes.compositionEnd) { + if (isComposing) { + fallbackData = getData(); + } + } + } + + var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget); + + if (fallbackData) { + // Inject data generated from fallback path into the synthetic event. + // This matches the property of native CompositionEventInterface. + event.data = fallbackData; + } else { + var customData = getDataFromCustomEvent(nativeEvent); + if (customData !== null) { + event.data = customData; + } + } + + accumulateTwoPhaseDispatches(event); + return event; +} + +/** + * @param {TopLevelTypes} topLevelType Record from `BrowserEventConstants`. + * @param {object} nativeEvent Native browser event. + * @return {?string} The string corresponding to this `beforeInput` event. + */ +function getNativeBeforeInputChars(topLevelType, nativeEvent) { + switch (topLevelType) { + case 'topCompositionEnd': + return getDataFromCustomEvent(nativeEvent); + case 'topKeyPress': + /** + * If native `textInput` events are available, our goal is to make + * use of them. However, there is a special case: the spacebar key. + * In Webkit, preventing default on a spacebar `textInput` event + * cancels character insertion, but it *also* causes the browser + * to fall back to its default spacebar behavior of scrolling the + * page. + * + * Tracking at: + * https://code.google.com/p/chromium/issues/detail?id=355103 + * + * To avoid this issue, use the keypress event as if no `textInput` + * event is available. + */ + var which = nativeEvent.which; + if (which !== SPACEBAR_CODE) { + return null; + } + + hasSpaceKeypress = true; + return SPACEBAR_CHAR; + + case 'topTextInput': + // Record the characters to be added to the DOM. + var chars = nativeEvent.data; + + // If it's a spacebar character, assume that we have already handled + // it at the keypress level and bail immediately. Android Chrome + // doesn't give us keycodes, so we need to blacklist it. + if (chars === SPACEBAR_CHAR && hasSpaceKeypress) { + return null; + } + + return chars; + + default: + // For other native event types, do nothing. + return null; + } +} + +/** + * For browsers that do not provide the `textInput` event, extract the + * appropriate string to use for SyntheticInputEvent. + * + * @param {string} topLevelType Record from `BrowserEventConstants`. + * @param {object} nativeEvent Native browser event. + * @return {?string} The fallback string for this `beforeInput` event. + */ +function getFallbackBeforeInputChars(topLevelType, nativeEvent) { + // If we are currently composing (IME) and using a fallback to do so, + // try to extract the composed characters from the fallback object. + // If composition event is available, we extract a string only at + // compositionevent, otherwise extract it at fallback events. + if (isComposing) { + if (topLevelType === 'topCompositionEnd' || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) { + var chars = getData(); + reset(); + isComposing = false; + return chars; + } + return null; + } + + switch (topLevelType) { + case 'topPaste': + // If a paste event occurs after a keypress, throw out the input + // chars. Paste events should not lead to BeforeInput events. + return null; + case 'topKeyPress': + /** + * As of v27, Firefox may fire keypress events even when no character + * will be inserted. A few possibilities: + * + * - `which` is `0`. Arrow keys, Esc key, etc. + * + * - `which` is the pressed key code, but no char is available. + * Ex: 'AltGr + d` in Polish. There is no modified character for + * this key combination and no character is inserted into the + * document, but FF fires the keypress for char code `100` anyway. + * No `input` event will occur. + * + * - `which` is the pressed key code, but a command combination is + * being used. Ex: `Cmd+C`. No character is inserted, and no + * `input` event will occur. + */ + if (!isKeypressCommand(nativeEvent)) { + // IE fires the `keypress` event when a user types an emoji via + // Touch keyboard of Windows. In such a case, the `char` property + // holds an emoji character like `\uD83D\uDE0A`. Because its length + // is 2, the property `which` does not represent an emoji correctly. + // In such a case, we directly return the `char` property instead of + // using `which`. + if (nativeEvent.char && nativeEvent.char.length > 1) { + return nativeEvent.char; + } else if (nativeEvent.which) { + return String.fromCharCode(nativeEvent.which); + } + } + return null; + case 'topCompositionEnd': + return useFallbackCompositionData ? null : nativeEvent.data; + default: + return null; + } +} + +/** + * Extract a SyntheticInputEvent for `beforeInput`, based on either native + * `textInput` or fallback behavior. + * + * @return {?object} A SyntheticInputEvent. + */ +function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var chars = void 0; + + if (canUseTextInputEvent) { + chars = getNativeBeforeInputChars(topLevelType, nativeEvent); + } else { + chars = getFallbackBeforeInputChars(topLevelType, nativeEvent); + } + + // If no characters are being inserted, no BeforeInput event should + // be fired. + if (!chars) { + return null; + } + + var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget); + + event.data = chars; + accumulateTwoPhaseDispatches(event); + return event; +} + +/** + * Create an `onBeforeInput` event to match + * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents. + * + * This event plugin is based on the native `textInput` event + * available in Chrome, Safari, Opera, and IE. This event fires after + * `onKeyPress` and `onCompositionEnd`, but before `onInput`. + * + * `beforeInput` is spec'd but not implemented in any browsers, and + * the `input` event does not provide any useful information about what has + * actually been added, contrary to the spec. Thus, `textInput` is the best + * available event to identify the characters that have actually been inserted + * into the target node. + * + * This plugin is also responsible for emitting `composition` events, thus + * allowing us to share composition fallback code for both `beforeInput` and + * `composition` event types. + */ +var BeforeInputEventPlugin = { + eventTypes: eventTypes, + + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var composition = extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget); + + var beforeInput = extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget); + + if (composition === null) { + return beforeInput; + } + + if (beforeInput === null) { + return composition; + } + + return [composition, beforeInput]; + } +}; + +// Use to restore controlled state after a change event has fired. + +var fiberHostComponent = null; + +var ReactControlledComponentInjection = { + injectFiberControlledHostComponent: function (hostComponentImpl) { + // The fiber implementation doesn't use dynamic dispatch so we need to + // inject the implementation. + fiberHostComponent = hostComponentImpl; + } +}; + +var restoreTarget = null; +var restoreQueue = null; + +function restoreStateOfTarget(target) { + // We perform this translation at the end of the event loop so that we + // always receive the correct fiber here + var internalInstance = getInstanceFromNode(target); + if (!internalInstance) { + // Unmounted + return; + } + !(fiberHostComponent && typeof fiberHostComponent.restoreControlledState === 'function') ? invariant_1(false, 'Fiber needs to be injected to handle a fiber target for controlled events. This error is likely caused by a bug in React. Please file an issue.') : void 0; + var props = getFiberCurrentPropsFromNode(internalInstance.stateNode); + fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props); +} + +var injection$2 = ReactControlledComponentInjection; + +function enqueueStateRestore(target) { + if (restoreTarget) { + if (restoreQueue) { + restoreQueue.push(target); + } else { + restoreQueue = [target]; + } + } else { + restoreTarget = target; + } +} + +function needsStateRestore() { + return restoreTarget !== null || restoreQueue !== null; +} + +function restoreStateIfNeeded() { + if (!restoreTarget) { + return; + } + var target = restoreTarget; + var queuedTargets = restoreQueue; + restoreTarget = null; + restoreQueue = null; + + restoreStateOfTarget(target); + if (queuedTargets) { + for (var i = 0; i < queuedTargets.length; i++) { + restoreStateOfTarget(queuedTargets[i]); + } + } +} + +var ReactControlledComponent = Object.freeze({ + injection: injection$2, + enqueueStateRestore: enqueueStateRestore, + needsStateRestore: needsStateRestore, + restoreStateIfNeeded: restoreStateIfNeeded +}); + +// Used as a way to call batchedUpdates when we don't have a reference to +// the renderer. Such as when we're dispatching events or if third party +// libraries need to call batchedUpdates. Eventually, this API will go away when +// everything is batched by default. We'll then have a similar API to opt-out of +// scheduled work and instead do synchronous work. + +// Defaults +var _batchedUpdates = function (fn, bookkeeping) { + return fn(bookkeeping); +}; +var _interactiveUpdates = function (fn, a, b) { + return fn(a, b); +}; +var _flushInteractiveUpdates = function () {}; + +var isBatching = false; +function batchedUpdates(fn, bookkeeping) { + if (isBatching) { + // If we are currently inside another batch, we need to wait until it + // fully completes before restoring state. + return fn(bookkeeping); + } + isBatching = true; + try { + return _batchedUpdates(fn, bookkeeping); + } finally { + // Here we wait until all updates have propagated, which is important + // when using controlled components within layers: + // https://github.com/facebook/react/issues/1698 + // Then we restore state of any controlled component. + isBatching = false; + var controlledComponentsHavePendingUpdates = needsStateRestore(); + if (controlledComponentsHavePendingUpdates) { + // If a controlled event was fired, we may need to restore the state of + // the DOM node back to the controlled value. This is necessary when React + // bails out of the update without touching the DOM. + _flushInteractiveUpdates(); + restoreStateIfNeeded(); + } + } +} + +function interactiveUpdates(fn, a, b) { + return _interactiveUpdates(fn, a, b); +} + + + +var injection$3 = { + injectRenderer: function (renderer) { + _batchedUpdates = renderer.batchedUpdates; + _interactiveUpdates = renderer.interactiveUpdates; + _flushInteractiveUpdates = renderer.flushInteractiveUpdates; + } +}; + +/** + * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary + */ +var supportedInputTypes = { + color: true, + date: true, + datetime: true, + 'datetime-local': true, + email: true, + month: true, + number: true, + password: true, + range: true, + search: true, + tel: true, + text: true, + time: true, + url: true, + week: true +}; + +function isTextInputElement(elem) { + var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase(); + + if (nodeName === 'input') { + return !!supportedInputTypes[elem.type]; + } + + if (nodeName === 'textarea') { + return true; + } + + return false; +} + +/** + * HTML nodeType values that represent the type of the node + */ + +var ELEMENT_NODE = 1; +var TEXT_NODE = 3; +var COMMENT_NODE = 8; +var DOCUMENT_NODE = 9; +var DOCUMENT_FRAGMENT_NODE = 11; + +/** + * Gets the target node from a native browser event by accounting for + * inconsistencies in browser DOM APIs. + * + * @param {object} nativeEvent Native browser event. + * @return {DOMEventTarget} Target node. + */ +function getEventTarget(nativeEvent) { + var target = nativeEvent.target || window; + + // Normalize SVG element events #4963 + if (target.correspondingUseElement) { + target = target.correspondingUseElement; + } + + // Safari may fire events on text nodes (Node.TEXT_NODE is 3). + // @see http://www.quirksmode.org/js/events_properties.html + return target.nodeType === TEXT_NODE ? target.parentNode : target; +} + +/** + * Checks if an event is supported in the current execution environment. + * + * NOTE: This will not work correctly for non-generic events such as `change`, + * `reset`, `load`, `error`, and `select`. + * + * Borrows from Modernizr. + * + * @param {string} eventNameSuffix Event name, e.g. "click". + * @param {?boolean} capture Check if the capture phase is supported. + * @return {boolean} True if the event is supported. + * @internal + * @license Modernizr 3.0.0pre (Custom Build) | MIT + */ +function isEventSupported(eventNameSuffix, capture) { + if (!ExecutionEnvironment_1.canUseDOM || capture && !('addEventListener' in document)) { + return false; + } + + var eventName = 'on' + eventNameSuffix; + var isSupported = eventName in document; + + if (!isSupported) { + var element = document.createElement('div'); + element.setAttribute(eventName, 'return;'); + isSupported = typeof element[eventName] === 'function'; + } + + return isSupported; +} + +function isCheckable(elem) { + var type = elem.type; + var nodeName = elem.nodeName; + return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio'); +} + +function getTracker(node) { + return node._valueTracker; +} + +function detachTracker(node) { + node._valueTracker = null; +} + +function getValueFromNode(node) { + var value = ''; + if (!node) { + return value; + } + + if (isCheckable(node)) { + value = node.checked ? 'true' : 'false'; + } else { + value = node.value; + } + + return value; +} + +function trackValueOnNode(node) { + var valueField = isCheckable(node) ? 'checked' : 'value'; + var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField); + + var currentValue = '' + node[valueField]; + + // if someone has already defined a value or Safari, then bail + // and don't track value will cause over reporting of changes, + // but it's better then a hard failure + // (needed for certain tests that spyOn input values and Safari) + if (node.hasOwnProperty(valueField) || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') { + return; + } + + Object.defineProperty(node, valueField, { + configurable: true, + get: function () { + return descriptor.get.call(this); + }, + set: function (value) { + currentValue = '' + value; + descriptor.set.call(this, value); + } + }); + // We could've passed this the first time + // but it triggers a bug in IE11 and Edge 14/15. + // Calling defineProperty() again should be equivalent. + // https://github.com/facebook/react/issues/11768 + Object.defineProperty(node, valueField, { + enumerable: descriptor.enumerable + }); + + var tracker = { + getValue: function () { + return currentValue; + }, + setValue: function (value) { + currentValue = '' + value; + }, + stopTracking: function () { + detachTracker(node); + delete node[valueField]; + } + }; + return tracker; +} + +function track(node) { + if (getTracker(node)) { + return; + } + + // TODO: Once it's just Fiber we can move this to node._wrapperState + node._valueTracker = trackValueOnNode(node); +} + +function updateValueIfChanged(node) { + if (!node) { + return false; + } + + var tracker = getTracker(node); + // if there is no tracker at this point it's unlikely + // that trying again will succeed + if (!tracker) { + return true; + } + + var lastValue = tracker.getValue(); + var nextValue = getValueFromNode(node); + if (nextValue !== lastValue) { + tracker.setValue(nextValue); + return true; + } + return false; +} + +var ReactInternals$1 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; + +var ReactCurrentOwner = ReactInternals$1.ReactCurrentOwner; +var ReactDebugCurrentFrame = ReactInternals$1.ReactDebugCurrentFrame; + +var describeComponentFrame = function (name, source, ownerName) { + return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : ''); +}; + +// The Symbol used to tag the ReactElement-like types. If there is no native Symbol +// nor polyfill, then a plain number is used for performance. +var hasSymbol = typeof Symbol === 'function' && Symbol['for']; + +var REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7; +var REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8; +var REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9; +var REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca; +var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb; +var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol['for']('react.strict_mode') : 0xeacc; +var REACT_PROVIDER_TYPE = hasSymbol ? Symbol['for']('react.provider') : 0xeacd; +var REACT_CONTEXT_TYPE = hasSymbol ? Symbol['for']('react.context') : 0xeace; +var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol['for']('react.async_mode') : 0xeacf; +var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol['for']('react.forward_ref') : 0xead0; + +var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; +var FAUX_ITERATOR_SYMBOL = '@@iterator'; + +function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable === 'undefined') { + return null; + } + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + if (typeof maybeIterator === 'function') { + return maybeIterator; + } + return null; +} + +function getComponentName(fiber) { + var type = fiber.type; + + if (typeof type === 'function') { + return type.displayName || type.name; + } + if (typeof type === 'string') { + return type; + } + switch (type) { + case REACT_FRAGMENT_TYPE: + return 'ReactFragment'; + case REACT_PORTAL_TYPE: + return 'ReactPortal'; + case REACT_CALL_TYPE: + return 'ReactCall'; + case REACT_RETURN_TYPE: + return 'ReactReturn'; + } + return null; +} + +function describeFiber(fiber) { + switch (fiber.tag) { + case IndeterminateComponent: + case FunctionalComponent: + case ClassComponent: + case HostComponent: + var owner = fiber._debugOwner; + var source = fiber._debugSource; + var name = getComponentName(fiber); + var ownerName = null; + if (owner) { + ownerName = getComponentName(owner); + } + return describeComponentFrame(name, source, ownerName); + default: + return ''; + } +} + +// This function can only be called with a work-in-progress fiber and +// only during begin or complete phase. Do not call it under any other +// circumstances. +function getStackAddendumByWorkInProgressFiber(workInProgress) { + var info = ''; + var node = workInProgress; + do { + info += describeFiber(node); + // Otherwise this return pointer might point to the wrong tree: + node = node['return']; + } while (node); + return info; +} + +function getCurrentFiberOwnerName$1() { + { + var fiber = ReactDebugCurrentFiber.current; + if (fiber === null) { + return null; + } + var owner = fiber._debugOwner; + if (owner !== null && typeof owner !== 'undefined') { + return getComponentName(owner); + } + } + return null; +} + +function getCurrentFiberStackAddendum$1() { + { + var fiber = ReactDebugCurrentFiber.current; + if (fiber === null) { + return null; + } + // Safe because if current fiber exists, we are reconciling, + // and it is guaranteed to be the work-in-progress version. + return getStackAddendumByWorkInProgressFiber(fiber); + } + return null; +} + +function resetCurrentFiber() { + ReactDebugCurrentFrame.getCurrentStack = null; + ReactDebugCurrentFiber.current = null; + ReactDebugCurrentFiber.phase = null; +} + +function setCurrentFiber(fiber) { + ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum$1; + ReactDebugCurrentFiber.current = fiber; + ReactDebugCurrentFiber.phase = null; +} + +function setCurrentPhase(phase) { + ReactDebugCurrentFiber.phase = phase; +} + +var ReactDebugCurrentFiber = { + current: null, + phase: null, + resetCurrentFiber: resetCurrentFiber, + setCurrentFiber: setCurrentFiber, + setCurrentPhase: setCurrentPhase, + getCurrentFiberOwnerName: getCurrentFiberOwnerName$1, + getCurrentFiberStackAddendum: getCurrentFiberStackAddendum$1 +}; + +// A reserved attribute. +// It is handled by React separately and shouldn't be written to the DOM. +var RESERVED = 0; + +// A simple string attribute. +// Attributes that aren't in the whitelist are presumed to have this type. +var STRING = 1; + +// A string attribute that accepts booleans in React. In HTML, these are called +// "enumerated" attributes with "true" and "false" as possible values. +// When true, it should be set to a "true" string. +// When false, it should be set to a "false" string. +var BOOLEANISH_STRING = 2; + +// A real boolean attribute. +// When true, it should be present (set either to an empty string or its name). +// When false, it should be omitted. +var BOOLEAN = 3; + +// An attribute that can be used as a flag as well as with a value. +// When true, it should be present (set either to an empty string or its name). +// When false, it should be omitted. +// For any other value, should be present with that value. +var OVERLOADED_BOOLEAN = 4; + +// An attribute that must be numeric or parse as a numeric. +// When falsy, it should be removed. +var NUMERIC = 5; + +// An attribute that must be positive numeric or parse as a positive numeric. +// When falsy, it should be removed. +var POSITIVE_NUMERIC = 6; + +/* eslint-disable max-len */ +var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD'; +/* eslint-enable max-len */ +var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040'; + + +var ROOT_ATTRIBUTE_NAME = 'data-reactroot'; +var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$'); + +var illegalAttributeNameCache = {}; +var validatedAttributeNameCache = {}; + +function isAttributeNameSafe(attributeName) { + if (validatedAttributeNameCache.hasOwnProperty(attributeName)) { + return true; + } + if (illegalAttributeNameCache.hasOwnProperty(attributeName)) { + return false; + } + if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) { + validatedAttributeNameCache[attributeName] = true; + return true; + } + illegalAttributeNameCache[attributeName] = true; + { + warning_1(false, 'Invalid attribute name: `%s`', attributeName); + } + return false; +} + +function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null) { + return propertyInfo.type === RESERVED; + } + if (isCustomComponentTag) { + return false; + } + if (name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) { + return true; + } + return false; +} + +function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null && propertyInfo.type === RESERVED) { + return false; + } + switch (typeof value) { + case 'function': + // $FlowIssue symbol is perfectly valid here + case 'symbol': + // eslint-disable-line + return true; + case 'boolean': + { + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + return !propertyInfo.acceptsBooleans; + } else { + var prefix = name.toLowerCase().slice(0, 5); + return prefix !== 'data-' && prefix !== 'aria-'; + } + } + default: + return false; + } +} + +function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) { + if (value === null || typeof value === 'undefined') { + return true; + } + if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) { + return true; + } + if (propertyInfo !== null) { + switch (propertyInfo.type) { + case BOOLEAN: + return !value; + case OVERLOADED_BOOLEAN: + return value === false; + case NUMERIC: + return isNaN(value); + case POSITIVE_NUMERIC: + return isNaN(value) || value < 1; + } + } + return false; +} + +function getPropertyInfo(name) { + return properties.hasOwnProperty(name) ? properties[name] : null; +} + +function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace) { + this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN; + this.attributeName = attributeName; + this.attributeNamespace = attributeNamespace; + this.mustUseProperty = mustUseProperty; + this.propertyName = name; + this.type = type; +} + +// When adding attributes to this list, be sure to also add them to +// the `possibleStandardNames` module to ensure casing and incorrect +// name warnings. +var properties = {}; + +// These props are reserved by React. They shouldn't be written to the DOM. +['children', 'dangerouslySetInnerHTML', +// TODO: This prevents the assignment of defaultValue to regular +// elements (not just inputs). Now that ReactDOMInput assigns to the +// defaultValue property -- do we need this? +'defaultValue', 'defaultChecked', 'innerHTML', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'style'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, RESERVED, false, // mustUseProperty + name, // attributeName + null); +}); + +// A few React string attributes have a different name. +// This is a mapping from React prop names to the attribute names. +[['acceptCharset', 'accept-charset'], ['className', 'class'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv']].forEach(function (_ref) { + var name = _ref[0], + attributeName = _ref[1]; + + properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty + attributeName, // attributeName + null); +}); + +// These are "enumerated" HTML attributes that accept "true" and "false". +// In React, we let users pass `true` and `false` even though technically +// these aren't boolean attributes (they are coerced to strings). +['contentEditable', 'draggable', 'spellCheck', 'value'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty + name.toLowerCase(), // attributeName + null); +}); + +// These are "enumerated" SVG attributes that accept "true" and "false". +// In React, we let users pass `true` and `false` even though technically +// these aren't boolean attributes (they are coerced to strings). +// Since these are SVG attributes, their attribute names are case-sensitive. +['autoReverse', 'externalResourcesRequired', 'preserveAlpha'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty + name, // attributeName + null); +}); + +// These are HTML boolean attributes. +['allowFullScreen', 'async', +// Note: there is a special case that prevents it from being written to the DOM +// on the client side because the browsers are inconsistent. Instead we call focus(). +'autoFocus', 'autoPlay', 'controls', 'default', 'defer', 'disabled', 'formNoValidate', 'hidden', 'loop', 'noModule', 'noValidate', 'open', 'playsInline', 'readOnly', 'required', 'reversed', 'scoped', 'seamless', +// Microdata +'itemScope'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, BOOLEAN, false, // mustUseProperty + name.toLowerCase(), // attributeName + null); +}); + +// These are the few React props that we set as DOM properties +// rather than attributes. These are all booleans. +['checked', +// Note: `option.selected` is not updated if `select.multiple` is +// disabled with `removeAttribute`. We have special logic for handling this. +'multiple', 'muted', 'selected'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, BOOLEAN, true, // mustUseProperty + name.toLowerCase(), // attributeName + null); +}); + +// These are HTML attributes that are "overloaded booleans": they behave like +// booleans, but can also accept a string value. +['capture', 'download'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, OVERLOADED_BOOLEAN, false, // mustUseProperty + name.toLowerCase(), // attributeName + null); +}); + +// These are HTML attributes that must be positive numbers. +['cols', 'rows', 'size', 'span'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, POSITIVE_NUMERIC, false, // mustUseProperty + name.toLowerCase(), // attributeName + null); +}); + +// These are HTML attributes that must be numbers. +['rowSpan', 'start'].forEach(function (name) { + properties[name] = new PropertyInfoRecord(name, NUMERIC, false, // mustUseProperty + name.toLowerCase(), // attributeName + null); +}); + +var CAMELIZE = /[\-\:]([a-z])/g; +var capitalize = function (token) { + return token[1].toUpperCase(); +}; + +// This is a list of all SVG attributes that need special casing, namespacing, +// or boolean value assignment. Regular attributes that just accept strings +// and have the same names are omitted, just like in the HTML whitelist. +// Some of these attributes can be hard to find. This list was created by +// scrapping the MDN documentation. +['accent-height', 'alignment-baseline', 'arabic-form', 'baseline-shift', 'cap-height', 'clip-path', 'clip-rule', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'dominant-baseline', 'enable-background', 'fill-opacity', 'fill-rule', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'glyph-name', 'glyph-orientation-horizontal', 'glyph-orientation-vertical', 'horiz-adv-x', 'horiz-origin-x', 'image-rendering', 'letter-spacing', 'lighting-color', 'marker-end', 'marker-mid', 'marker-start', 'overline-position', 'overline-thickness', 'paint-order', 'panose-1', 'pointer-events', 'rendering-intent', 'shape-rendering', 'stop-color', 'stop-opacity', 'strikethrough-position', 'strikethrough-thickness', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'text-anchor', 'text-decoration', 'text-rendering', 'underline-position', 'underline-thickness', 'unicode-bidi', 'unicode-range', 'units-per-em', 'v-alphabetic', 'v-hanging', 'v-ideographic', 'v-mathematical', 'vector-effect', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'word-spacing', 'writing-mode', 'xmlns:xlink', 'x-height'].forEach(function (attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty + attributeName, null); +}); + +// String SVG attributes with the xlink namespace. +['xlink:actuate', 'xlink:arcrole', 'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type'].forEach(function (attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty + attributeName, 'http://www.w3.org/1999/xlink'); +}); + +// String SVG attributes with the xml namespace. +['xml:base', 'xml:lang', 'xml:space'].forEach(function (attributeName) { + var name = attributeName.replace(CAMELIZE, capitalize); + properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty + attributeName, 'http://www.w3.org/XML/1998/namespace'); +}); + +// Special case: this attribute exists both in HTML and SVG. +// Its "tabindex" attribute name is case-sensitive in SVG so we can't just use +// its React `tabIndex` name, like we do for attributes that exist only in HTML. +properties.tabIndex = new PropertyInfoRecord('tabIndex', STRING, false, // mustUseProperty +'tabindex', // attributeName +null); + +/** + * Get the value for a property on a node. Only used in DEV for SSR validation. + * The "expected" argument is used as a hint of what the expected value is. + * Some properties have multiple equivalent values. + */ +function getValueForProperty(node, name, expected, propertyInfo) { + { + if (propertyInfo.mustUseProperty) { + var propertyName = propertyInfo.propertyName; + + return node[propertyName]; + } else { + var attributeName = propertyInfo.attributeName; + + var stringValue = null; + + if (propertyInfo.type === OVERLOADED_BOOLEAN) { + if (node.hasAttribute(attributeName)) { + var value = node.getAttribute(attributeName); + if (value === '') { + return true; + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return value; + } + if (value === '' + expected) { + return expected; + } + return value; + } + } else if (node.hasAttribute(attributeName)) { + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + // We had an attribute but shouldn't have had one, so read it + // for the error message. + return node.getAttribute(attributeName); + } + if (propertyInfo.type === BOOLEAN) { + // If this was a boolean, it doesn't matter what the value is + // the fact that we have it is the same as the expected. + return expected; + } + // Even if this property uses a namespace we use getAttribute + // because we assume its namespaced name is the same as our config. + // To use getAttributeNS we need the local name which we don't have + // in our config atm. + stringValue = node.getAttribute(attributeName); + } + + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return stringValue === null ? expected : stringValue; + } else if (stringValue === '' + expected) { + return expected; + } else { + return stringValue; + } + } + } +} + +/** + * Get the value for a attribute on a node. Only used in DEV for SSR validation. + * The third argument is used as a hint of what the expected value is. Some + * attributes have multiple equivalent values. + */ +function getValueForAttribute(node, name, expected) { + { + if (!isAttributeNameSafe(name)) { + return; + } + if (!node.hasAttribute(name)) { + return expected === undefined ? undefined : null; + } + var value = node.getAttribute(name); + if (value === '' + expected) { + return expected; + } + return value; + } +} + +/** + * Sets the value for a property on a node. + * + * @param {DOMElement} node + * @param {string} name + * @param {*} value + */ +function setValueForProperty(node, name, value, isCustomComponentTag) { + var propertyInfo = getPropertyInfo(name); + if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) { + return; + } + if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) { + value = null; + } + // If the prop isn't in the special list, treat it as a simple attribute. + if (isCustomComponentTag || propertyInfo === null) { + if (isAttributeNameSafe(name)) { + var _attributeName = name; + if (value === null) { + node.removeAttribute(_attributeName); + } else { + node.setAttribute(_attributeName, '' + value); + } + } + return; + } + var mustUseProperty = propertyInfo.mustUseProperty; + + if (mustUseProperty) { + var propertyName = propertyInfo.propertyName; + + if (value === null) { + var type = propertyInfo.type; + + node[propertyName] = type === BOOLEAN ? false : ''; + } else { + // Contrary to `setAttribute`, object properties are properly + // `toString`ed by IE8/9. + node[propertyName] = value; + } + return; + } + // The rest are treated as attributes with special cases. + var attributeName = propertyInfo.attributeName, + attributeNamespace = propertyInfo.attributeNamespace; + + if (value === null) { + node.removeAttribute(attributeName); + } else { + var _type = propertyInfo.type; + + var attributeValue = void 0; + if (_type === BOOLEAN || _type === OVERLOADED_BOOLEAN && value === true) { + attributeValue = ''; + } else { + // `setAttribute` with objects becomes only `[object]` in IE8/9, + // ('' + value) makes it output the correct toString()-value. + attributeValue = '' + value; + } + if (attributeNamespace) { + node.setAttributeNS(attributeNamespace, attributeName, attributeValue); + } else { + node.setAttribute(attributeName, attributeValue); + } + } +} + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var ReactPropTypesSecret$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; + +var ReactPropTypesSecret_1 = ReactPropTypesSecret$1; + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +{ + var invariant$2 = invariant_1; + var warning$2 = warning_1; + var ReactPropTypesSecret = ReactPropTypesSecret_1; + var loggedTypeFailures = {}; +} + +/** + * Assert that the values match with the type specs. + * Error messages are memorized and will only be shown once. + * + * @param {object} typeSpecs Map of name to a ReactPropType + * @param {object} values Runtime values that need to be type-checked + * @param {string} location e.g. "prop", "context", "child context" + * @param {string} componentName Name of the component for error messages. + * @param {?Function} getStack Returns the component stack. + * @private + */ +function checkPropTypes(typeSpecs, values, location, componentName, getStack) { + { + for (var typeSpecName in typeSpecs) { + if (typeSpecs.hasOwnProperty(typeSpecName)) { + var error; + // Prop type validation may throw. In case they do, we don't want to + // fail the render phase where it didn't fail before. So we log it. + // After these have been cleaned up, we'll let them throw. + try { + // This is intentionally an invariant that gets caught. It's the same + // behavior as without this statement except with a better message. + invariant$2(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]); + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + warning$2(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error); + if (error instanceof Error && !(error.message in loggedTypeFailures)) { + // Only monitor this failure once because there tends to be a lot of the + // same error. + loggedTypeFailures[error.message] = true; + + var stack = getStack ? getStack() : ''; + + warning$2(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : ''); + } + } + } + } +} + +var checkPropTypes_1 = checkPropTypes; + +var ReactControlledValuePropTypes = { + checkPropTypes: null +}; + +{ + var hasReadOnlyValue = { + button: true, + checkbox: true, + image: true, + hidden: true, + radio: true, + reset: true, + submit: true + }; + + var propTypes = { + value: function (props, propName, componentName) { + if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) { + return null; + } + return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.'); + }, + checked: function (props, propName, componentName) { + if (!props[propName] || props.onChange || props.readOnly || props.disabled) { + return null; + } + return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.'); + } + }; + + /** + * Provide a linked `value` attribute for controlled forms. You should not use + * this outside of the ReactDOM controlled form components. + */ + ReactControlledValuePropTypes.checkPropTypes = function (tagName, props, getStack) { + checkPropTypes_1(propTypes, props, 'prop', tagName, getStack); + }; +} + +// TODO: direct imports like some-package/src/* are bad. Fix me. +var getCurrentFiberOwnerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName; +var getCurrentFiberStackAddendum = ReactDebugCurrentFiber.getCurrentFiberStackAddendum; + +var didWarnValueDefaultValue = false; +var didWarnCheckedDefaultChecked = false; +var didWarnControlledToUncontrolled = false; +var didWarnUncontrolledToControlled = false; + +function isControlled(props) { + var usesChecked = props.type === 'checkbox' || props.type === 'radio'; + return usesChecked ? props.checked != null : props.value != null; +} + +/** + * Implements an host component that allows setting these optional + * props: `checked`, `value`, `defaultChecked`, and `defaultValue`. + * + * If `checked` or `value` are not supplied (or null/undefined), user actions + * that affect the checked state or value will trigger updates to the element. + * + * If they are supplied (and not null/undefined), the rendered element will not + * trigger updates to the element. Instead, the props must change in order for + * the rendered element to be updated. + * + * The rendered element will be initialized as unchecked (or `defaultChecked`) + * with an empty value (or `defaultValue`). + * + * See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html + */ + +function getHostProps(element, props) { + var node = element; + var checked = props.checked; + + var hostProps = _assign({}, props, { + defaultChecked: undefined, + defaultValue: undefined, + value: undefined, + checked: checked != null ? checked : node._wrapperState.initialChecked + }); + + return hostProps; +} + +function initWrapperState(element, props) { + { + ReactControlledValuePropTypes.checkPropTypes('input', props, getCurrentFiberStackAddendum); + + if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) { + warning_1(false, '%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', getCurrentFiberOwnerName() || 'A component', props.type); + didWarnCheckedDefaultChecked = true; + } + if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) { + warning_1(false, '%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', getCurrentFiberOwnerName() || 'A component', props.type); + didWarnValueDefaultValue = true; + } + } + + var node = element; + var defaultValue = props.defaultValue == null ? '' : props.defaultValue; + + node._wrapperState = { + initialChecked: props.checked != null ? props.checked : props.defaultChecked, + initialValue: getSafeValue(props.value != null ? props.value : defaultValue), + controlled: isControlled(props) + }; +} + +function updateChecked(element, props) { + var node = element; + var checked = props.checked; + if (checked != null) { + setValueForProperty(node, 'checked', checked, false); + } +} + +function updateWrapper(element, props) { + var node = element; + { + var _controlled = isControlled(props); + + if (!node._wrapperState.controlled && _controlled && !didWarnUncontrolledToControlled) { + warning_1(false, 'A component is changing an uncontrolled input of type %s to be controlled. ' + 'Input elements should not switch from uncontrolled to controlled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components%s', props.type, getCurrentFiberStackAddendum()); + didWarnUncontrolledToControlled = true; + } + if (node._wrapperState.controlled && !_controlled && !didWarnControlledToUncontrolled) { + warning_1(false, 'A component is changing a controlled input of type %s to be uncontrolled. ' + 'Input elements should not switch from controlled to uncontrolled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components%s', props.type, getCurrentFiberStackAddendum()); + didWarnControlledToUncontrolled = true; + } + } + + updateChecked(element, props); + + var value = getSafeValue(props.value); + + if (value != null) { + if (props.type === 'number') { + if (value === 0 && node.value === '' || + // eslint-disable-next-line + node.value != value) { + node.value = '' + value; + } + } else if (node.value !== '' + value) { + node.value = '' + value; + } + } + + if (props.hasOwnProperty('value')) { + setDefaultValue(node, props.type, value); + } else if (props.hasOwnProperty('defaultValue')) { + setDefaultValue(node, props.type, getSafeValue(props.defaultValue)); + } + + if (props.checked == null && props.defaultChecked != null) { + node.defaultChecked = !!props.defaultChecked; + } +} + +function postMountWrapper(element, props) { + var node = element; + + if (props.hasOwnProperty('value') || props.hasOwnProperty('defaultValue')) { + // Do not assign value if it is already set. This prevents user text input + // from being lost during SSR hydration. + if (node.value === '') { + node.value = '' + node._wrapperState.initialValue; + } + + // value must be assigned before defaultValue. This fixes an issue where the + // visually displayed value of date inputs disappears on mobile Safari and Chrome: + // https://github.com/facebook/react/issues/7233 + node.defaultValue = '' + node._wrapperState.initialValue; + } + + // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug + // this is needed to work around a chrome bug where setting defaultChecked + // will sometimes influence the value of checked (even after detachment). + // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416 + // We need to temporarily unset name to avoid disrupting radio button groups. + var name = node.name; + if (name !== '') { + node.name = ''; + } + node.defaultChecked = !node.defaultChecked; + node.defaultChecked = !node.defaultChecked; + if (name !== '') { + node.name = name; + } +} + +function restoreControlledState(element, props) { + var node = element; + updateWrapper(node, props); + updateNamedCousins(node, props); +} + +function updateNamedCousins(rootNode, props) { + var name = props.name; + if (props.type === 'radio' && name != null) { + var queryRoot = rootNode; + + while (queryRoot.parentNode) { + queryRoot = queryRoot.parentNode; + } + + // If `rootNode.form` was non-null, then we could try `form.elements`, + // but that sometimes behaves strangely in IE8. We could also try using + // `form.getElementsByName`, but that will only return direct children + // and won't include inputs that use the HTML5 `form=` attribute. Since + // the input might not even be in a form. It might not even be in the + // document. Let's just use the local `querySelectorAll` to ensure we don't + // miss anything. + var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]'); + + for (var i = 0; i < group.length; i++) { + var otherNode = group[i]; + if (otherNode === rootNode || otherNode.form !== rootNode.form) { + continue; + } + // This will throw if radio buttons rendered by different copies of React + // and the same name are rendered into the same form (same as #1939). + // That's probably okay; we don't support it just as we don't support + // mixing React radio buttons with non-React ones. + var otherProps = getFiberCurrentPropsFromNode$1(otherNode); + !otherProps ? invariant_1(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.') : void 0; + + // We need update the tracked value on the named cousin since the value + // was changed but the input saw no event or value set + updateValueIfChanged(otherNode); + + // If this is a controlled radio button group, forcing the input that + // was previously checked to update will cause it to be come re-checked + // as appropriate. + updateWrapper(otherNode, otherProps); + } + } +} + +// In Chrome, assigning defaultValue to certain input types triggers input validation. +// For number inputs, the display value loses trailing decimal points. For email inputs, +// Chrome raises "The specified value is not a valid email address". +// +// Here we check to see if the defaultValue has actually changed, avoiding these problems +// when the user is inputting text +// +// https://github.com/facebook/react/issues/7253 +function setDefaultValue(node, type, value) { + if ( + // Focused number inputs synchronize on blur. See ChangeEventPlugin.js + type !== 'number' || node.ownerDocument.activeElement !== node) { + if (value == null) { + node.defaultValue = '' + node._wrapperState.initialValue; + } else if (node.defaultValue !== '' + value) { + node.defaultValue = '' + value; + } + } +} + +function getSafeValue(value) { + switch (typeof value) { + case 'boolean': + case 'number': + case 'object': + case 'string': + case 'undefined': + return value; + default: + // function, symbol are assigned as empty strings + return ''; + } +} + +var eventTypes$1 = { + change: { + phasedRegistrationNames: { + bubbled: 'onChange', + captured: 'onChangeCapture' + }, + dependencies: ['topBlur', 'topChange', 'topClick', 'topFocus', 'topInput', 'topKeyDown', 'topKeyUp', 'topSelectionChange'] + } +}; + +function createAndAccumulateChangeEvent(inst, nativeEvent, target) { + var event = SyntheticEvent$1.getPooled(eventTypes$1.change, inst, nativeEvent, target); + event.type = 'change'; + // Flag this event loop as needing state restore. + enqueueStateRestore(target); + accumulateTwoPhaseDispatches(event); + return event; +} +/** + * For IE shims + */ +var activeElement = null; +var activeElementInst = null; + +/** + * SECTION: handle `change` event + */ +function shouldUseChangeEvent(elem) { + var nodeName = elem.nodeName && elem.nodeName.toLowerCase(); + return nodeName === 'select' || nodeName === 'input' && elem.type === 'file'; +} + +function manualDispatchChangeEvent(nativeEvent) { + var event = createAndAccumulateChangeEvent(activeElementInst, nativeEvent, getEventTarget(nativeEvent)); + + // If change and propertychange bubbled, we'd just bind to it like all the + // other events and have it go through ReactBrowserEventEmitter. Since it + // doesn't, we manually listen for the events and so we have to enqueue and + // process the abstract event manually. + // + // Batching is necessary here in order to ensure that all event handlers run + // before the next rerender (including event handlers attached to ancestor + // elements instead of directly on the input). Without this, controlled + // components don't work properly in conjunction with event bubbling because + // the component is rerendered and the value reverted before all the event + // handlers can run. See https://github.com/facebook/react/issues/708. + batchedUpdates(runEventInBatch, event); +} + +function runEventInBatch(event) { + runEventsInBatch(event, false); +} + +function getInstIfValueChanged(targetInst) { + var targetNode = getNodeFromInstance$1(targetInst); + if (updateValueIfChanged(targetNode)) { + return targetInst; + } +} + +function getTargetInstForChangeEvent(topLevelType, targetInst) { + if (topLevelType === 'topChange') { + return targetInst; + } +} + +/** + * SECTION: handle `input` event + */ +var isInputEventSupported = false; +if (ExecutionEnvironment_1.canUseDOM) { + // IE9 claims to support the input event but fails to trigger it when + // deleting text, so we ignore its input events. + isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9); +} + +/** + * (For IE <=9) Starts tracking propertychange events on the passed-in element + * and override the value property so that we can distinguish user events from + * value changes in JS. + */ +function startWatchingForValueChange(target, targetInst) { + activeElement = target; + activeElementInst = targetInst; + activeElement.attachEvent('onpropertychange', handlePropertyChange); +} + +/** + * (For IE <=9) Removes the event listeners from the currently-tracked element, + * if any exists. + */ +function stopWatchingForValueChange() { + if (!activeElement) { + return; + } + activeElement.detachEvent('onpropertychange', handlePropertyChange); + activeElement = null; + activeElementInst = null; +} + +/** + * (For IE <=9) Handles a propertychange event, sending a `change` event if + * the value of the active element has changed. + */ +function handlePropertyChange(nativeEvent) { + if (nativeEvent.propertyName !== 'value') { + return; + } + if (getInstIfValueChanged(activeElementInst)) { + manualDispatchChangeEvent(nativeEvent); + } +} + +function handleEventsForInputEventPolyfill(topLevelType, target, targetInst) { + if (topLevelType === 'topFocus') { + // In IE9, propertychange fires for most input events but is buggy and + // doesn't fire when text is deleted, but conveniently, selectionchange + // appears to fire in all of the remaining cases so we catch those and + // forward the event if the value has changed + // In either case, we don't want to call the event handler if the value + // is changed from JS so we redefine a setter for `.value` that updates + // our activeElementValue variable, allowing us to ignore those changes + // + // stopWatching() should be a noop here but we call it just in case we + // missed a blur event somehow. + stopWatchingForValueChange(); + startWatchingForValueChange(target, targetInst); + } else if (topLevelType === 'topBlur') { + stopWatchingForValueChange(); + } +} + +// For IE8 and IE9. +function getTargetInstForInputEventPolyfill(topLevelType, targetInst) { + if (topLevelType === 'topSelectionChange' || topLevelType === 'topKeyUp' || topLevelType === 'topKeyDown') { + // On the selectionchange event, the target is just document which isn't + // helpful for us so just check activeElement instead. + // + // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire + // propertychange on the first input event after setting `value` from a + // script and fires only keydown, keypress, keyup. Catching keyup usually + // gets it and catching keydown lets us fire an event for the first + // keystroke if user does a key repeat (it'll be a little delayed: right + // before the second keystroke). Other input methods (e.g., paste) seem to + // fire selectionchange normally. + return getInstIfValueChanged(activeElementInst); + } +} + +/** + * SECTION: handle `click` event + */ +function shouldUseClickEvent(elem) { + // Use the `click` event to detect changes to checkbox and radio inputs. + // This approach works across all browsers, whereas `change` does not fire + // until `blur` in IE8. + var nodeName = elem.nodeName; + return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio'); +} + +function getTargetInstForClickEvent(topLevelType, targetInst) { + if (topLevelType === 'topClick') { + return getInstIfValueChanged(targetInst); + } +} + +function getTargetInstForInputOrChangeEvent(topLevelType, targetInst) { + if (topLevelType === 'topInput' || topLevelType === 'topChange') { + return getInstIfValueChanged(targetInst); + } +} + +function handleControlledInputBlur(inst, node) { + // TODO: In IE, inst is occasionally null. Why? + if (inst == null) { + return; + } + + // Fiber and ReactDOM keep wrapper state in separate places + var state = inst._wrapperState || node._wrapperState; + + if (!state || !state.controlled || node.type !== 'number') { + return; + } + + // If controlled, assign the value attribute to the current value on blur + setDefaultValue(node, 'number', node.value); +} + +/** + * This plugin creates an `onChange` event that normalizes change events + * across form elements. This event fires at a time when it's possible to + * change the element's value without seeing a flicker. + * + * Supported elements are: + * - input (see `isTextInputElement`) + * - textarea + * - select + */ +var ChangeEventPlugin = { + eventTypes: eventTypes$1, + + _isInputEventSupported: isInputEventSupported, + + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var targetNode = targetInst ? getNodeFromInstance$1(targetInst) : window; + + var getTargetInstFunc = void 0, + handleEventFunc = void 0; + if (shouldUseChangeEvent(targetNode)) { + getTargetInstFunc = getTargetInstForChangeEvent; + } else if (isTextInputElement(targetNode)) { + if (isInputEventSupported) { + getTargetInstFunc = getTargetInstForInputOrChangeEvent; + } else { + getTargetInstFunc = getTargetInstForInputEventPolyfill; + handleEventFunc = handleEventsForInputEventPolyfill; + } + } else if (shouldUseClickEvent(targetNode)) { + getTargetInstFunc = getTargetInstForClickEvent; + } + + if (getTargetInstFunc) { + var inst = getTargetInstFunc(topLevelType, targetInst); + if (inst) { + var event = createAndAccumulateChangeEvent(inst, nativeEvent, nativeEventTarget); + return event; + } + } + + if (handleEventFunc) { + handleEventFunc(topLevelType, targetNode, targetInst); + } + + // When blurring, set the value attribute for number inputs + if (topLevelType === 'topBlur') { + handleControlledInputBlur(targetInst, targetNode); + } + } +}; + +/** + * Module that is injectable into `EventPluginHub`, that specifies a + * deterministic ordering of `EventPlugin`s. A convenient way to reason about + * plugins, without having to package every one of them. This is better than + * having plugins be ordered in the same order that they are injected because + * that ordering would be influenced by the packaging order. + * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that + * preventing default on events is convenient in `SimpleEventPlugin` handlers. + */ +var DOMEventPluginOrder = ['ResponderEventPlugin', 'SimpleEventPlugin', 'TapEventPlugin', 'EnterLeaveEventPlugin', 'ChangeEventPlugin', 'SelectEventPlugin', 'BeforeInputEventPlugin']; + +var SyntheticUIEvent = SyntheticEvent$1.extend({ + view: null, + detail: null +}); + +/** + * Translation from modifier key to the associated property in the event. + * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers + */ + +var modifierKeyToProp = { + Alt: 'altKey', + Control: 'ctrlKey', + Meta: 'metaKey', + Shift: 'shiftKey' +}; + +// IE8 does not implement getModifierState so we simply map it to the only +// modifier keys exposed by the event itself, does not support Lock-keys. +// Currently, all major browsers except Chrome seems to support Lock-keys. +function modifierStateGetter(keyArg) { + var syntheticEvent = this; + var nativeEvent = syntheticEvent.nativeEvent; + if (nativeEvent.getModifierState) { + return nativeEvent.getModifierState(keyArg); + } + var keyProp = modifierKeyToProp[keyArg]; + return keyProp ? !!nativeEvent[keyProp] : false; +} + +function getEventModifierState(nativeEvent) { + return modifierStateGetter; +} + +/** + * @interface MouseEvent + * @see http://www.w3.org/TR/DOM-Level-3-Events/ + */ +var SyntheticMouseEvent = SyntheticUIEvent.extend({ + screenX: null, + screenY: null, + clientX: null, + clientY: null, + pageX: null, + pageY: null, + ctrlKey: null, + shiftKey: null, + altKey: null, + metaKey: null, + getModifierState: getEventModifierState, + button: null, + buttons: null, + relatedTarget: function (event) { + return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement); + } +}); + +var eventTypes$2 = { + mouseEnter: { + registrationName: 'onMouseEnter', + dependencies: ['topMouseOut', 'topMouseOver'] + }, + mouseLeave: { + registrationName: 'onMouseLeave', + dependencies: ['topMouseOut', 'topMouseOver'] + } +}; + +var EnterLeaveEventPlugin = { + eventTypes: eventTypes$2, + + /** + * For almost every interaction we care about, there will be both a top-level + * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that + * we do not extract duplicate events. However, moving the mouse into the + * browser from outside will not fire a `mouseout` event. In this case, we use + * the `mouseover` top-level event. + */ + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) { + if (topLevelType === 'topMouseOver' && (nativeEvent.relatedTarget || nativeEvent.fromElement)) { + return null; + } + if (topLevelType !== 'topMouseOut' && topLevelType !== 'topMouseOver') { + // Must not be a mouse in or mouse out - ignoring. + return null; + } + + var win = void 0; + if (nativeEventTarget.window === nativeEventTarget) { + // `nativeEventTarget` is probably a window object. + win = nativeEventTarget; + } else { + // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8. + var doc = nativeEventTarget.ownerDocument; + if (doc) { + win = doc.defaultView || doc.parentWindow; + } else { + win = window; + } + } + + var from = void 0; + var to = void 0; + if (topLevelType === 'topMouseOut') { + from = targetInst; + var related = nativeEvent.relatedTarget || nativeEvent.toElement; + to = related ? getClosestInstanceFromNode(related) : null; + } else { + // Moving to a node from outside the window. + from = null; + to = targetInst; + } + + if (from === to) { + // Nothing pertains to our managed components. + return null; + } + + var fromNode = from == null ? win : getNodeFromInstance$1(from); + var toNode = to == null ? win : getNodeFromInstance$1(to); + + var leave = SyntheticMouseEvent.getPooled(eventTypes$2.mouseLeave, from, nativeEvent, nativeEventTarget); + leave.type = 'mouseleave'; + leave.target = fromNode; + leave.relatedTarget = toNode; + + var enter = SyntheticMouseEvent.getPooled(eventTypes$2.mouseEnter, to, nativeEvent, nativeEventTarget); + enter.type = 'mouseenter'; + enter.target = toNode; + enter.relatedTarget = fromNode; + + accumulateEnterLeaveDispatches(leave, enter, from, to); + + return [leave, enter]; + } +}; + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + +/* eslint-disable fb-www/typeof-undefined */ + +/** + * Same as document.activeElement but wraps in a try-catch block. In IE it is + * not safe to call document.activeElement if there is nothing focused. + * + * The activeElement will be null only if the document or document body is not + * yet defined. + * + * @param {?DOMDocument} doc Defaults to current document. + * @return {?DOMElement} + */ +function getActiveElement(doc) /*?DOMElement*/{ + doc = doc || (typeof document !== 'undefined' ? document : undefined); + if (typeof doc === 'undefined') { + return null; + } + try { + return doc.activeElement || doc.body; + } catch (e) { + return doc.body; + } +} + +var getActiveElement_1 = getActiveElement; + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + * + */ + +/*eslint-disable no-self-compare */ + + + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +/** + * inlined Object.is polyfill to avoid requiring consumers ship their own + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is + */ +function is(x, y) { + // SameValue algorithm + if (x === y) { + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + // Added the nonzero y check to make Flow happy, but it is redundant + return x !== 0 || y !== 0 || 1 / x === 1 / y; + } else { + // Step 6.a: NaN == NaN + return x !== x && y !== y; + } +} + +/** + * Performs equality by iterating through keys on an object and returning false + * when any key has values which are not strictly equal between the arguments. + * Returns true when the values of all keys are strictly equal. + */ +function shallowEqual(objA, objB) { + if (is(objA, objB)) { + return true; + } + + if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) { + return false; + } + + var keysA = Object.keys(objA); + var keysB = Object.keys(objB); + + if (keysA.length !== keysB.length) { + return false; + } + + // Test for A's keys different from B. + for (var i = 0; i < keysA.length; i++) { + if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { + return false; + } + } + + return true; +} + +var shallowEqual_1 = shallowEqual; + +/** + * `ReactInstanceMap` maintains a mapping from a public facing stateful + * instance (key) and the internal representation (value). This allows public + * methods to accept the user facing instance as an argument and map them back + * to internal methods. + * + * Note that this module is currently shared and assumed to be stateless. + * If this becomes an actual Map, that will break. + */ + +/** + * This API should be called `delete` but we'd have to make sure to always + * transform these to strings for IE support. When this transform is fully + * supported we can rename it. + */ + + +function get(key) { + return key._reactInternalFiber; +} + +function has(key) { + return key._reactInternalFiber !== undefined; +} + +function set(key, value) { + key._reactInternalFiber = value; +} + +// Don't change these two values. They're used by React Dev Tools. +var NoEffect = /* */0; +var PerformedWork = /* */1; + +// You can change the rest (and add more). +var Placement = /* */2; +var Update = /* */4; +var PlacementAndUpdate = /* */6; +var Deletion = /* */8; +var ContentReset = /* */16; +var Callback = /* */32; +var DidCapture = /* */64; +var Ref = /* */128; +var ErrLog = /* */256; +var Snapshot = /* */2048; + +// Union of all host effects +var HostEffectMask = /* */2559; + +var Incomplete = /* */512; +var ShouldCapture = /* */1024; + +var MOUNTING = 1; +var MOUNTED = 2; +var UNMOUNTED = 3; + +function isFiberMountedImpl(fiber) { + var node = fiber; + if (!fiber.alternate) { + // If there is no alternate, this might be a new tree that isn't inserted + // yet. If it is, then it will have a pending insertion effect on it. + if ((node.effectTag & Placement) !== NoEffect) { + return MOUNTING; + } + while (node['return']) { + node = node['return']; + if ((node.effectTag & Placement) !== NoEffect) { + return MOUNTING; + } + } + } else { + while (node['return']) { + node = node['return']; + } + } + if (node.tag === HostRoot) { + // TODO: Check if this was a nested HostRoot when used with + // renderContainerIntoSubtree. + return MOUNTED; + } + // If we didn't hit the root, that means that we're in an disconnected tree + // that has been unmounted. + return UNMOUNTED; +} + +function isFiberMounted(fiber) { + return isFiberMountedImpl(fiber) === MOUNTED; +} + +function isMounted(component) { + { + var owner = ReactCurrentOwner.current; + if (owner !== null && owner.tag === ClassComponent) { + var ownerFiber = owner; + var instance = ownerFiber.stateNode; + warning_1(instance._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', getComponentName(ownerFiber) || 'A component'); + instance._warnedAboutRefsInRender = true; + } + } + + var fiber = get(component); + if (!fiber) { + return false; + } + return isFiberMountedImpl(fiber) === MOUNTED; +} + +function assertIsMounted(fiber) { + !(isFiberMountedImpl(fiber) === MOUNTED) ? invariant_1(false, 'Unable to find node on an unmounted component.') : void 0; +} + +function findCurrentFiberUsingSlowPath(fiber) { + var alternate = fiber.alternate; + if (!alternate) { + // If there is no alternate, then we only need to check if it is mounted. + var state = isFiberMountedImpl(fiber); + !(state !== UNMOUNTED) ? invariant_1(false, 'Unable to find node on an unmounted component.') : void 0; + if (state === MOUNTING) { + return null; + } + return fiber; + } + // If we have two possible branches, we'll walk backwards up to the root + // to see what path the root points to. On the way we may hit one of the + // special cases and we'll deal with them. + var a = fiber; + var b = alternate; + while (true) { + var parentA = a['return']; + var parentB = parentA ? parentA.alternate : null; + if (!parentA || !parentB) { + // We're at the root. + break; + } + + // If both copies of the parent fiber point to the same child, we can + // assume that the child is current. This happens when we bailout on low + // priority: the bailed out fiber's child reuses the current child. + if (parentA.child === parentB.child) { + var child = parentA.child; + while (child) { + if (child === a) { + // We've determined that A is the current branch. + assertIsMounted(parentA); + return fiber; + } + if (child === b) { + // We've determined that B is the current branch. + assertIsMounted(parentA); + return alternate; + } + child = child.sibling; + } + // We should never have an alternate for any mounting node. So the only + // way this could possibly happen is if this was unmounted, if at all. + invariant_1(false, 'Unable to find node on an unmounted component.'); + } + + if (a['return'] !== b['return']) { + // The return pointer of A and the return pointer of B point to different + // fibers. We assume that return pointers never criss-cross, so A must + // belong to the child set of A.return, and B must belong to the child + // set of B.return. + a = parentA; + b = parentB; + } else { + // The return pointers point to the same fiber. We'll have to use the + // default, slow path: scan the child sets of each parent alternate to see + // which child belongs to which set. + // + // Search parent A's child set + var didFindChild = false; + var _child = parentA.child; + while (_child) { + if (_child === a) { + didFindChild = true; + a = parentA; + b = parentB; + break; + } + if (_child === b) { + didFindChild = true; + b = parentA; + a = parentB; + break; + } + _child = _child.sibling; + } + if (!didFindChild) { + // Search parent B's child set + _child = parentB.child; + while (_child) { + if (_child === a) { + didFindChild = true; + a = parentB; + b = parentA; + break; + } + if (_child === b) { + didFindChild = true; + b = parentB; + a = parentA; + break; + } + _child = _child.sibling; + } + !didFindChild ? invariant_1(false, 'Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.') : void 0; + } + } + + !(a.alternate === b) ? invariant_1(false, 'Return fibers should always be each others\' alternates. This error is likely caused by a bug in React. Please file an issue.') : void 0; + } + // If the root is not a host container, we're in a disconnected tree. I.e. + // unmounted. + !(a.tag === HostRoot) ? invariant_1(false, 'Unable to find node on an unmounted component.') : void 0; + if (a.stateNode.current === a) { + // We've determined that A is the current branch. + return fiber; + } + // Otherwise B has to be current branch. + return alternate; +} + +function findCurrentHostFiber(parent) { + var currentParent = findCurrentFiberUsingSlowPath(parent); + if (!currentParent) { + return null; + } + + // Next we'll drill down this component to find the first HostComponent/Text. + var node = currentParent; + while (true) { + if (node.tag === HostComponent || node.tag === HostText) { + return node; + } else if (node.child) { + node.child['return'] = node; + node = node.child; + continue; + } + if (node === currentParent) { + return null; + } + while (!node.sibling) { + if (!node['return'] || node['return'] === currentParent) { + return null; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + // Flow needs the return null here, but ESLint complains about it. + // eslint-disable-next-line no-unreachable + return null; +} + +function findCurrentHostFiberWithNoPortals(parent) { + var currentParent = findCurrentFiberUsingSlowPath(parent); + if (!currentParent) { + return null; + } + + // Next we'll drill down this component to find the first HostComponent/Text. + var node = currentParent; + while (true) { + if (node.tag === HostComponent || node.tag === HostText) { + return node; + } else if (node.child && node.tag !== HostPortal) { + node.child['return'] = node; + node = node.child; + continue; + } + if (node === currentParent) { + return null; + } + while (!node.sibling) { + if (!node['return'] || node['return'] === currentParent) { + return null; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + // Flow needs the return null here, but ESLint complains about it. + // eslint-disable-next-line no-unreachable + return null; +} + +function addEventBubbleListener(element, eventType, listener) { + element.addEventListener(eventType, listener, false); +} + +function addEventCaptureListener(element, eventType, listener) { + element.addEventListener(eventType, listener, true); +} + +/** + * @interface Event + * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface + * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent + */ +var SyntheticAnimationEvent = SyntheticEvent$1.extend({ + animationName: null, + elapsedTime: null, + pseudoElement: null +}); + +/** + * @interface Event + * @see http://www.w3.org/TR/clipboard-apis/ + */ +var SyntheticClipboardEvent = SyntheticEvent$1.extend({ + clipboardData: function (event) { + return 'clipboardData' in event ? event.clipboardData : window.clipboardData; + } +}); + +/** + * @interface FocusEvent + * @see http://www.w3.org/TR/DOM-Level-3-Events/ + */ +var SyntheticFocusEvent = SyntheticUIEvent.extend({ + relatedTarget: null +}); + +/** + * `charCode` represents the actual "character code" and is safe to use with + * `String.fromCharCode`. As such, only keys that correspond to printable + * characters produce a valid `charCode`, the only exception to this is Enter. + * The Tab-key is considered non-printable and does not have a `charCode`, + * presumably because it does not produce a tab-character in browsers. + * + * @param {object} nativeEvent Native browser event. + * @return {number} Normalized `charCode` property. + */ +function getEventCharCode(nativeEvent) { + var charCode = void 0; + var keyCode = nativeEvent.keyCode; + + if ('charCode' in nativeEvent) { + charCode = nativeEvent.charCode; + + // FF does not set `charCode` for the Enter-key, check against `keyCode`. + if (charCode === 0 && keyCode === 13) { + charCode = 13; + } + } else { + // IE8 does not implement `charCode`, but `keyCode` has the correct value. + charCode = keyCode; + } + + // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux) + // report Enter as charCode 10 when ctrl is pressed. + if (charCode === 10) { + charCode = 13; + } + + // Some non-printable keys are reported in `charCode`/`keyCode`, discard them. + // Must not discard the (non-)printable Enter-key. + if (charCode >= 32 || charCode === 13) { + return charCode; + } + + return 0; +} + +/** + * Normalization of deprecated HTML5 `key` values + * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names + */ +var normalizeKey = { + Esc: 'Escape', + Spacebar: ' ', + Left: 'ArrowLeft', + Up: 'ArrowUp', + Right: 'ArrowRight', + Down: 'ArrowDown', + Del: 'Delete', + Win: 'OS', + Menu: 'ContextMenu', + Apps: 'ContextMenu', + Scroll: 'ScrollLock', + MozPrintableKey: 'Unidentified' +}; + +/** + * Translation from legacy `keyCode` to HTML5 `key` + * Only special keys supported, all others depend on keyboard layout or browser + * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names + */ +var translateToKey = { + '8': 'Backspace', + '9': 'Tab', + '12': 'Clear', + '13': 'Enter', + '16': 'Shift', + '17': 'Control', + '18': 'Alt', + '19': 'Pause', + '20': 'CapsLock', + '27': 'Escape', + '32': ' ', + '33': 'PageUp', + '34': 'PageDown', + '35': 'End', + '36': 'Home', + '37': 'ArrowLeft', + '38': 'ArrowUp', + '39': 'ArrowRight', + '40': 'ArrowDown', + '45': 'Insert', + '46': 'Delete', + '112': 'F1', + '113': 'F2', + '114': 'F3', + '115': 'F4', + '116': 'F5', + '117': 'F6', + '118': 'F7', + '119': 'F8', + '120': 'F9', + '121': 'F10', + '122': 'F11', + '123': 'F12', + '144': 'NumLock', + '145': 'ScrollLock', + '224': 'Meta' +}; + +/** + * @param {object} nativeEvent Native browser event. + * @return {string} Normalized `key` property. + */ +function getEventKey(nativeEvent) { + if (nativeEvent.key) { + // Normalize inconsistent values reported by browsers due to + // implementations of a working draft specification. + + // FireFox implements `key` but returns `MozPrintableKey` for all + // printable characters (normalized to `Unidentified`), ignore it. + var key = normalizeKey[nativeEvent.key] || nativeEvent.key; + if (key !== 'Unidentified') { + return key; + } + } + + // Browser does not implement `key`, polyfill as much of it as we can. + if (nativeEvent.type === 'keypress') { + var charCode = getEventCharCode(nativeEvent); + + // The enter-key is technically both printable and non-printable and can + // thus be captured by `keypress`, no other non-printable key should. + return charCode === 13 ? 'Enter' : String.fromCharCode(charCode); + } + if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') { + // While user keyboard layout determines the actual meaning of each + // `keyCode` value, almost all function keys have a universal value. + return translateToKey[nativeEvent.keyCode] || 'Unidentified'; + } + return ''; +} + +/** + * @interface KeyboardEvent + * @see http://www.w3.org/TR/DOM-Level-3-Events/ + */ +var SyntheticKeyboardEvent = SyntheticUIEvent.extend({ + key: getEventKey, + location: null, + ctrlKey: null, + shiftKey: null, + altKey: null, + metaKey: null, + repeat: null, + locale: null, + getModifierState: getEventModifierState, + // Legacy Interface + charCode: function (event) { + // `charCode` is the result of a KeyPress event and represents the value of + // the actual printable character. + + // KeyPress is deprecated, but its replacement is not yet final and not + // implemented in any major browser. Only KeyPress has charCode. + if (event.type === 'keypress') { + return getEventCharCode(event); + } + return 0; + }, + keyCode: function (event) { + // `keyCode` is the result of a KeyDown/Up event and represents the value of + // physical keyboard key. + + // The actual meaning of the value depends on the users' keyboard layout + // which cannot be detected. Assuming that it is a US keyboard layout + // provides a surprisingly accurate mapping for US and European users. + // Due to this, it is left to the user to implement at this time. + if (event.type === 'keydown' || event.type === 'keyup') { + return event.keyCode; + } + return 0; + }, + which: function (event) { + // `which` is an alias for either `keyCode` or `charCode` depending on the + // type of the event. + if (event.type === 'keypress') { + return getEventCharCode(event); + } + if (event.type === 'keydown' || event.type === 'keyup') { + return event.keyCode; + } + return 0; + } +}); + +/** + * @interface DragEvent + * @see http://www.w3.org/TR/DOM-Level-3-Events/ + */ +var SyntheticDragEvent = SyntheticMouseEvent.extend({ + dataTransfer: null +}); + +/** + * @interface TouchEvent + * @see http://www.w3.org/TR/touch-events/ + */ +var SyntheticTouchEvent = SyntheticUIEvent.extend({ + touches: null, + targetTouches: null, + changedTouches: null, + altKey: null, + metaKey: null, + ctrlKey: null, + shiftKey: null, + getModifierState: getEventModifierState +}); + +/** + * @interface Event + * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events- + * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent + */ +var SyntheticTransitionEvent = SyntheticEvent$1.extend({ + propertyName: null, + elapsedTime: null, + pseudoElement: null +}); + +/** + * @interface WheelEvent + * @see http://www.w3.org/TR/DOM-Level-3-Events/ + */ +var SyntheticWheelEvent = SyntheticMouseEvent.extend({ + deltaX: function (event) { + return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive). + 'wheelDeltaX' in event ? -event.wheelDeltaX : 0; + }, + deltaY: function (event) { + return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive). + 'wheelDeltaY' in event ? -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive). + 'wheelDelta' in event ? -event.wheelDelta : 0; + }, + + deltaZ: null, + + // Browsers without "deltaMode" is reporting in raw wheel delta where one + // notch on the scroll is always +/- 120, roughly equivalent to pixels. + // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or + // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size. + deltaMode: null +}); + +/** + * Turns + * ['abort', ...] + * into + * eventTypes = { + * 'abort': { + * phasedRegistrationNames: { + * bubbled: 'onAbort', + * captured: 'onAbortCapture', + * }, + * dependencies: ['topAbort'], + * }, + * ... + * }; + * topLevelEventsToDispatchConfig = { + * 'topAbort': { sameConfig } + * }; + */ +var interactiveEventTypeNames = ['blur', 'cancel', 'click', 'close', 'contextMenu', 'copy', 'cut', 'doubleClick', 'dragEnd', 'dragStart', 'drop', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'mouseDown', 'mouseUp', 'paste', 'pause', 'play', 'rateChange', 'reset', 'seeked', 'submit', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange']; +var nonInteractiveEventTypeNames = ['abort', 'animationEnd', 'animationIteration', 'animationStart', 'canPlay', 'canPlayThrough', 'drag', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'mouseMove', 'mouseOut', 'mouseOver', 'playing', 'progress', 'scroll', 'seeking', 'stalled', 'suspend', 'timeUpdate', 'toggle', 'touchMove', 'transitionEnd', 'waiting', 'wheel']; + +var eventTypes$4 = {}; +var topLevelEventsToDispatchConfig = {}; + +function addEventTypeNameToConfig(event, isInteractive) { + var capitalizedEvent = event[0].toUpperCase() + event.slice(1); + var onEvent = 'on' + capitalizedEvent; + var topEvent = 'top' + capitalizedEvent; + + var type = { + phasedRegistrationNames: { + bubbled: onEvent, + captured: onEvent + 'Capture' + }, + dependencies: [topEvent], + isInteractive: isInteractive + }; + eventTypes$4[event] = type; + topLevelEventsToDispatchConfig[topEvent] = type; +} + +interactiveEventTypeNames.forEach(function (eventTypeName) { + addEventTypeNameToConfig(eventTypeName, true); +}); +nonInteractiveEventTypeNames.forEach(function (eventTypeName) { + addEventTypeNameToConfig(eventTypeName, false); +}); + +// Only used in DEV for exhaustiveness validation. +var knownHTMLTopLevelTypes = ['topAbort', 'topCancel', 'topCanPlay', 'topCanPlayThrough', 'topClose', 'topDurationChange', 'topEmptied', 'topEncrypted', 'topEnded', 'topError', 'topInput', 'topInvalid', 'topLoad', 'topLoadedData', 'topLoadedMetadata', 'topLoadStart', 'topPause', 'topPlay', 'topPlaying', 'topProgress', 'topRateChange', 'topReset', 'topSeeked', 'topSeeking', 'topStalled', 'topSubmit', 'topSuspend', 'topTimeUpdate', 'topToggle', 'topVolumeChange', 'topWaiting']; + +var SimpleEventPlugin = { + eventTypes: eventTypes$4, + + isInteractiveTopLevelEventType: function (topLevelType) { + var config = topLevelEventsToDispatchConfig[topLevelType]; + return config !== undefined && config.isInteractive === true; + }, + + + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType]; + if (!dispatchConfig) { + return null; + } + var EventConstructor = void 0; + switch (topLevelType) { + case 'topKeyPress': + // Firefox creates a keypress event for function keys too. This removes + // the unwanted keypress events. Enter is however both printable and + // non-printable. One would expect Tab to be as well (but it isn't). + if (getEventCharCode(nativeEvent) === 0) { + return null; + } + /* falls through */ + case 'topKeyDown': + case 'topKeyUp': + EventConstructor = SyntheticKeyboardEvent; + break; + case 'topBlur': + case 'topFocus': + EventConstructor = SyntheticFocusEvent; + break; + case 'topClick': + // Firefox creates a click event on right mouse clicks. This removes the + // unwanted click events. + if (nativeEvent.button === 2) { + return null; + } + /* falls through */ + case 'topDoubleClick': + case 'topMouseDown': + case 'topMouseMove': + case 'topMouseUp': + // TODO: Disabled elements should not respond to mouse events + /* falls through */ + case 'topMouseOut': + case 'topMouseOver': + case 'topContextMenu': + EventConstructor = SyntheticMouseEvent; + break; + case 'topDrag': + case 'topDragEnd': + case 'topDragEnter': + case 'topDragExit': + case 'topDragLeave': + case 'topDragOver': + case 'topDragStart': + case 'topDrop': + EventConstructor = SyntheticDragEvent; + break; + case 'topTouchCancel': + case 'topTouchEnd': + case 'topTouchMove': + case 'topTouchStart': + EventConstructor = SyntheticTouchEvent; + break; + case 'topAnimationEnd': + case 'topAnimationIteration': + case 'topAnimationStart': + EventConstructor = SyntheticAnimationEvent; + break; + case 'topTransitionEnd': + EventConstructor = SyntheticTransitionEvent; + break; + case 'topScroll': + EventConstructor = SyntheticUIEvent; + break; + case 'topWheel': + EventConstructor = SyntheticWheelEvent; + break; + case 'topCopy': + case 'topCut': + case 'topPaste': + EventConstructor = SyntheticClipboardEvent; + break; + default: + { + if (knownHTMLTopLevelTypes.indexOf(topLevelType) === -1) { + warning_1(false, 'SimpleEventPlugin: Unhandled event type, `%s`. This warning ' + 'is likely caused by a bug in React. Please file an issue.', topLevelType); + } + } + // HTML Events + // @see http://www.w3.org/TR/html5/index.html#events-0 + EventConstructor = SyntheticEvent$1; + break; + } + var event = EventConstructor.getPooled(dispatchConfig, targetInst, nativeEvent, nativeEventTarget); + accumulateTwoPhaseDispatches(event); + return event; + } +}; + +var isInteractiveTopLevelEventType = SimpleEventPlugin.isInteractiveTopLevelEventType; + + +var CALLBACK_BOOKKEEPING_POOL_SIZE = 10; +var callbackBookkeepingPool = []; + +/** + * Find the deepest React component completely containing the root of the + * passed-in instance (for use when entire React trees are nested within each + * other). If React trees are not nested, returns null. + */ +function findRootContainerNode(inst) { + // TODO: It may be a good idea to cache this to prevent unnecessary DOM + // traversal, but caching is difficult to do correctly without using a + // mutation observer to listen for all DOM changes. + while (inst['return']) { + inst = inst['return']; + } + if (inst.tag !== HostRoot) { + // This can happen if we're in a detached tree. + return null; + } + return inst.stateNode.containerInfo; +} + +// Used to store ancestor hierarchy in top level callback +function getTopLevelCallbackBookKeeping(topLevelType, nativeEvent, targetInst) { + if (callbackBookkeepingPool.length) { + var instance = callbackBookkeepingPool.pop(); + instance.topLevelType = topLevelType; + instance.nativeEvent = nativeEvent; + instance.targetInst = targetInst; + return instance; + } + return { + topLevelType: topLevelType, + nativeEvent: nativeEvent, + targetInst: targetInst, + ancestors: [] + }; +} + +function releaseTopLevelCallbackBookKeeping(instance) { + instance.topLevelType = null; + instance.nativeEvent = null; + instance.targetInst = null; + instance.ancestors.length = 0; + if (callbackBookkeepingPool.length < CALLBACK_BOOKKEEPING_POOL_SIZE) { + callbackBookkeepingPool.push(instance); + } +} + +function handleTopLevel(bookKeeping) { + var targetInst = bookKeeping.targetInst; + + // Loop through the hierarchy, in case there's any nested components. + // It's important that we build the array of ancestors before calling any + // event handlers, because event handlers can modify the DOM, leading to + // inconsistencies with ReactMount's node cache. See #1105. + var ancestor = targetInst; + do { + if (!ancestor) { + bookKeeping.ancestors.push(ancestor); + break; + } + var root = findRootContainerNode(ancestor); + if (!root) { + break; + } + bookKeeping.ancestors.push(ancestor); + ancestor = getClosestInstanceFromNode(root); + } while (ancestor); + + for (var i = 0; i < bookKeeping.ancestors.length; i++) { + targetInst = bookKeeping.ancestors[i]; + runExtractedEventsInBatch(bookKeeping.topLevelType, targetInst, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent)); + } +} + +// TODO: can we stop exporting these? +var _enabled = true; + +function setEnabled(enabled) { + _enabled = !!enabled; +} + +function isEnabled() { + return _enabled; +} + +/** + * Traps top-level events by using event bubbling. + * + * @param {string} topLevelType Record from `BrowserEventConstants`. + * @param {string} handlerBaseName Event name (e.g. "click"). + * @param {object} element Element on which to attach listener. + * @return {?object} An object with a remove function which will forcefully + * remove the listener. + * @internal + */ +function trapBubbledEvent(topLevelType, handlerBaseName, element) { + if (!element) { + return null; + } + var dispatch = isInteractiveTopLevelEventType(topLevelType) ? dispatchInteractiveEvent : dispatchEvent; + + addEventBubbleListener(element, handlerBaseName, + // Check if interactive and wrap in interactiveUpdates + dispatch.bind(null, topLevelType)); +} + +/** + * Traps a top-level event by using event capturing. + * + * @param {string} topLevelType Record from `BrowserEventConstants`. + * @param {string} handlerBaseName Event name (e.g. "click"). + * @param {object} element Element on which to attach listener. + * @return {?object} An object with a remove function which will forcefully + * remove the listener. + * @internal + */ +function trapCapturedEvent(topLevelType, handlerBaseName, element) { + if (!element) { + return null; + } + var dispatch = isInteractiveTopLevelEventType(topLevelType) ? dispatchInteractiveEvent : dispatchEvent; + + addEventCaptureListener(element, handlerBaseName, + // Check if interactive and wrap in interactiveUpdates + dispatch.bind(null, topLevelType)); +} + +function dispatchInteractiveEvent(topLevelType, nativeEvent) { + interactiveUpdates(dispatchEvent, topLevelType, nativeEvent); +} + +function dispatchEvent(topLevelType, nativeEvent) { + if (!_enabled) { + return; + } + + var nativeEventTarget = getEventTarget(nativeEvent); + var targetInst = getClosestInstanceFromNode(nativeEventTarget); + if (targetInst !== null && typeof targetInst.tag === 'number' && !isFiberMounted(targetInst)) { + // If we get an event (ex: img onload) before committing that + // component's mount, ignore it for now (that is, treat it as if it was an + // event on a non-React tree). We might also consider queueing events and + // dispatching them after the mount. + targetInst = null; + } + + var bookKeeping = getTopLevelCallbackBookKeeping(topLevelType, nativeEvent, targetInst); + + try { + // Event queue being processed in the same cycle allows + // `preventDefault`. + batchedUpdates(handleTopLevel, bookKeeping); + } finally { + releaseTopLevelCallbackBookKeeping(bookKeeping); + } +} + +var ReactDOMEventListener = Object.freeze({ + get _enabled () { return _enabled; }, + setEnabled: setEnabled, + isEnabled: isEnabled, + trapBubbledEvent: trapBubbledEvent, + trapCapturedEvent: trapCapturedEvent, + dispatchEvent: dispatchEvent +}); + +/** + * Generate a mapping of standard vendor prefixes using the defined style property and event name. + * + * @param {string} styleProp + * @param {string} eventName + * @returns {object} + */ +function makePrefixMap(styleProp, eventName) { + var prefixes = {}; + + prefixes[styleProp.toLowerCase()] = eventName.toLowerCase(); + prefixes['Webkit' + styleProp] = 'webkit' + eventName; + prefixes['Moz' + styleProp] = 'moz' + eventName; + prefixes['ms' + styleProp] = 'MS' + eventName; + prefixes['O' + styleProp] = 'o' + eventName.toLowerCase(); + + return prefixes; +} + +/** + * A list of event names to a configurable list of vendor prefixes. + */ +var vendorPrefixes = { + animationend: makePrefixMap('Animation', 'AnimationEnd'), + animationiteration: makePrefixMap('Animation', 'AnimationIteration'), + animationstart: makePrefixMap('Animation', 'AnimationStart'), + transitionend: makePrefixMap('Transition', 'TransitionEnd') +}; + +/** + * Event names that have already been detected and prefixed (if applicable). + */ +var prefixedEventNames = {}; + +/** + * Element to check for prefixes on. + */ +var style = {}; + +/** + * Bootstrap if a DOM exists. + */ +if (ExecutionEnvironment_1.canUseDOM) { + style = document.createElement('div').style; + + // On some platforms, in particular some releases of Android 4.x, + // the un-prefixed "animation" and "transition" properties are defined on the + // style object but the events that fire will still be prefixed, so we need + // to check if the un-prefixed events are usable, and if not remove them from the map. + if (!('AnimationEvent' in window)) { + delete vendorPrefixes.animationend.animation; + delete vendorPrefixes.animationiteration.animation; + delete vendorPrefixes.animationstart.animation; + } + + // Same as above + if (!('TransitionEvent' in window)) { + delete vendorPrefixes.transitionend.transition; + } +} + +/** + * Attempts to determine the correct vendor prefixed event name. + * + * @param {string} eventName + * @returns {string} + */ +function getVendorPrefixedEventName(eventName) { + if (prefixedEventNames[eventName]) { + return prefixedEventNames[eventName]; + } else if (!vendorPrefixes[eventName]) { + return eventName; + } + + var prefixMap = vendorPrefixes[eventName]; + + for (var styleProp in prefixMap) { + if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) { + return prefixedEventNames[eventName] = prefixMap[styleProp]; + } + } + + return eventName; +} + +/** + * Types of raw signals from the browser caught at the top level. + * + * For events like 'submit' or audio/video events which don't consistently + * bubble (which we trap at a lower node than `document`), binding + * at `document` would cause duplicate events so we don't include them here. + */ +var topLevelTypes = { + topAnimationEnd: getVendorPrefixedEventName('animationend'), + topAnimationIteration: getVendorPrefixedEventName('animationiteration'), + topAnimationStart: getVendorPrefixedEventName('animationstart'), + topBlur: 'blur', + topCancel: 'cancel', + topChange: 'change', + topClick: 'click', + topClose: 'close', + topCompositionEnd: 'compositionend', + topCompositionStart: 'compositionstart', + topCompositionUpdate: 'compositionupdate', + topContextMenu: 'contextmenu', + topCopy: 'copy', + topCut: 'cut', + topDoubleClick: 'dblclick', + topDrag: 'drag', + topDragEnd: 'dragend', + topDragEnter: 'dragenter', + topDragExit: 'dragexit', + topDragLeave: 'dragleave', + topDragOver: 'dragover', + topDragStart: 'dragstart', + topDrop: 'drop', + topFocus: 'focus', + topInput: 'input', + topKeyDown: 'keydown', + topKeyPress: 'keypress', + topKeyUp: 'keyup', + topLoad: 'load', + topLoadStart: 'loadstart', + topMouseDown: 'mousedown', + topMouseMove: 'mousemove', + topMouseOut: 'mouseout', + topMouseOver: 'mouseover', + topMouseUp: 'mouseup', + topPaste: 'paste', + topScroll: 'scroll', + topSelectionChange: 'selectionchange', + topTextInput: 'textInput', + topToggle: 'toggle', + topTouchCancel: 'touchcancel', + topTouchEnd: 'touchend', + topTouchMove: 'touchmove', + topTouchStart: 'touchstart', + topTransitionEnd: getVendorPrefixedEventName('transitionend'), + topWheel: 'wheel' +}; + +// There are so many media events, it makes sense to just +// maintain a list of them. Note these aren't technically +// "top-level" since they don't bubble. We should come up +// with a better naming convention if we come to refactoring +// the event system. +var mediaEventTypes = { + topAbort: 'abort', + topCanPlay: 'canplay', + topCanPlayThrough: 'canplaythrough', + topDurationChange: 'durationchange', + topEmptied: 'emptied', + topEncrypted: 'encrypted', + topEnded: 'ended', + topError: 'error', + topLoadedData: 'loadeddata', + topLoadedMetadata: 'loadedmetadata', + topLoadStart: 'loadstart', + topPause: 'pause', + topPlay: 'play', + topPlaying: 'playing', + topProgress: 'progress', + topRateChange: 'ratechange', + topSeeked: 'seeked', + topSeeking: 'seeking', + topStalled: 'stalled', + topSuspend: 'suspend', + topTimeUpdate: 'timeupdate', + topVolumeChange: 'volumechange', + topWaiting: 'waiting' +}; + +/** + * Summary of `ReactBrowserEventEmitter` event handling: + * + * - Top-level delegation is used to trap most native browser events. This + * may only occur in the main thread and is the responsibility of + * ReactDOMEventListener, which is injected and can therefore support + * pluggable event sources. This is the only work that occurs in the main + * thread. + * + * - We normalize and de-duplicate events to account for browser quirks. This + * may be done in the worker thread. + * + * - Forward these native events (with the associated top-level type used to + * trap it) to `EventPluginHub`, which in turn will ask plugins if they want + * to extract any synthetic events. + * + * - The `EventPluginHub` will then process each event by annotating them with + * "dispatches", a sequence of listeners and IDs that care about that event. + * + * - The `EventPluginHub` then dispatches the events. + * + * Overview of React and the event system: + * + * +------------+ . + * | DOM | . + * +------------+ . + * | . + * v . + * +------------+ . + * | ReactEvent | . + * | Listener | . + * +------------+ . +-----------+ + * | . +--------+|SimpleEvent| + * | . | |Plugin | + * +-----|------+ . v +-----------+ + * | | | . +--------------+ +------------+ + * | +-----------.--->|EventPluginHub| | Event | + * | | . | | +-----------+ | Propagators| + * | ReactEvent | . | | |TapEvent | |------------| + * | Emitter | . | |<---+|Plugin | |other plugin| + * | | . | | +-----------+ | utilities | + * | +-----------.--->| | +------------+ + * | | | . +--------------+ + * +-----|------+ . ^ +-----------+ + * | . | |Enter/Leave| + * + . +-------+|Plugin | + * +-------------+ . +-----------+ + * | application | . + * |-------------| . + * | | . + * | | . + * +-------------+ . + * . + * React Core . General Purpose Event Plugin System + */ + +var alreadyListeningTo = {}; +var reactTopListenersCounter = 0; + +/** + * To ensure no conflicts with other potential React instances on the page + */ +var topListenersIDKey = '_reactListenersID' + ('' + Math.random()).slice(2); + +function getListeningForDocument(mountAt) { + // In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty` + // directly. + if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) { + mountAt[topListenersIDKey] = reactTopListenersCounter++; + alreadyListeningTo[mountAt[topListenersIDKey]] = {}; + } + return alreadyListeningTo[mountAt[topListenersIDKey]]; +} + +/** + * We listen for bubbled touch events on the document object. + * + * Firefox v8.01 (and possibly others) exhibited strange behavior when + * mounting `onmousemove` events at some node that was not the document + * element. The symptoms were that if your mouse is not moving over something + * contained within that mount point (for example on the background) the + * top-level listeners for `onmousemove` won't be called. However, if you + * register the `mousemove` on the document object, then it will of course + * catch all `mousemove`s. This along with iOS quirks, justifies restricting + * top-level listeners to the document object only, at least for these + * movement types of events and possibly all events. + * + * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html + * + * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but + * they bubble to document. + * + * @param {string} registrationName Name of listener (e.g. `onClick`). + * @param {object} contentDocumentHandle Document which owns the container + */ +function listenTo(registrationName, contentDocumentHandle) { + var mountAt = contentDocumentHandle; + var isListening = getListeningForDocument(mountAt); + var dependencies = registrationNameDependencies[registrationName]; + + for (var i = 0; i < dependencies.length; i++) { + var dependency = dependencies[i]; + if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) { + if (dependency === 'topScroll') { + trapCapturedEvent('topScroll', 'scroll', mountAt); + } else if (dependency === 'topFocus' || dependency === 'topBlur') { + trapCapturedEvent('topFocus', 'focus', mountAt); + trapCapturedEvent('topBlur', 'blur', mountAt); + + // to make sure blur and focus event listeners are only attached once + isListening.topBlur = true; + isListening.topFocus = true; + } else if (dependency === 'topCancel') { + if (isEventSupported('cancel', true)) { + trapCapturedEvent('topCancel', 'cancel', mountAt); + } + isListening.topCancel = true; + } else if (dependency === 'topClose') { + if (isEventSupported('close', true)) { + trapCapturedEvent('topClose', 'close', mountAt); + } + isListening.topClose = true; + } else if (topLevelTypes.hasOwnProperty(dependency)) { + trapBubbledEvent(dependency, topLevelTypes[dependency], mountAt); + } + + isListening[dependency] = true; + } + } +} + +function isListeningToAllDependencies(registrationName, mountAt) { + var isListening = getListeningForDocument(mountAt); + var dependencies = registrationNameDependencies[registrationName]; + for (var i = 0; i < dependencies.length; i++) { + var dependency = dependencies[i]; + if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) { + return false; + } + } + return true; +} + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + +/** + * @param {*} object The object to check. + * @return {boolean} Whether or not the object is a DOM node. + */ +function isNode(object) { + var doc = object ? object.ownerDocument || object : document; + var defaultView = doc.defaultView || window; + return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string')); +} + +var isNode_1 = isNode; + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + + + +/** + * @param {*} object The object to check. + * @return {boolean} Whether or not the object is a DOM text node. + */ +function isTextNode(object) { + return isNode_1(object) && object.nodeType == 3; +} + +var isTextNode_1 = isTextNode; + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * + */ + + + +/*eslint-disable no-bitwise */ + +/** + * Checks if a given DOM node contains or is another DOM node. + */ +function containsNode(outerNode, innerNode) { + if (!outerNode || !innerNode) { + return false; + } else if (outerNode === innerNode) { + return true; + } else if (isTextNode_1(outerNode)) { + return false; + } else if (isTextNode_1(innerNode)) { + return containsNode(outerNode, innerNode.parentNode); + } else if ('contains' in outerNode) { + return outerNode.contains(innerNode); + } else if (outerNode.compareDocumentPosition) { + return !!(outerNode.compareDocumentPosition(innerNode) & 16); + } else { + return false; + } +} + +var containsNode_1 = containsNode; + +/** + * Given any node return the first leaf node without children. + * + * @param {DOMElement|DOMTextNode} node + * @return {DOMElement|DOMTextNode} + */ +function getLeafNode(node) { + while (node && node.firstChild) { + node = node.firstChild; + } + return node; +} + +/** + * Get the next sibling within a container. This will walk up the + * DOM if a node's siblings have been exhausted. + * + * @param {DOMElement|DOMTextNode} node + * @return {?DOMElement|DOMTextNode} + */ +function getSiblingNode(node) { + while (node) { + if (node.nextSibling) { + return node.nextSibling; + } + node = node.parentNode; + } +} + +/** + * Get object describing the nodes which contain characters at offset. + * + * @param {DOMElement|DOMTextNode} root + * @param {number} offset + * @return {?object} + */ +function getNodeForCharacterOffset(root, offset) { + var node = getLeafNode(root); + var nodeStart = 0; + var nodeEnd = 0; + + while (node) { + if (node.nodeType === TEXT_NODE) { + nodeEnd = nodeStart + node.textContent.length; + + if (nodeStart <= offset && nodeEnd >= offset) { + return { + node: node, + offset: offset - nodeStart + }; + } + + nodeStart = nodeEnd; + } + + node = getLeafNode(getSiblingNode(node)); + } +} + +/** + * @param {DOMElement} outerNode + * @return {?object} + */ +function getOffsets(outerNode) { + var selection = window.getSelection && window.getSelection(); + + if (!selection || selection.rangeCount === 0) { + return null; + } + + var anchorNode = selection.anchorNode, + anchorOffset = selection.anchorOffset, + focusNode = selection.focusNode, + focusOffset = selection.focusOffset; + + // In Firefox, anchorNode and focusNode can be "anonymous divs", e.g. the + // up/down buttons on an . Anonymous divs do not seem to + // expose properties, triggering a "Permission denied error" if any of its + // properties are accessed. The only seemingly possible way to avoid erroring + // is to access a property that typically works for non-anonymous divs and + // catch any error that may otherwise arise. See + // https://bugzilla.mozilla.org/show_bug.cgi?id=208427 + + try { + /* eslint-disable no-unused-expressions */ + anchorNode.nodeType; + focusNode.nodeType; + /* eslint-enable no-unused-expressions */ + } catch (e) { + return null; + } + + return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset); +} + +/** + * Returns {start, end} where `start` is the character/codepoint index of + * (anchorNode, anchorOffset) within the textContent of `outerNode`, and + * `end` is the index of (focusNode, focusOffset). + * + * Returns null if you pass in garbage input but we should probably just crash. + * + * Exported only for testing. + */ +function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) { + var length = 0; + var start = -1; + var end = -1; + var indexWithinAnchor = 0; + var indexWithinFocus = 0; + var node = outerNode; + var parentNode = null; + + outer: while (true) { + var next = null; + + while (true) { + if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) { + start = length + anchorOffset; + } + if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) { + end = length + focusOffset; + } + + if (node.nodeType === TEXT_NODE) { + length += node.nodeValue.length; + } + + if ((next = node.firstChild) === null) { + break; + } + // Moving from `node` to its first child `next`. + parentNode = node; + node = next; + } + + while (true) { + if (node === outerNode) { + // If `outerNode` has children, this is always the second time visiting + // it. If it has no children, this is still the first loop, and the only + // valid selection is anchorNode and focusNode both equal to this node + // and both offsets 0, in which case we will have handled above. + break outer; + } + if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) { + start = length; + } + if (parentNode === focusNode && ++indexWithinFocus === focusOffset) { + end = length; + } + if ((next = node.nextSibling) !== null) { + break; + } + node = parentNode; + parentNode = node.parentNode; + } + + // Moving from `node` to its next sibling `next`. + node = next; + } + + if (start === -1 || end === -1) { + // This should never happen. (Would happen if the anchor/focus nodes aren't + // actually inside the passed-in node.) + return null; + } + + return { + start: start, + end: end + }; +} + +/** + * In modern non-IE browsers, we can support both forward and backward + * selections. + * + * Note: IE10+ supports the Selection object, but it does not support + * the `extend` method, which means that even in modern IE, it's not possible + * to programmatically create a backward selection. Thus, for all IE + * versions, we use the old IE API to create our selections. + * + * @param {DOMElement|DOMTextNode} node + * @param {object} offsets + */ +function setOffsets(node, offsets) { + if (!window.getSelection) { + return; + } + + var selection = window.getSelection(); + var length = node[getTextContentAccessor()].length; + var start = Math.min(offsets.start, length); + var end = offsets.end === undefined ? start : Math.min(offsets.end, length); + + // IE 11 uses modern selection, but doesn't support the extend method. + // Flip backward selections, so we can set with a single range. + if (!selection.extend && start > end) { + var temp = end; + end = start; + start = temp; + } + + var startMarker = getNodeForCharacterOffset(node, start); + var endMarker = getNodeForCharacterOffset(node, end); + + if (startMarker && endMarker) { + if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) { + return; + } + var range = document.createRange(); + range.setStart(startMarker.node, startMarker.offset); + selection.removeAllRanges(); + + if (start > end) { + selection.addRange(range); + selection.extend(endMarker.node, endMarker.offset); + } else { + range.setEnd(endMarker.node, endMarker.offset); + selection.addRange(range); + } + } +} + +function isInDocument(node) { + return containsNode_1(document.documentElement, node); +} + +/** + * @ReactInputSelection: React input selection module. Based on Selection.js, + * but modified to be suitable for react and has a couple of bug fixes (doesn't + * assume buttons have range selections allowed). + * Input selection module for React. + */ + +function hasSelectionCapabilities(elem) { + var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase(); + return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true'); +} + +function getSelectionInformation() { + var focusedElem = getActiveElement_1(); + return { + focusedElem: focusedElem, + selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null + }; +} + +/** + * @restoreSelection: If any selection information was potentially lost, + * restore it. This is useful when performing operations that could remove dom + * nodes and place them back in, resulting in focus being lost. + */ +function restoreSelection(priorSelectionInformation) { + var curFocusedElem = getActiveElement_1(); + var priorFocusedElem = priorSelectionInformation.focusedElem; + var priorSelectionRange = priorSelectionInformation.selectionRange; + if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) { + if (hasSelectionCapabilities(priorFocusedElem)) { + setSelection(priorFocusedElem, priorSelectionRange); + } + + // Focusing a node can change the scroll position, which is undesirable + var ancestors = []; + var ancestor = priorFocusedElem; + while (ancestor = ancestor.parentNode) { + if (ancestor.nodeType === ELEMENT_NODE) { + ancestors.push({ + element: ancestor, + left: ancestor.scrollLeft, + top: ancestor.scrollTop + }); + } + } + + priorFocusedElem.focus(); + + for (var i = 0; i < ancestors.length; i++) { + var info = ancestors[i]; + info.element.scrollLeft = info.left; + info.element.scrollTop = info.top; + } + } +} + +/** + * @getSelection: Gets the selection bounds of a focused textarea, input or + * contentEditable node. + * -@input: Look up selection bounds of this input + * -@return {start: selectionStart, end: selectionEnd} + */ +function getSelection$1(input) { + var selection = void 0; + + if ('selectionStart' in input) { + // Modern browser with input or textarea. + selection = { + start: input.selectionStart, + end: input.selectionEnd + }; + } else { + // Content editable or old IE textarea. + selection = getOffsets(input); + } + + return selection || { start: 0, end: 0 }; +} + +/** + * @setSelection: Sets the selection bounds of a textarea or input and focuses + * the input. + * -@input Set selection bounds of this input or textarea + * -@offsets Object of same form that is returned from get* + */ +function setSelection(input, offsets) { + var start = offsets.start, + end = offsets.end; + + if (end === undefined) { + end = start; + } + + if ('selectionStart' in input) { + input.selectionStart = start; + input.selectionEnd = Math.min(end, input.value.length); + } else { + setOffsets(input, offsets); + } +} + +var skipSelectionChangeEvent = ExecutionEnvironment_1.canUseDOM && 'documentMode' in document && document.documentMode <= 11; + +var eventTypes$3 = { + select: { + phasedRegistrationNames: { + bubbled: 'onSelect', + captured: 'onSelectCapture' + }, + dependencies: ['topBlur', 'topContextMenu', 'topFocus', 'topKeyDown', 'topKeyUp', 'topMouseDown', 'topMouseUp', 'topSelectionChange'] + } +}; + +var activeElement$1 = null; +var activeElementInst$1 = null; +var lastSelection = null; +var mouseDown = false; + +/** + * Get an object which is a unique representation of the current selection. + * + * The return value will not be consistent across nodes or browsers, but + * two identical selections on the same node will return identical objects. + * + * @param {DOMElement} node + * @return {object} + */ +function getSelection(node) { + if ('selectionStart' in node && hasSelectionCapabilities(node)) { + return { + start: node.selectionStart, + end: node.selectionEnd + }; + } else if (window.getSelection) { + var selection = window.getSelection(); + return { + anchorNode: selection.anchorNode, + anchorOffset: selection.anchorOffset, + focusNode: selection.focusNode, + focusOffset: selection.focusOffset + }; + } +} + +/** + * Poll selection to see whether it's changed. + * + * @param {object} nativeEvent + * @return {?SyntheticEvent} + */ +function constructSelectEvent(nativeEvent, nativeEventTarget) { + // Ensure we have the right element, and that the user is not dragging a + // selection (this matches native `select` event behavior). In HTML5, select + // fires only on input and textarea thus if there's no focused element we + // won't dispatch. + if (mouseDown || activeElement$1 == null || activeElement$1 !== getActiveElement_1()) { + return null; + } + + // Only fire when selection has actually changed. + var currentSelection = getSelection(activeElement$1); + if (!lastSelection || !shallowEqual_1(lastSelection, currentSelection)) { + lastSelection = currentSelection; + + var syntheticEvent = SyntheticEvent$1.getPooled(eventTypes$3.select, activeElementInst$1, nativeEvent, nativeEventTarget); + + syntheticEvent.type = 'select'; + syntheticEvent.target = activeElement$1; + + accumulateTwoPhaseDispatches(syntheticEvent); + + return syntheticEvent; + } + + return null; +} + +/** + * This plugin creates an `onSelect` event that normalizes select events + * across form elements. + * + * Supported elements are: + * - input (see `isTextInputElement`) + * - textarea + * - contentEditable + * + * This differs from native browser implementations in the following ways: + * - Fires on contentEditable fields as well as inputs. + * - Fires for collapsed selection. + * - Fires after user input. + */ +var SelectEventPlugin = { + eventTypes: eventTypes$3, + + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) { + var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : nativeEventTarget.nodeType === DOCUMENT_NODE ? nativeEventTarget : nativeEventTarget.ownerDocument; + // Track whether all listeners exists for this plugin. If none exist, we do + // not extract events. See #3639. + if (!doc || !isListeningToAllDependencies('onSelect', doc)) { + return null; + } + + var targetNode = targetInst ? getNodeFromInstance$1(targetInst) : window; + + switch (topLevelType) { + // Track the input node that has focus. + case 'topFocus': + if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') { + activeElement$1 = targetNode; + activeElementInst$1 = targetInst; + lastSelection = null; + } + break; + case 'topBlur': + activeElement$1 = null; + activeElementInst$1 = null; + lastSelection = null; + break; + // Don't fire the event while the user is dragging. This matches the + // semantics of the native select event. + case 'topMouseDown': + mouseDown = true; + break; + case 'topContextMenu': + case 'topMouseUp': + mouseDown = false; + return constructSelectEvent(nativeEvent, nativeEventTarget); + // Chrome and IE fire non-standard event when selection is changed (and + // sometimes when it hasn't). IE's event fires out of order with respect + // to key and input events on deletion, so we discard it. + // + // Firefox doesn't support selectionchange, so check selection status + // after each key entry. The selection changes after keydown and before + // keyup, but we check on keydown as well in the case of holding down a + // key, when multiple keydown events are fired but only one keyup is. + // This is also our approach for IE handling, for the reason above. + case 'topSelectionChange': + if (skipSelectionChangeEvent) { + break; + } + // falls through + case 'topKeyDown': + case 'topKeyUp': + return constructSelectEvent(nativeEvent, nativeEventTarget); + } + + return null; + } +}; + +/** + * Inject modules for resolving DOM hierarchy and plugin ordering. + */ +injection.injectEventPluginOrder(DOMEventPluginOrder); +injection$1.injectComponentTree(ReactDOMComponentTree); + +/** + * Some important event plugins included by default (without having to require + * them). + */ +injection.injectEventPluginsByName({ + SimpleEventPlugin: SimpleEventPlugin, + EnterLeaveEventPlugin: EnterLeaveEventPlugin, + ChangeEventPlugin: ChangeEventPlugin, + SelectEventPlugin: SelectEventPlugin, + BeforeInputEventPlugin: BeforeInputEventPlugin +}); + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var emptyObject = {}; + +{ + Object.freeze(emptyObject); +} + +var emptyObject_1 = emptyObject; + +// Max 31 bit integer. The max integer size in V8 for 32-bit systems. +// Math.pow(2, 30) - 1 +// 0b111111111111111111111111111111 +var MAX_SIGNED_31_BIT_INT = 1073741823; + +// TODO: Use an opaque type once ESLint et al support the syntax + + +var NoWork = 0; +var Sync = 1; +var Never = MAX_SIGNED_31_BIT_INT; + +var UNIT_SIZE = 10; +var MAGIC_NUMBER_OFFSET = 2; + +// 1 unit of expiration time represents 10ms. +function msToExpirationTime(ms) { + // Always add an offset so that we don't clash with the magic number for NoWork. + return (ms / UNIT_SIZE | 0) + MAGIC_NUMBER_OFFSET; +} + +function expirationTimeToMs(expirationTime) { + return (expirationTime - MAGIC_NUMBER_OFFSET) * UNIT_SIZE; +} + +function ceiling(num, precision) { + return ((num / precision | 0) + 1) * precision; +} + +function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) { + return ceiling(currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE); +} + +var NoContext = 0; +var AsyncMode = 1; +var StrictMode = 2; + +var hasBadMapPolyfill = void 0; + +{ + hasBadMapPolyfill = false; + try { + var nonExtensibleObject = Object.preventExtensions({}); + var testMap = new Map([[nonExtensibleObject, null]]); + var testSet = new Set([nonExtensibleObject]); + // This is necessary for Rollup to not consider these unused. + // https://github.com/rollup/rollup/issues/1771 + // TODO: we can remove these if Rollup fixes the bug. + testMap.set(0, 0); + testSet.add(0); + } catch (e) { + // TODO: Consider warning about bad polyfills + hasBadMapPolyfill = true; + } +} + +// A Fiber is work on a Component that needs to be done or was done. There can +// be more than one per component. + + +var debugCounter = void 0; + +{ + debugCounter = 1; +} + +function FiberNode(tag, pendingProps, key, mode) { + // Instance + this.tag = tag; + this.key = key; + this.type = null; + this.stateNode = null; + + // Fiber + this['return'] = null; + this.child = null; + this.sibling = null; + this.index = 0; + + this.ref = null; + + this.pendingProps = pendingProps; + this.memoizedProps = null; + this.updateQueue = null; + this.memoizedState = null; + + this.mode = mode; + + // Effects + this.effectTag = NoEffect; + this.nextEffect = null; + + this.firstEffect = null; + this.lastEffect = null; + + this.expirationTime = NoWork; + + this.alternate = null; + + { + this._debugID = debugCounter++; + this._debugSource = null; + this._debugOwner = null; + this._debugIsCurrentlyTiming = false; + if (!hasBadMapPolyfill && typeof Object.preventExtensions === 'function') { + Object.preventExtensions(this); + } + } +} + +// This is a constructor function, rather than a POJO constructor, still +// please ensure we do the following: +// 1) Nobody should add any instance methods on this. Instance methods can be +// more difficult to predict when they get optimized and they are almost +// never inlined properly in static compilers. +// 2) Nobody should rely on `instanceof Fiber` for type testing. We should +// always know when it is a fiber. +// 3) We might want to experiment with using numeric keys since they are easier +// to optimize in a non-JIT environment. +// 4) We can easily go from a constructor to a createFiber object literal if that +// is faster. +// 5) It should be easy to port this to a C struct and keep a C implementation +// compatible. +var createFiber = function (tag, pendingProps, key, mode) { + // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors + return new FiberNode(tag, pendingProps, key, mode); +}; + +function shouldConstruct(Component) { + return !!(Component.prototype && Component.prototype.isReactComponent); +} + +// This is used to create an alternate fiber to do work on. +function createWorkInProgress(current, pendingProps, expirationTime) { + var workInProgress = current.alternate; + if (workInProgress === null) { + // We use a double buffering pooling technique because we know that we'll + // only ever need at most two versions of a tree. We pool the "other" unused + // node that we're free to reuse. This is lazily created to avoid allocating + // extra objects for things that are never updated. It also allow us to + // reclaim the extra memory if needed. + workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode); + workInProgress.type = current.type; + workInProgress.stateNode = current.stateNode; + + { + // DEV-only fields + workInProgress._debugID = current._debugID; + workInProgress._debugSource = current._debugSource; + workInProgress._debugOwner = current._debugOwner; + } + + workInProgress.alternate = current; + current.alternate = workInProgress; + } else { + workInProgress.pendingProps = pendingProps; + + // We already have an alternate. + // Reset the effect tag. + workInProgress.effectTag = NoEffect; + + // The effect list is no longer valid. + workInProgress.nextEffect = null; + workInProgress.firstEffect = null; + workInProgress.lastEffect = null; + } + + workInProgress.expirationTime = expirationTime; + + workInProgress.child = current.child; + workInProgress.memoizedProps = current.memoizedProps; + workInProgress.memoizedState = current.memoizedState; + workInProgress.updateQueue = current.updateQueue; + + // These will be overridden during the parent's reconciliation + workInProgress.sibling = current.sibling; + workInProgress.index = current.index; + workInProgress.ref = current.ref; + + return workInProgress; +} + +function createHostRootFiber(isAsync) { + var mode = isAsync ? AsyncMode | StrictMode : NoContext; + return createFiber(HostRoot, null, null, mode); +} + +function createFiberFromElement(element, mode, expirationTime) { + var owner = null; + { + owner = element._owner; + } + + var fiber = void 0; + var type = element.type; + var key = element.key; + var pendingProps = element.props; + + var fiberTag = void 0; + if (typeof type === 'function') { + fiberTag = shouldConstruct(type) ? ClassComponent : IndeterminateComponent; + } else if (typeof type === 'string') { + fiberTag = HostComponent; + } else { + switch (type) { + case REACT_FRAGMENT_TYPE: + return createFiberFromFragment(pendingProps.children, mode, expirationTime, key); + case REACT_ASYNC_MODE_TYPE: + fiberTag = Mode; + mode |= AsyncMode | StrictMode; + break; + case REACT_STRICT_MODE_TYPE: + fiberTag = Mode; + mode |= StrictMode; + break; + case REACT_CALL_TYPE: + fiberTag = CallComponent; + break; + case REACT_RETURN_TYPE: + fiberTag = ReturnComponent; + break; + default: + { + if (typeof type === 'object' && type !== null) { + switch (type.$$typeof) { + case REACT_PROVIDER_TYPE: + fiberTag = ContextProvider; + break; + case REACT_CONTEXT_TYPE: + // This is a consumer + fiberTag = ContextConsumer; + break; + case REACT_FORWARD_REF_TYPE: + fiberTag = ForwardRef; + break; + default: + if (typeof type.tag === 'number') { + // Currently assumed to be a continuation and therefore is a + // fiber already. + // TODO: The yield system is currently broken for updates in + // some cases. The reified yield stores a fiber, but we don't + // know which fiber that is; the current or a workInProgress? + // When the continuation gets rendered here we don't know if we + // can reuse that fiber or if we need to clone it. There is + // probably a clever way to restructure this. + fiber = type; + fiber.pendingProps = pendingProps; + fiber.expirationTime = expirationTime; + return fiber; + } else { + throwOnInvalidElementType(type, owner); + } + break; + } + } else { + throwOnInvalidElementType(type, owner); + } + } + } + } + + fiber = createFiber(fiberTag, pendingProps, key, mode); + fiber.type = type; + fiber.expirationTime = expirationTime; + + { + fiber._debugSource = element._source; + fiber._debugOwner = element._owner; + } + + return fiber; +} + +function throwOnInvalidElementType(type, owner) { + var info = ''; + { + if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { + info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and " + 'named imports.'; + } + var ownerName = owner ? getComponentName(owner) : null; + if (ownerName) { + info += '\n\nCheck the render method of `' + ownerName + '`.'; + } + } + invariant_1(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', type == null ? type : typeof type, info); +} + +function createFiberFromFragment(elements, mode, expirationTime, key) { + var fiber = createFiber(Fragment, elements, key, mode); + fiber.expirationTime = expirationTime; + return fiber; +} + +function createFiberFromText(content, mode, expirationTime) { + var fiber = createFiber(HostText, content, null, mode); + fiber.expirationTime = expirationTime; + return fiber; +} + +function createFiberFromHostInstanceForDeletion() { + var fiber = createFiber(HostComponent, null, null, NoContext); + fiber.type = 'DELETED'; + return fiber; +} + +function createFiberFromPortal(portal, mode, expirationTime) { + var pendingProps = portal.children !== null ? portal.children : []; + var fiber = createFiber(HostPortal, pendingProps, portal.key, mode); + fiber.expirationTime = expirationTime; + fiber.stateNode = { + containerInfo: portal.containerInfo, + pendingChildren: null, // Used by persistent updates + implementation: portal.implementation + }; + return fiber; +} + +// TODO: This should be lifted into the renderer. + + +function createFiberRoot(containerInfo, isAsync, hydrate) { + // Cyclic construction. This cheats the type system right now because + // stateNode is any. + var uninitializedFiber = createHostRootFiber(isAsync); + var root = { + current: uninitializedFiber, + containerInfo: containerInfo, + pendingChildren: null, + pendingCommitExpirationTime: NoWork, + finishedWork: null, + context: null, + pendingContext: null, + hydrate: hydrate, + remainingExpirationTime: NoWork, + firstBatch: null, + nextScheduledRoot: null + }; + uninitializedFiber.stateNode = root; + return root; +} + +var onCommitFiberRoot = null; +var onCommitFiberUnmount = null; +var hasLoggedError = false; + +function catchErrors(fn) { + return function (arg) { + try { + return fn(arg); + } catch (err) { + if (true && !hasLoggedError) { + hasLoggedError = true; + warning_1(false, 'React DevTools encountered an error: %s', err); + } + } + }; +} + +function injectInternals(internals) { + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') { + // No DevTools + return false; + } + var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__; + if (hook.isDisabled) { + // This isn't a real property on the hook, but it can be set to opt out + // of DevTools integration and associated warnings and logs. + // https://github.com/facebook/react/issues/3877 + return true; + } + if (!hook.supportsFiber) { + { + warning_1(false, 'The installed version of React DevTools is too old and will not work ' + 'with the current version of React. Please update React DevTools. ' + 'https://fb.me/react-devtools'); + } + // DevTools exists, even though it doesn't support Fiber. + return true; + } + try { + var rendererID = hook.inject(internals); + // We have successfully injected, so now it is safe to set up hooks. + onCommitFiberRoot = catchErrors(function (root) { + return hook.onCommitFiberRoot(rendererID, root); + }); + onCommitFiberUnmount = catchErrors(function (fiber) { + return hook.onCommitFiberUnmount(rendererID, fiber); + }); + } catch (err) { + // Catch all errors because it is unsafe to throw during initialization. + { + warning_1(false, 'React DevTools encountered an error: %s.', err); + } + } + // DevTools exists + return true; +} + +function onCommitRoot(root) { + if (typeof onCommitFiberRoot === 'function') { + onCommitFiberRoot(root); + } +} + +function onCommitUnmount(fiber) { + if (typeof onCommitFiberUnmount === 'function') { + onCommitFiberUnmount(fiber); + } +} + +/** + * Forked from fbjs/warning: + * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js + * + * Only change is we use console.warn instead of console.error, + * and do nothing when 'console' is not supported. + * This really simplifies the code. + * --- + * Similar to invariant but only logs a warning if the condition is not met. + * This can be used to log issues in development environments in critical + * paths. Removing the logging code for production environments will keep the + * same logic and follow the same code paths. + */ + +var lowPriorityWarning = function () {}; + +{ + var printWarning$1 = function (format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + var argIndex = 0; + var message = 'Warning: ' + format.replace(/%s/g, function () { + return args[argIndex++]; + }); + if (typeof console !== 'undefined') { + console.warn(message); + } + try { + // --- Welcome to debugging React --- + // This error was thrown as a convenience so that you can use this stack + // to find the callsite that caused this warning to fire. + throw new Error(message); + } catch (x) {} + }; + + lowPriorityWarning = function (condition, format) { + if (format === undefined) { + throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); + } + if (!condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } + + printWarning$1.apply(undefined, [format].concat(args)); + } + }; +} + +var lowPriorityWarning$1 = lowPriorityWarning; + +var ReactStrictModeWarnings = { + discardPendingWarnings: function () {}, + flushPendingDeprecationWarnings: function () {}, + flushPendingUnsafeLifecycleWarnings: function () {}, + recordDeprecationWarnings: function (fiber, instance) {}, + recordUnsafeLifecycleWarnings: function (fiber, instance) {} +}; + +{ + var LIFECYCLE_SUGGESTIONS = { + UNSAFE_componentWillMount: 'componentDidMount', + UNSAFE_componentWillReceiveProps: 'static getDerivedStateFromProps', + UNSAFE_componentWillUpdate: 'componentDidUpdate' + }; + + var pendingComponentWillMountWarnings = []; + var pendingComponentWillReceivePropsWarnings = []; + var pendingComponentWillUpdateWarnings = []; + var pendingUnsafeLifecycleWarnings = new Map(); + + // Tracks components we have already warned about. + var didWarnAboutDeprecatedLifecycles = new Set(); + var didWarnAboutUnsafeLifecycles = new Set(); + + ReactStrictModeWarnings.discardPendingWarnings = function () { + pendingComponentWillMountWarnings = []; + pendingComponentWillReceivePropsWarnings = []; + pendingComponentWillUpdateWarnings = []; + pendingUnsafeLifecycleWarnings = new Map(); + }; + + ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () { + pendingUnsafeLifecycleWarnings.forEach(function (lifecycleWarningsMap, strictRoot) { + var lifecyclesWarningMesages = []; + + Object.keys(lifecycleWarningsMap).forEach(function (lifecycle) { + var lifecycleWarnings = lifecycleWarningsMap[lifecycle]; + if (lifecycleWarnings.length > 0) { + var componentNames = new Set(); + lifecycleWarnings.forEach(function (fiber) { + componentNames.add(getComponentName(fiber) || 'Component'); + didWarnAboutUnsafeLifecycles.add(fiber.type); + }); + + var formatted = lifecycle.replace('UNSAFE_', ''); + var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle]; + var sortedComponentNames = Array.from(componentNames).sort().join(', '); + + lifecyclesWarningMesages.push(formatted + ': Please update the following components to use ' + (suggestion + ' instead: ' + sortedComponentNames)); + } + }); + + if (lifecyclesWarningMesages.length > 0) { + var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(strictRoot); + + warning_1(false, 'Unsafe lifecycle methods were found within a strict-mode tree:%s' + '\n\n%s' + '\n\nLearn more about this warning here:' + '\nhttps://fb.me/react-strict-mode-warnings', strictRootComponentStack, lifecyclesWarningMesages.join('\n\n')); + } + }); + + pendingUnsafeLifecycleWarnings = new Map(); + }; + + var getStrictRoot = function (fiber) { + var maybeStrictRoot = null; + + while (fiber !== null) { + if (fiber.mode & StrictMode) { + maybeStrictRoot = fiber; + } + + fiber = fiber['return']; + } + + return maybeStrictRoot; + }; + + ReactStrictModeWarnings.flushPendingDeprecationWarnings = function () { + if (pendingComponentWillMountWarnings.length > 0) { + var uniqueNames = new Set(); + pendingComponentWillMountWarnings.forEach(function (fiber) { + uniqueNames.add(getComponentName(fiber) || 'Component'); + didWarnAboutDeprecatedLifecycles.add(fiber.type); + }); + + var sortedNames = Array.from(uniqueNames).sort().join(', '); + + lowPriorityWarning$1(false, 'componentWillMount is deprecated and will be removed in the next major version. ' + 'Use componentDidMount instead. As a temporary workaround, ' + 'you can rename to UNSAFE_componentWillMount.' + '\n\nPlease update the following components: %s' + '\n\nLearn more about this warning here:' + '\nhttps://fb.me/react-async-component-lifecycle-hooks', sortedNames); + + pendingComponentWillMountWarnings = []; + } + + if (pendingComponentWillReceivePropsWarnings.length > 0) { + var _uniqueNames = new Set(); + pendingComponentWillReceivePropsWarnings.forEach(function (fiber) { + _uniqueNames.add(getComponentName(fiber) || 'Component'); + didWarnAboutDeprecatedLifecycles.add(fiber.type); + }); + + var _sortedNames = Array.from(_uniqueNames).sort().join(', '); + + lowPriorityWarning$1(false, 'componentWillReceiveProps is deprecated and will be removed in the next major version. ' + 'Use static getDerivedStateFromProps instead.' + '\n\nPlease update the following components: %s' + '\n\nLearn more about this warning here:' + '\nhttps://fb.me/react-async-component-lifecycle-hooks', _sortedNames); + + pendingComponentWillReceivePropsWarnings = []; + } + + if (pendingComponentWillUpdateWarnings.length > 0) { + var _uniqueNames2 = new Set(); + pendingComponentWillUpdateWarnings.forEach(function (fiber) { + _uniqueNames2.add(getComponentName(fiber) || 'Component'); + didWarnAboutDeprecatedLifecycles.add(fiber.type); + }); + + var _sortedNames2 = Array.from(_uniqueNames2).sort().join(', '); + + lowPriorityWarning$1(false, 'componentWillUpdate is deprecated and will be removed in the next major version. ' + 'Use componentDidUpdate instead. As a temporary workaround, ' + 'you can rename to UNSAFE_componentWillUpdate.' + '\n\nPlease update the following components: %s' + '\n\nLearn more about this warning here:' + '\nhttps://fb.me/react-async-component-lifecycle-hooks', _sortedNames2); + + pendingComponentWillUpdateWarnings = []; + } + }; + + ReactStrictModeWarnings.recordDeprecationWarnings = function (fiber, instance) { + // Dedup strategy: Warn once per component. + if (didWarnAboutDeprecatedLifecycles.has(fiber.type)) { + return; + } + + // Don't warn about react-lifecycles-compat polyfilled components. + if (typeof instance.componentWillMount === 'function' && instance.componentWillMount.__suppressDeprecationWarning !== true) { + pendingComponentWillMountWarnings.push(fiber); + } + if (typeof instance.componentWillReceiveProps === 'function' && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) { + pendingComponentWillReceivePropsWarnings.push(fiber); + } + if (typeof instance.componentWillUpdate === 'function' && instance.componentWillUpdate.__suppressDeprecationWarning !== true) { + pendingComponentWillUpdateWarnings.push(fiber); + } + }; + + ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) { + var strictRoot = getStrictRoot(fiber); + + // Dedup strategy: Warn once per component. + // This is difficult to track any other way since component names + // are often vague and are likely to collide between 3rd party libraries. + // An expand property is probably okay to use here since it's DEV-only, + // and will only be set in the event of serious warnings. + if (didWarnAboutUnsafeLifecycles.has(fiber.type)) { + return; + } + + // Don't warn about react-lifecycles-compat polyfilled components. + // Note that it is sufficient to check for the presence of a + // single lifecycle, componentWillMount, with the polyfill flag. + if (typeof instance.componentWillMount === 'function' && instance.componentWillMount.__suppressDeprecationWarning === true) { + return; + } + + var warningsForRoot = void 0; + if (!pendingUnsafeLifecycleWarnings.has(strictRoot)) { + warningsForRoot = { + UNSAFE_componentWillMount: [], + UNSAFE_componentWillReceiveProps: [], + UNSAFE_componentWillUpdate: [] + }; + + pendingUnsafeLifecycleWarnings.set(strictRoot, warningsForRoot); + } else { + warningsForRoot = pendingUnsafeLifecycleWarnings.get(strictRoot); + } + + var unsafeLifecycles = []; + if (typeof instance.componentWillMount === 'function' || typeof instance.UNSAFE_componentWillMount === 'function') { + unsafeLifecycles.push('UNSAFE_componentWillMount'); + } + if (typeof instance.componentWillReceiveProps === 'function' || typeof instance.UNSAFE_componentWillReceiveProps === 'function') { + unsafeLifecycles.push('UNSAFE_componentWillReceiveProps'); + } + if (typeof instance.componentWillUpdate === 'function' || typeof instance.UNSAFE_componentWillUpdate === 'function') { + unsafeLifecycles.push('UNSAFE_componentWillUpdate'); + } + + if (unsafeLifecycles.length > 0) { + unsafeLifecycles.forEach(function (lifecycle) { + warningsForRoot[lifecycle].push(fiber); + }); + } + }; +} + +// Exports ReactDOM.createRoot +var enableUserTimingAPI = true; + +// Mutating mode (React DOM, React ART, React Native): +var enableMutatingReconciler = true; +// Experimental noop mode (currently unused): +var enableNoopReconciler = false; +// Experimental persistent mode (Fabric): +var enablePersistentReconciler = false; +// Experimental error-boundary API that can recover from errors within a single +// render phase +var enableGetDerivedStateFromCatch = false; +// Helps identify side effects in begin-phase lifecycle hooks and setState reducers: +var debugRenderPhaseSideEffects = false; + +// In some cases, StrictMode should also double-render lifecycles. +// This can be confusing for tests though, +// And it can be bad for performance in production. +// This feature flag can be used to control the behavior: +var debugRenderPhaseSideEffectsForStrictMode = true; + +// To preserve the "Pause on caught exceptions" behavior of the debugger, we +// replay the begin phase of a failed component inside invokeGuardedCallback. +var replayFailedUnitOfWorkWithInvokeGuardedCallback = true; + +// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6: +var warnAboutDeprecatedLifecycles = false; + +var alwaysUseRequestIdleCallbackPolyfill = false; + +// Only used in www builds. + +// Prefix measurements so that it's possible to filter them. +// Longer prefixes are hard to read in DevTools. +var reactEmoji = '\u269B'; +var warningEmoji = '\u26D4'; +var supportsUserTiming = typeof performance !== 'undefined' && typeof performance.mark === 'function' && typeof performance.clearMarks === 'function' && typeof performance.measure === 'function' && typeof performance.clearMeasures === 'function'; + +// Keep track of current fiber so that we know the path to unwind on pause. +// TODO: this looks the same as nextUnitOfWork in scheduler. Can we unify them? +var currentFiber = null; +// If we're in the middle of user code, which fiber and method is it? +// Reusing `currentFiber` would be confusing for this because user code fiber +// can change during commit phase too, but we don't need to unwind it (since +// lifecycles in the commit phase don't resemble a tree). +var currentPhase = null; +var currentPhaseFiber = null; +// Did lifecycle hook schedule an update? This is often a performance problem, +// so we will keep track of it, and include it in the report. +// Track commits caused by cascading updates. +var isCommitting = false; +var hasScheduledUpdateInCurrentCommit = false; +var hasScheduledUpdateInCurrentPhase = false; +var commitCountInCurrentWorkLoop = 0; +var effectCountInCurrentCommit = 0; +var isWaitingForCallback = false; +// During commits, we only show a measurement once per method name +// to avoid stretch the commit phase with measurement overhead. +var labelsInCurrentCommit = new Set(); + +var formatMarkName = function (markName) { + return reactEmoji + ' ' + markName; +}; + +var formatLabel = function (label, warning) { + var prefix = warning ? warningEmoji + ' ' : reactEmoji + ' '; + var suffix = warning ? ' Warning: ' + warning : ''; + return '' + prefix + label + suffix; +}; + +var beginMark = function (markName) { + performance.mark(formatMarkName(markName)); +}; + +var clearMark = function (markName) { + performance.clearMarks(formatMarkName(markName)); +}; + +var endMark = function (label, markName, warning) { + var formattedMarkName = formatMarkName(markName); + var formattedLabel = formatLabel(label, warning); + try { + performance.measure(formattedLabel, formattedMarkName); + } catch (err) {} + // If previous mark was missing for some reason, this will throw. + // This could only happen if React crashed in an unexpected place earlier. + // Don't pile on with more errors. + + // Clear marks immediately to avoid growing buffer. + performance.clearMarks(formattedMarkName); + performance.clearMeasures(formattedLabel); +}; + +var getFiberMarkName = function (label, debugID) { + return label + ' (#' + debugID + ')'; +}; + +var getFiberLabel = function (componentName, isMounted, phase) { + if (phase === null) { + // These are composite component total time measurements. + return componentName + ' [' + (isMounted ? 'update' : 'mount') + ']'; + } else { + // Composite component methods. + return componentName + '.' + phase; + } +}; + +var beginFiberMark = function (fiber, phase) { + var componentName = getComponentName(fiber) || 'Unknown'; + var debugID = fiber._debugID; + var isMounted = fiber.alternate !== null; + var label = getFiberLabel(componentName, isMounted, phase); + + if (isCommitting && labelsInCurrentCommit.has(label)) { + // During the commit phase, we don't show duplicate labels because + // there is a fixed overhead for every measurement, and we don't + // want to stretch the commit phase beyond necessary. + return false; + } + labelsInCurrentCommit.add(label); + + var markName = getFiberMarkName(label, debugID); + beginMark(markName); + return true; +}; + +var clearFiberMark = function (fiber, phase) { + var componentName = getComponentName(fiber) || 'Unknown'; + var debugID = fiber._debugID; + var isMounted = fiber.alternate !== null; + var label = getFiberLabel(componentName, isMounted, phase); + var markName = getFiberMarkName(label, debugID); + clearMark(markName); +}; + +var endFiberMark = function (fiber, phase, warning) { + var componentName = getComponentName(fiber) || 'Unknown'; + var debugID = fiber._debugID; + var isMounted = fiber.alternate !== null; + var label = getFiberLabel(componentName, isMounted, phase); + var markName = getFiberMarkName(label, debugID); + endMark(label, markName, warning); +}; + +var shouldIgnoreFiber = function (fiber) { + // Host components should be skipped in the timeline. + // We could check typeof fiber.type, but does this work with RN? + switch (fiber.tag) { + case HostRoot: + case HostComponent: + case HostText: + case HostPortal: + case CallComponent: + case ReturnComponent: + case Fragment: + case ContextProvider: + case ContextConsumer: + return true; + default: + return false; + } +}; + +var clearPendingPhaseMeasurement = function () { + if (currentPhase !== null && currentPhaseFiber !== null) { + clearFiberMark(currentPhaseFiber, currentPhase); + } + currentPhaseFiber = null; + currentPhase = null; + hasScheduledUpdateInCurrentPhase = false; +}; + +var pauseTimers = function () { + // Stops all currently active measurements so that they can be resumed + // if we continue in a later deferred loop from the same unit of work. + var fiber = currentFiber; + while (fiber) { + if (fiber._debugIsCurrentlyTiming) { + endFiberMark(fiber, null, null); + } + fiber = fiber['return']; + } +}; + +var resumeTimersRecursively = function (fiber) { + if (fiber['return'] !== null) { + resumeTimersRecursively(fiber['return']); + } + if (fiber._debugIsCurrentlyTiming) { + beginFiberMark(fiber, null); + } +}; + +var resumeTimers = function () { + // Resumes all measurements that were active during the last deferred loop. + if (currentFiber !== null) { + resumeTimersRecursively(currentFiber); + } +}; + +function recordEffect() { + if (enableUserTimingAPI) { + effectCountInCurrentCommit++; + } +} + +function recordScheduleUpdate() { + if (enableUserTimingAPI) { + if (isCommitting) { + hasScheduledUpdateInCurrentCommit = true; + } + if (currentPhase !== null && currentPhase !== 'componentWillMount' && currentPhase !== 'componentWillReceiveProps') { + hasScheduledUpdateInCurrentPhase = true; + } + } +} + +function startRequestCallbackTimer() { + if (enableUserTimingAPI) { + if (supportsUserTiming && !isWaitingForCallback) { + isWaitingForCallback = true; + beginMark('(Waiting for async callback...)'); + } + } +} + +function stopRequestCallbackTimer(didExpire, expirationTime) { + if (enableUserTimingAPI) { + if (supportsUserTiming) { + isWaitingForCallback = false; + var warning = didExpire ? 'React was blocked by main thread' : null; + endMark('(Waiting for async callback... will force flush in ' + expirationTime + ' ms)', '(Waiting for async callback...)', warning); + } + } +} + +function startWorkTimer(fiber) { + if (enableUserTimingAPI) { + if (!supportsUserTiming || shouldIgnoreFiber(fiber)) { + return; + } + // If we pause, this is the fiber to unwind from. + currentFiber = fiber; + if (!beginFiberMark(fiber, null)) { + return; + } + fiber._debugIsCurrentlyTiming = true; + } +} + +function cancelWorkTimer(fiber) { + if (enableUserTimingAPI) { + if (!supportsUserTiming || shouldIgnoreFiber(fiber)) { + return; + } + // Remember we shouldn't complete measurement for this fiber. + // Otherwise flamechart will be deep even for small updates. + fiber._debugIsCurrentlyTiming = false; + clearFiberMark(fiber, null); + } +} + +function stopWorkTimer(fiber) { + if (enableUserTimingAPI) { + if (!supportsUserTiming || shouldIgnoreFiber(fiber)) { + return; + } + // If we pause, its parent is the fiber to unwind from. + currentFiber = fiber['return']; + if (!fiber._debugIsCurrentlyTiming) { + return; + } + fiber._debugIsCurrentlyTiming = false; + endFiberMark(fiber, null, null); + } +} + +function stopFailedWorkTimer(fiber) { + if (enableUserTimingAPI) { + if (!supportsUserTiming || shouldIgnoreFiber(fiber)) { + return; + } + // If we pause, its parent is the fiber to unwind from. + currentFiber = fiber['return']; + if (!fiber._debugIsCurrentlyTiming) { + return; + } + fiber._debugIsCurrentlyTiming = false; + var warning = 'An error was thrown inside this error boundary'; + endFiberMark(fiber, null, warning); + } +} + +function startPhaseTimer(fiber, phase) { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + clearPendingPhaseMeasurement(); + if (!beginFiberMark(fiber, phase)) { + return; + } + currentPhaseFiber = fiber; + currentPhase = phase; + } +} + +function stopPhaseTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + if (currentPhase !== null && currentPhaseFiber !== null) { + var warning = hasScheduledUpdateInCurrentPhase ? 'Scheduled a cascading update' : null; + endFiberMark(currentPhaseFiber, currentPhase, warning); + } + currentPhase = null; + currentPhaseFiber = null; + } +} + +function startWorkLoopTimer(nextUnitOfWork) { + if (enableUserTimingAPI) { + currentFiber = nextUnitOfWork; + if (!supportsUserTiming) { + return; + } + commitCountInCurrentWorkLoop = 0; + // This is top level call. + // Any other measurements are performed within. + beginMark('(React Tree Reconciliation)'); + // Resume any measurements that were in progress during the last loop. + resumeTimers(); + } +} + +function stopWorkLoopTimer(interruptedBy) { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + var warning = null; + if (interruptedBy !== null) { + if (interruptedBy.tag === HostRoot) { + warning = 'A top-level update interrupted the previous render'; + } else { + var componentName = getComponentName(interruptedBy) || 'Unknown'; + warning = 'An update to ' + componentName + ' interrupted the previous render'; + } + } else if (commitCountInCurrentWorkLoop > 1) { + warning = 'There were cascading updates'; + } + commitCountInCurrentWorkLoop = 0; + // Pause any measurements until the next loop. + pauseTimers(); + endMark('(React Tree Reconciliation)', '(React Tree Reconciliation)', warning); + } +} + +function startCommitTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + isCommitting = true; + hasScheduledUpdateInCurrentCommit = false; + labelsInCurrentCommit.clear(); + beginMark('(Committing Changes)'); + } +} + +function stopCommitTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + + var warning = null; + if (hasScheduledUpdateInCurrentCommit) { + warning = 'Lifecycle hook scheduled a cascading update'; + } else if (commitCountInCurrentWorkLoop > 0) { + warning = 'Caused by a cascading update in earlier commit'; + } + hasScheduledUpdateInCurrentCommit = false; + commitCountInCurrentWorkLoop++; + isCommitting = false; + labelsInCurrentCommit.clear(); + + endMark('(Committing Changes)', '(Committing Changes)', warning); + } +} + +function startCommitSnapshotEffectsTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + effectCountInCurrentCommit = 0; + beginMark('(Committing Snapshot Effects)'); + } +} + +function stopCommitSnapshotEffectsTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + var count = effectCountInCurrentCommit; + effectCountInCurrentCommit = 0; + endMark('(Committing Snapshot Effects: ' + count + ' Total)', '(Committing Snapshot Effects)', null); + } +} + +function startCommitHostEffectsTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + effectCountInCurrentCommit = 0; + beginMark('(Committing Host Effects)'); + } +} + +function stopCommitHostEffectsTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + var count = effectCountInCurrentCommit; + effectCountInCurrentCommit = 0; + endMark('(Committing Host Effects: ' + count + ' Total)', '(Committing Host Effects)', null); + } +} + +function startCommitLifeCyclesTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + effectCountInCurrentCommit = 0; + beginMark('(Calling Lifecycle Methods)'); + } +} + +function stopCommitLifeCyclesTimer() { + if (enableUserTimingAPI) { + if (!supportsUserTiming) { + return; + } + var count = effectCountInCurrentCommit; + effectCountInCurrentCommit = 0; + endMark('(Calling Lifecycle Methods: ' + count + ' Total)', '(Calling Lifecycle Methods)', null); + } +} + +var didWarnUpdateInsideUpdate = void 0; + +{ + didWarnUpdateInsideUpdate = false; +} + +// Callbacks are not validated until invocation + + +// Singly linked-list of updates. When an update is scheduled, it is added to +// the queue of the current fiber and the work-in-progress fiber. The two queues +// are separate but they share a persistent structure. +// +// During reconciliation, updates are removed from the work-in-progress fiber, +// but they remain on the current fiber. That ensures that if a work-in-progress +// is aborted, the aborted updates are recovered by cloning from current. +// +// The work-in-progress queue is always a subset of the current queue. +// +// When the tree is committed, the work-in-progress becomes the current. + + +function createUpdateQueue(baseState) { + var queue = { + baseState: baseState, + expirationTime: NoWork, + first: null, + last: null, + callbackList: null, + hasForceUpdate: false, + isInitialized: false, + capturedValues: null + }; + { + queue.isProcessing = false; + } + return queue; +} + +function insertUpdateIntoQueue(queue, update) { + // Append the update to the end of the list. + if (queue.last === null) { + // Queue is empty + queue.first = queue.last = update; + } else { + queue.last.next = update; + queue.last = update; + } + if (queue.expirationTime === NoWork || queue.expirationTime > update.expirationTime) { + queue.expirationTime = update.expirationTime; + } +} + +var q1 = void 0; +var q2 = void 0; +function ensureUpdateQueues(fiber) { + q1 = q2 = null; + // We'll have at least one and at most two distinct update queues. + var alternateFiber = fiber.alternate; + var queue1 = fiber.updateQueue; + if (queue1 === null) { + // TODO: We don't know what the base state will be until we begin work. + // It depends on which fiber is the next current. Initialize with an empty + // base state, then set to the memoizedState when rendering. Not super + // happy with this approach. + queue1 = fiber.updateQueue = createUpdateQueue(null); + } + + var queue2 = void 0; + if (alternateFiber !== null) { + queue2 = alternateFiber.updateQueue; + if (queue2 === null) { + queue2 = alternateFiber.updateQueue = createUpdateQueue(null); + } + } else { + queue2 = null; + } + queue2 = queue2 !== queue1 ? queue2 : null; + + // Use module variables instead of returning a tuple + q1 = queue1; + q2 = queue2; +} + +function insertUpdateIntoFiber(fiber, update) { + ensureUpdateQueues(fiber); + var queue1 = q1; + var queue2 = q2; + + // Warn if an update is scheduled from inside an updater function. + { + if ((queue1.isProcessing || queue2 !== null && queue2.isProcessing) && !didWarnUpdateInsideUpdate) { + warning_1(false, 'An update (setState, replaceState, or forceUpdate) was scheduled ' + 'from inside an update function. Update functions should be pure, ' + 'with zero side-effects. Consider using componentDidUpdate or a ' + 'callback.'); + didWarnUpdateInsideUpdate = true; + } + } + + // If there's only one queue, add the update to that queue and exit. + if (queue2 === null) { + insertUpdateIntoQueue(queue1, update); + return; + } + + // If either queue is empty, we need to add to both queues. + if (queue1.last === null || queue2.last === null) { + insertUpdateIntoQueue(queue1, update); + insertUpdateIntoQueue(queue2, update); + return; + } + + // If both lists are not empty, the last update is the same for both lists + // because of structural sharing. So, we should only append to one of + // the lists. + insertUpdateIntoQueue(queue1, update); + // But we still need to update the `last` pointer of queue2. + queue2.last = update; +} + +function getUpdateExpirationTime(fiber) { + switch (fiber.tag) { + case HostRoot: + case ClassComponent: + var updateQueue = fiber.updateQueue; + if (updateQueue === null) { + return NoWork; + } + return updateQueue.expirationTime; + default: + return NoWork; + } +} + +function getStateFromUpdate(update, instance, prevState, props) { + var partialState = update.partialState; + if (typeof partialState === 'function') { + return partialState.call(instance, prevState, props); + } else { + return partialState; + } +} + +function processUpdateQueue(current, workInProgress, queue, instance, props, renderExpirationTime) { + if (current !== null && current.updateQueue === queue) { + // We need to create a work-in-progress queue, by cloning the current queue. + var currentQueue = queue; + queue = workInProgress.updateQueue = { + baseState: currentQueue.baseState, + expirationTime: currentQueue.expirationTime, + first: currentQueue.first, + last: currentQueue.last, + isInitialized: currentQueue.isInitialized, + capturedValues: currentQueue.capturedValues, + // These fields are no longer valid because they were already committed. + // Reset them. + callbackList: null, + hasForceUpdate: false + }; + } + + { + // Set this flag so we can warn if setState is called inside the update + // function of another setState. + queue.isProcessing = true; + } + + // Reset the remaining expiration time. If we skip over any updates, we'll + // increase this accordingly. + queue.expirationTime = NoWork; + + // TODO: We don't know what the base state will be until we begin work. + // It depends on which fiber is the next current. Initialize with an empty + // base state, then set to the memoizedState when rendering. Not super + // happy with this approach. + var state = void 0; + if (queue.isInitialized) { + state = queue.baseState; + } else { + state = queue.baseState = workInProgress.memoizedState; + queue.isInitialized = true; + } + var dontMutatePrevState = true; + var update = queue.first; + var didSkip = false; + while (update !== null) { + var updateExpirationTime = update.expirationTime; + if (updateExpirationTime > renderExpirationTime) { + // This update does not have sufficient priority. Skip it. + var remainingExpirationTime = queue.expirationTime; + if (remainingExpirationTime === NoWork || remainingExpirationTime > updateExpirationTime) { + // Update the remaining expiration time. + queue.expirationTime = updateExpirationTime; + } + if (!didSkip) { + didSkip = true; + queue.baseState = state; + } + // Continue to the next update. + update = update.next; + continue; + } + + // This update does have sufficient priority. + + // If no previous updates were skipped, drop this update from the queue by + // advancing the head of the list. + if (!didSkip) { + queue.first = update.next; + if (queue.first === null) { + queue.last = null; + } + } + + // Invoke setState callback an extra time to help detect side-effects. + // Ignore the return value in this case. + if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) { + getStateFromUpdate(update, instance, state, props); + } + + // Process the update + var _partialState = void 0; + if (update.isReplace) { + state = getStateFromUpdate(update, instance, state, props); + dontMutatePrevState = true; + } else { + _partialState = getStateFromUpdate(update, instance, state, props); + if (_partialState) { + if (dontMutatePrevState) { + // $FlowFixMe: Idk how to type this properly. + state = _assign({}, state, _partialState); + } else { + state = _assign(state, _partialState); + } + dontMutatePrevState = false; + } + } + if (update.isForced) { + queue.hasForceUpdate = true; + } + if (update.callback !== null) { + // Append to list of callbacks. + var _callbackList = queue.callbackList; + if (_callbackList === null) { + _callbackList = queue.callbackList = []; + } + _callbackList.push(update); + } + if (update.capturedValue !== null) { + var _capturedValues = queue.capturedValues; + if (_capturedValues === null) { + queue.capturedValues = [update.capturedValue]; + } else { + _capturedValues.push(update.capturedValue); + } + } + update = update.next; + } + + if (queue.callbackList !== null) { + workInProgress.effectTag |= Callback; + } else if (queue.first === null && !queue.hasForceUpdate && queue.capturedValues === null) { + // The queue is empty. We can reset it. + workInProgress.updateQueue = null; + } + + if (!didSkip) { + didSkip = true; + queue.baseState = state; + } + + { + // No longer processing. + queue.isProcessing = false; + } + + return state; +} + +function commitCallbacks(queue, context) { + var callbackList = queue.callbackList; + if (callbackList === null) { + return; + } + // Set the list to null to make sure they don't get called more than once. + queue.callbackList = null; + for (var i = 0; i < callbackList.length; i++) { + var update = callbackList[i]; + var _callback = update.callback; + // This update might be processed again. Clear the callback so it's only + // called once. + update.callback = null; + !(typeof _callback === 'function') ? invariant_1(false, 'Invalid argument passed as callback. Expected a function. Instead received: %s', _callback) : void 0; + _callback.call(context); + } +} + +var fakeInternalInstance = {}; +var isArray = Array.isArray; + +var didWarnAboutStateAssignmentForComponent = void 0; +var didWarnAboutUndefinedDerivedState = void 0; +var didWarnAboutUninitializedState = void 0; +var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0; +var didWarnAboutLegacyLifecyclesAndDerivedState = void 0; +var warnOnInvalidCallback$1 = void 0; + +{ + didWarnAboutStateAssignmentForComponent = new Set(); + didWarnAboutUndefinedDerivedState = new Set(); + didWarnAboutUninitializedState = new Set(); + didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set(); + didWarnAboutLegacyLifecyclesAndDerivedState = new Set(); + + var didWarnOnInvalidCallback = new Set(); + + warnOnInvalidCallback$1 = function (callback, callerName) { + if (callback === null || typeof callback === 'function') { + return; + } + var key = callerName + '_' + callback; + if (!didWarnOnInvalidCallback.has(key)) { + didWarnOnInvalidCallback.add(key); + warning_1(false, '%s(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callerName, callback); + } + }; + + // This is so gross but it's at least non-critical and can be removed if + // it causes problems. This is meant to give a nicer error message for + // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component, + // ...)) which otherwise throws a "_processChildContext is not a function" + // exception. + Object.defineProperty(fakeInternalInstance, '_processChildContext', { + enumerable: false, + value: function () { + invariant_1(false, '_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn\'t supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal).'); + } + }); + Object.freeze(fakeInternalInstance); +} +function callGetDerivedStateFromCatch(ctor, capturedValues) { + var resultState = {}; + for (var i = 0; i < capturedValues.length; i++) { + var capturedValue = capturedValues[i]; + var error = capturedValue.value; + var partialState = ctor.getDerivedStateFromCatch.call(null, error); + if (partialState !== null && partialState !== undefined) { + _assign(resultState, partialState); + } + } + return resultState; +} + +var ReactFiberClassComponent = function (legacyContext, scheduleWork, computeExpirationForFiber, memoizeProps, memoizeState) { + var cacheContext = legacyContext.cacheContext, + getMaskedContext = legacyContext.getMaskedContext, + getUnmaskedContext = legacyContext.getUnmaskedContext, + isContextConsumer = legacyContext.isContextConsumer, + hasContextChanged = legacyContext.hasContextChanged; + + // Class component state updater + + var updater = { + isMounted: isMounted, + enqueueSetState: function (instance, partialState, callback) { + var fiber = get(instance); + callback = callback === undefined ? null : callback; + { + warnOnInvalidCallback$1(callback, 'setState'); + } + var expirationTime = computeExpirationForFiber(fiber); + var update = { + expirationTime: expirationTime, + partialState: partialState, + callback: callback, + isReplace: false, + isForced: false, + capturedValue: null, + next: null + }; + insertUpdateIntoFiber(fiber, update); + scheduleWork(fiber, expirationTime); + }, + enqueueReplaceState: function (instance, state, callback) { + var fiber = get(instance); + callback = callback === undefined ? null : callback; + { + warnOnInvalidCallback$1(callback, 'replaceState'); + } + var expirationTime = computeExpirationForFiber(fiber); + var update = { + expirationTime: expirationTime, + partialState: state, + callback: callback, + isReplace: true, + isForced: false, + capturedValue: null, + next: null + }; + insertUpdateIntoFiber(fiber, update); + scheduleWork(fiber, expirationTime); + }, + enqueueForceUpdate: function (instance, callback) { + var fiber = get(instance); + callback = callback === undefined ? null : callback; + { + warnOnInvalidCallback$1(callback, 'forceUpdate'); + } + var expirationTime = computeExpirationForFiber(fiber); + var update = { + expirationTime: expirationTime, + partialState: null, + callback: callback, + isReplace: false, + isForced: true, + capturedValue: null, + next: null + }; + insertUpdateIntoFiber(fiber, update); + scheduleWork(fiber, expirationTime); + } + }; + + function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) { + if (oldProps === null || workInProgress.updateQueue !== null && workInProgress.updateQueue.hasForceUpdate) { + // If the workInProgress already has an Update effect, return true + return true; + } + + var instance = workInProgress.stateNode; + var ctor = workInProgress.type; + if (typeof instance.shouldComponentUpdate === 'function') { + startPhaseTimer(workInProgress, 'shouldComponentUpdate'); + var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, newContext); + stopPhaseTimer(); + + { + warning_1(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', getComponentName(workInProgress) || 'Component'); + } + + return shouldUpdate; + } + + if (ctor.prototype && ctor.prototype.isPureReactComponent) { + return !shallowEqual_1(oldProps, newProps) || !shallowEqual_1(oldState, newState); + } + + return true; + } + + function checkClassInstance(workInProgress) { + var instance = workInProgress.stateNode; + var type = workInProgress.type; + { + var name = getComponentName(workInProgress) || 'Component'; + var renderPresent = instance.render; + + if (!renderPresent) { + if (type.prototype && typeof type.prototype.render === 'function') { + warning_1(false, '%s(...): No `render` method found on the returned component ' + 'instance: did you accidentally return an object from the constructor?', name); + } else { + warning_1(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', name); + } + } + + var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state; + warning_1(noGetInitialStateOnES6, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', name); + var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved; + warning_1(noGetDefaultPropsOnES6, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', name); + var noInstancePropTypes = !instance.propTypes; + warning_1(noInstancePropTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', name); + var noInstanceContextTypes = !instance.contextTypes; + warning_1(noInstanceContextTypes, 'contextTypes was defined as an instance property on %s. Use a static ' + 'property to define contextTypes instead.', name); + var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== 'function'; + warning_1(noComponentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', name); + if (type.prototype && type.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== 'undefined') { + warning_1(false, '%s has a method called shouldComponentUpdate(). ' + 'shouldComponentUpdate should not be used when extending React.PureComponent. ' + 'Please extend React.Component if shouldComponentUpdate is used.', getComponentName(workInProgress) || 'A pure component'); + } + var noComponentDidUnmount = typeof instance.componentDidUnmount !== 'function'; + warning_1(noComponentDidUnmount, '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', name); + var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== 'function'; + warning_1(noComponentDidReceiveProps, '%s has a method called ' + 'componentDidReceiveProps(). But there is no such lifecycle method. ' + 'If you meant to update the state in response to changing props, ' + 'use componentWillReceiveProps(). If you meant to fetch data or ' + 'run side-effects or mutations after React has updated the UI, use componentDidUpdate().', name); + var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== 'function'; + warning_1(noComponentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', name); + var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== 'function'; + warning_1(noUnsafeComponentWillRecieveProps, '%s has a method called ' + 'UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?', name); + var hasMutatedProps = instance.props !== workInProgress.pendingProps; + warning_1(instance.props === undefined || !hasMutatedProps, '%s(...): When calling super() in `%s`, make sure to pass ' + "up the same props that your component's constructor was passed.", name, name); + var noInstanceDefaultProps = !instance.defaultProps; + warning_1(noInstanceDefaultProps, 'Setting defaultProps as an instance property on %s is not supported and will be ignored.' + ' Instead, define defaultProps as a static property on %s.', name, name); + + if (typeof instance.getSnapshotBeforeUpdate === 'function' && typeof instance.componentDidUpdate !== 'function' && typeof instance.componentDidUpdate !== 'function' && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(type)) { + didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(type); + warning_1(false, '%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). ' + 'This component defines getSnapshotBeforeUpdate() only.', getComponentName(workInProgress)); + } + + var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== 'function'; + warning_1(noInstanceGetDerivedStateFromProps, '%s: getDerivedStateFromProps() is defined as an instance method ' + 'and will be ignored. Instead, declare it as a static method.', name); + var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromCatch !== 'function'; + warning_1(noInstanceGetDerivedStateFromCatch, '%s: getDerivedStateFromCatch() is defined as an instance method ' + 'and will be ignored. Instead, declare it as a static method.', name); + var noStaticGetSnapshotBeforeUpdate = typeof type.getSnapshotBeforeUpdate !== 'function'; + warning_1(noStaticGetSnapshotBeforeUpdate, '%s: getSnapshotBeforeUpdate() is defined as a static method ' + 'and will be ignored. Instead, declare it as an instance method.', name); + var _state = instance.state; + if (_state && (typeof _state !== 'object' || isArray(_state))) { + warning_1(false, '%s.state: must be set to an object or null', name); + } + if (typeof instance.getChildContext === 'function') { + warning_1(typeof type.childContextTypes === 'object', '%s.getChildContext(): childContextTypes must be defined in order to ' + 'use getChildContext().', name); + } + } + } + + function resetInputPointers(workInProgress, instance) { + instance.props = workInProgress.memoizedProps; + instance.state = workInProgress.memoizedState; + } + + function adoptClassInstance(workInProgress, instance) { + instance.updater = updater; + workInProgress.stateNode = instance; + // The instance needs access to the fiber so that it can schedule updates + set(instance, workInProgress); + { + instance._reactInternalInstance = fakeInternalInstance; + } + } + + function constructClassInstance(workInProgress, props) { + var ctor = workInProgress.type; + var unmaskedContext = getUnmaskedContext(workInProgress); + var needsContext = isContextConsumer(workInProgress); + var context = needsContext ? getMaskedContext(workInProgress, unmaskedContext) : emptyObject_1; + + // Instantiate twice to help detect side-effects. + if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) { + new ctor(props, context); // eslint-disable-line no-new + } + + var instance = new ctor(props, context); + var state = instance.state !== null && instance.state !== undefined ? instance.state : null; + adoptClassInstance(workInProgress, instance); + + { + if (typeof ctor.getDerivedStateFromProps === 'function' && state === null) { + var componentName = getComponentName(workInProgress) || 'Component'; + if (!didWarnAboutUninitializedState.has(componentName)) { + didWarnAboutUninitializedState.add(componentName); + warning_1(false, '%s: Did not properly initialize state during construction. ' + 'Expected state to be an object, but it was %s.', componentName, instance.state === null ? 'null' : 'undefined'); + } + } + + // If new component APIs are defined, "unsafe" lifecycles won't be called. + // Warn about these lifecycles if they are present. + // Don't warn about react-lifecycles-compat polyfilled methods though. + if (typeof ctor.getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function') { + var foundWillMountName = null; + var foundWillReceivePropsName = null; + var foundWillUpdateName = null; + if (typeof instance.componentWillMount === 'function' && instance.componentWillMount.__suppressDeprecationWarning !== true) { + foundWillMountName = 'componentWillMount'; + } else if (typeof instance.UNSAFE_componentWillMount === 'function') { + foundWillMountName = 'UNSAFE_componentWillMount'; + } + if (typeof instance.componentWillReceiveProps === 'function' && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) { + foundWillReceivePropsName = 'componentWillReceiveProps'; + } else if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') { + foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps'; + } + if (typeof instance.componentWillUpdate === 'function' && instance.componentWillUpdate.__suppressDeprecationWarning !== true) { + foundWillUpdateName = 'componentWillUpdate'; + } else if (typeof instance.UNSAFE_componentWillUpdate === 'function') { + foundWillUpdateName = 'UNSAFE_componentWillUpdate'; + } + if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) { + var _componentName = getComponentName(workInProgress) || 'Component'; + var newApiName = typeof ctor.getDerivedStateFromProps === 'function' ? 'getDerivedStateFromProps()' : 'getSnapshotBeforeUpdate()'; + if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) { + didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName); + warning_1(false, 'Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' + '%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n' + 'The above lifecycles should be removed. Learn more about this warning here:\n' + 'https://fb.me/react-async-component-lifecycle-hooks', _componentName, newApiName, foundWillMountName !== null ? '\n ' + foundWillMountName : '', foundWillReceivePropsName !== null ? '\n ' + foundWillReceivePropsName : '', foundWillUpdateName !== null ? '\n ' + foundWillUpdateName : ''); + } + } + } + } + + workInProgress.memoizedState = state; + + var partialState = callGetDerivedStateFromProps(workInProgress, instance, props, state); + + if (partialState !== null && partialState !== undefined) { + // Render-phase updates (like this) should not be added to the update queue, + // So that multiple render passes do not enqueue multiple updates. + // Instead, just synchronously merge the returned state into the instance. + workInProgress.memoizedState = _assign({}, workInProgress.memoizedState, partialState); + } + + // Cache unmasked context so we can avoid recreating masked context unless necessary. + // ReactFiberContext usually updates this cache but can't for newly-created instances. + if (needsContext) { + cacheContext(workInProgress, unmaskedContext, context); + } + + return instance; + } + + function callComponentWillMount(workInProgress, instance) { + startPhaseTimer(workInProgress, 'componentWillMount'); + var oldState = instance.state; + + if (typeof instance.componentWillMount === 'function') { + instance.componentWillMount(); + } + if (typeof instance.UNSAFE_componentWillMount === 'function') { + instance.UNSAFE_componentWillMount(); + } + + stopPhaseTimer(); + + if (oldState !== instance.state) { + { + warning_1(false, '%s.componentWillMount(): Assigning directly to this.state is ' + "deprecated (except inside a component's " + 'constructor). Use setState instead.', getComponentName(workInProgress) || 'Component'); + } + updater.enqueueReplaceState(instance, instance.state, null); + } + } + + function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) { + var oldState = instance.state; + startPhaseTimer(workInProgress, 'componentWillReceiveProps'); + if (typeof instance.componentWillReceiveProps === 'function') { + instance.componentWillReceiveProps(newProps, newContext); + } + if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') { + instance.UNSAFE_componentWillReceiveProps(newProps, newContext); + } + stopPhaseTimer(); + + if (instance.state !== oldState) { + { + var componentName = getComponentName(workInProgress) || 'Component'; + if (!didWarnAboutStateAssignmentForComponent.has(componentName)) { + didWarnAboutStateAssignmentForComponent.add(componentName); + warning_1(false, '%s.componentWillReceiveProps(): Assigning directly to ' + "this.state is deprecated (except inside a component's " + 'constructor). Use setState instead.', componentName); + } + } + updater.enqueueReplaceState(instance, instance.state, null); + } + } + + function callGetDerivedStateFromProps(workInProgress, instance, nextProps, prevState) { + var type = workInProgress.type; + + + if (typeof type.getDerivedStateFromProps === 'function') { + if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) { + // Invoke method an extra time to help detect side-effects. + type.getDerivedStateFromProps.call(null, nextProps, prevState); + } + + var partialState = type.getDerivedStateFromProps.call(null, nextProps, prevState); + + { + if (partialState === undefined) { + var componentName = getComponentName(workInProgress) || 'Component'; + if (!didWarnAboutUndefinedDerivedState.has(componentName)) { + didWarnAboutUndefinedDerivedState.add(componentName); + warning_1(false, '%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. ' + 'You have returned undefined.', componentName); + } + } + } + + return partialState; + } + } + + // Invokes the mount life-cycles on a previously never rendered instance. + function mountClassInstance(workInProgress, renderExpirationTime) { + var ctor = workInProgress.type; + var current = workInProgress.alternate; + + { + checkClassInstance(workInProgress); + } + + var instance = workInProgress.stateNode; + var props = workInProgress.pendingProps; + var unmaskedContext = getUnmaskedContext(workInProgress); + + instance.props = props; + instance.state = workInProgress.memoizedState; + instance.refs = emptyObject_1; + instance.context = getMaskedContext(workInProgress, unmaskedContext); + + { + if (workInProgress.mode & StrictMode) { + ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance); + } + + if (warnAboutDeprecatedLifecycles) { + ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance); + } + } + + // In order to support react-lifecycles-compat polyfilled components, + // Unsafe lifecycles should not be invoked for components using the new APIs. + if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) { + callComponentWillMount(workInProgress, instance); + // If we had additional state updates during this life-cycle, let's + // process them now. + var updateQueue = workInProgress.updateQueue; + if (updateQueue !== null) { + instance.state = processUpdateQueue(current, workInProgress, updateQueue, instance, props, renderExpirationTime); + } + } + if (typeof instance.componentDidMount === 'function') { + workInProgress.effectTag |= Update; + } + } + + function resumeMountClassInstance(workInProgress, renderExpirationTime) { + var ctor = workInProgress.type; + var instance = workInProgress.stateNode; + resetInputPointers(workInProgress, instance); + + var oldProps = workInProgress.memoizedProps; + var newProps = workInProgress.pendingProps; + var oldContext = instance.context; + var newUnmaskedContext = getUnmaskedContext(workInProgress); + var newContext = getMaskedContext(workInProgress, newUnmaskedContext); + + var hasNewLifecycles = typeof ctor.getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; + + // Note: During these life-cycles, instance.props/instance.state are what + // ever the previously attempted to render - not the "current". However, + // during componentDidUpdate we pass the "current" props. + + // In order to support react-lifecycles-compat polyfilled components, + // Unsafe lifecycles should not be invoked for components using the new APIs. + if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) { + if (oldProps !== newProps || oldContext !== newContext) { + callComponentWillReceiveProps(workInProgress, instance, newProps, newContext); + } + } + + // Compute the next state using the memoized state and the update queue. + var oldState = workInProgress.memoizedState; + // TODO: Previous state can be null. + var newState = void 0; + var derivedStateFromCatch = void 0; + if (workInProgress.updateQueue !== null) { + newState = processUpdateQueue(null, workInProgress, workInProgress.updateQueue, instance, newProps, renderExpirationTime); + + var updateQueue = workInProgress.updateQueue; + if (updateQueue !== null && updateQueue.capturedValues !== null && enableGetDerivedStateFromCatch && typeof ctor.getDerivedStateFromCatch === 'function') { + var capturedValues = updateQueue.capturedValues; + // Don't remove these from the update queue yet. We need them in + // finishClassComponent. Do the reset there. + // TODO: This is awkward. Refactor class components. + // updateQueue.capturedValues = null; + derivedStateFromCatch = callGetDerivedStateFromCatch(ctor, capturedValues); + } + } else { + newState = oldState; + } + + var derivedStateFromProps = void 0; + if (oldProps !== newProps) { + // The prevState parameter should be the partially updated state. + // Otherwise, spreading state in return values could override updates. + derivedStateFromProps = callGetDerivedStateFromProps(workInProgress, instance, newProps, newState); + } + + if (derivedStateFromProps !== null && derivedStateFromProps !== undefined) { + // Render-phase updates (like this) should not be added to the update queue, + // So that multiple render passes do not enqueue multiple updates. + // Instead, just synchronously merge the returned state into the instance. + newState = newState === null || newState === undefined ? derivedStateFromProps : _assign({}, newState, derivedStateFromProps); + } + if (derivedStateFromCatch !== null && derivedStateFromCatch !== undefined) { + // Render-phase updates (like this) should not be added to the update queue, + // So that multiple render passes do not enqueue multiple updates. + // Instead, just synchronously merge the returned state into the instance. + newState = newState === null || newState === undefined ? derivedStateFromCatch : _assign({}, newState, derivedStateFromCatch); + } + + if (oldProps === newProps && oldState === newState && !hasContextChanged() && !(workInProgress.updateQueue !== null && workInProgress.updateQueue.hasForceUpdate)) { + // If an update was already in progress, we should schedule an Update + // effect even though we're bailing out, so that cWU/cDU are called. + if (typeof instance.componentDidMount === 'function') { + workInProgress.effectTag |= Update; + } + return false; + } + + var shouldUpdate = checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext); + + if (shouldUpdate) { + // In order to support react-lifecycles-compat polyfilled components, + // Unsafe lifecycles should not be invoked for components using the new APIs. + if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) { + startPhaseTimer(workInProgress, 'componentWillMount'); + if (typeof instance.componentWillMount === 'function') { + instance.componentWillMount(); + } + if (typeof instance.UNSAFE_componentWillMount === 'function') { + instance.UNSAFE_componentWillMount(); + } + stopPhaseTimer(); + } + if (typeof instance.componentDidMount === 'function') { + workInProgress.effectTag |= Update; + } + } else { + // If an update was already in progress, we should schedule an Update + // effect even though we're bailing out, so that cWU/cDU are called. + if (typeof instance.componentDidMount === 'function') { + workInProgress.effectTag |= Update; + } + + // If shouldComponentUpdate returned false, we should still update the + // memoized props/state to indicate that this work can be reused. + memoizeProps(workInProgress, newProps); + memoizeState(workInProgress, newState); + } + + // Update the existing instance's state, props, and context pointers even + // if shouldComponentUpdate returns false. + instance.props = newProps; + instance.state = newState; + instance.context = newContext; + + return shouldUpdate; + } + + // Invokes the update life-cycles and returns false if it shouldn't rerender. + function updateClassInstance(current, workInProgress, renderExpirationTime) { + var ctor = workInProgress.type; + var instance = workInProgress.stateNode; + resetInputPointers(workInProgress, instance); + + var oldProps = workInProgress.memoizedProps; + var newProps = workInProgress.pendingProps; + var oldContext = instance.context; + var newUnmaskedContext = getUnmaskedContext(workInProgress); + var newContext = getMaskedContext(workInProgress, newUnmaskedContext); + + var hasNewLifecycles = typeof ctor.getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; + + // Note: During these life-cycles, instance.props/instance.state are what + // ever the previously attempted to render - not the "current". However, + // during componentDidUpdate we pass the "current" props. + + // In order to support react-lifecycles-compat polyfilled components, + // Unsafe lifecycles should not be invoked for components using the new APIs. + if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) { + if (oldProps !== newProps || oldContext !== newContext) { + callComponentWillReceiveProps(workInProgress, instance, newProps, newContext); + } + } + + // Compute the next state using the memoized state and the update queue. + var oldState = workInProgress.memoizedState; + // TODO: Previous state can be null. + var newState = void 0; + var derivedStateFromCatch = void 0; + + if (workInProgress.updateQueue !== null) { + newState = processUpdateQueue(current, workInProgress, workInProgress.updateQueue, instance, newProps, renderExpirationTime); + + var updateQueue = workInProgress.updateQueue; + if (updateQueue !== null && updateQueue.capturedValues !== null && enableGetDerivedStateFromCatch && typeof ctor.getDerivedStateFromCatch === 'function') { + var capturedValues = updateQueue.capturedValues; + // Don't remove these from the update queue yet. We need them in + // finishClassComponent. Do the reset there. + // TODO: This is awkward. Refactor class components. + // updateQueue.capturedValues = null; + derivedStateFromCatch = callGetDerivedStateFromCatch(ctor, capturedValues); + } + } else { + newState = oldState; + } + + var derivedStateFromProps = void 0; + if (oldProps !== newProps) { + // The prevState parameter should be the partially updated state. + // Otherwise, spreading state in return values could override updates. + derivedStateFromProps = callGetDerivedStateFromProps(workInProgress, instance, newProps, newState); + } + + if (derivedStateFromProps !== null && derivedStateFromProps !== undefined) { + // Render-phase updates (like this) should not be added to the update queue, + // So that multiple render passes do not enqueue multiple updates. + // Instead, just synchronously merge the returned state into the instance. + newState = newState === null || newState === undefined ? derivedStateFromProps : _assign({}, newState, derivedStateFromProps); + } + if (derivedStateFromCatch !== null && derivedStateFromCatch !== undefined) { + // Render-phase updates (like this) should not be added to the update queue, + // So that multiple render passes do not enqueue multiple updates. + // Instead, just synchronously merge the returned state into the instance. + newState = newState === null || newState === undefined ? derivedStateFromCatch : _assign({}, newState, derivedStateFromCatch); + } + + if (oldProps === newProps && oldState === newState && !hasContextChanged() && !(workInProgress.updateQueue !== null && workInProgress.updateQueue.hasForceUpdate)) { + // If an update was already in progress, we should schedule an Update + // effect even though we're bailing out, so that cWU/cDU are called. + if (typeof instance.componentDidUpdate === 'function') { + if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) { + workInProgress.effectTag |= Update; + } + } + if (typeof instance.getSnapshotBeforeUpdate === 'function') { + if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) { + workInProgress.effectTag |= Snapshot; + } + } + return false; + } + + var shouldUpdate = checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext); + + if (shouldUpdate) { + // In order to support react-lifecycles-compat polyfilled components, + // Unsafe lifecycles should not be invoked for components using the new APIs. + if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) { + startPhaseTimer(workInProgress, 'componentWillUpdate'); + if (typeof instance.componentWillUpdate === 'function') { + instance.componentWillUpdate(newProps, newState, newContext); + } + if (typeof instance.UNSAFE_componentWillUpdate === 'function') { + instance.UNSAFE_componentWillUpdate(newProps, newState, newContext); + } + stopPhaseTimer(); + } + if (typeof instance.componentDidUpdate === 'function') { + workInProgress.effectTag |= Update; + } + if (typeof instance.getSnapshotBeforeUpdate === 'function') { + workInProgress.effectTag |= Snapshot; + } + } else { + // If an update was already in progress, we should schedule an Update + // effect even though we're bailing out, so that cWU/cDU are called. + if (typeof instance.componentDidUpdate === 'function') { + if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) { + workInProgress.effectTag |= Update; + } + } + if (typeof instance.getSnapshotBeforeUpdate === 'function') { + if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) { + workInProgress.effectTag |= Snapshot; + } + } + + // If shouldComponentUpdate returned false, we should still update the + // memoized props/state to indicate that this work can be reused. + memoizeProps(workInProgress, newProps); + memoizeState(workInProgress, newState); + } + + // Update the existing instance's state, props, and context pointers even + // if shouldComponentUpdate returns false. + instance.props = newProps; + instance.state = newState; + instance.context = newContext; + + return shouldUpdate; + } + + return { + adoptClassInstance: adoptClassInstance, + callGetDerivedStateFromProps: callGetDerivedStateFromProps, + constructClassInstance: constructClassInstance, + mountClassInstance: mountClassInstance, + resumeMountClassInstance: resumeMountClassInstance, + updateClassInstance: updateClassInstance + }; +}; + +var getCurrentFiberStackAddendum$2 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum; + + +var didWarnAboutMaps = void 0; +var didWarnAboutStringRefInStrictMode = void 0; +var ownerHasKeyUseWarning = void 0; +var ownerHasFunctionTypeWarning = void 0; +var warnForMissingKey = function (child) {}; + +{ + didWarnAboutMaps = false; + didWarnAboutStringRefInStrictMode = {}; + + /** + * Warn if there's no key explicitly set on dynamic arrays of children or + * object keys are not valid. This allows us to keep track of children between + * updates. + */ + ownerHasKeyUseWarning = {}; + ownerHasFunctionTypeWarning = {}; + + warnForMissingKey = function (child) { + if (child === null || typeof child !== 'object') { + return; + } + if (!child._store || child._store.validated || child.key != null) { + return; + } + !(typeof child._store === 'object') ? invariant_1(false, 'React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.') : void 0; + child._store.validated = true; + + var currentComponentErrorInfo = 'Each child in an array or iterator should have a unique ' + '"key" prop. See https://fb.me/react-warning-keys for ' + 'more information.' + (getCurrentFiberStackAddendum$2() || ''); + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; + + warning_1(false, 'Each child in an array or iterator should have a unique ' + '"key" prop. See https://fb.me/react-warning-keys for ' + 'more information.%s', getCurrentFiberStackAddendum$2()); + }; +} + +var isArray$1 = Array.isArray; + +function coerceRef(returnFiber, current, element) { + var mixedRef = element.ref; + if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') { + { + if (returnFiber.mode & StrictMode) { + var componentName = getComponentName(returnFiber) || 'Component'; + if (!didWarnAboutStringRefInStrictMode[componentName]) { + warning_1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + 'String refs are a source of potential bugs and should be avoided. ' + 'We recommend using createRef() instead.' + '\n%s' + '\n\nLearn more about using refs safely here:' + '\nhttps://fb.me/react-strict-mode-string-ref', mixedRef, getStackAddendumByWorkInProgressFiber(returnFiber)); + didWarnAboutStringRefInStrictMode[componentName] = true; + } + } + } + + if (element._owner) { + var owner = element._owner; + var inst = void 0; + if (owner) { + var ownerFiber = owner; + !(ownerFiber.tag === ClassComponent) ? invariant_1(false, 'Stateless function components cannot have refs.') : void 0; + inst = ownerFiber.stateNode; + } + !inst ? invariant_1(false, 'Missing owner for string ref %s. This error is likely caused by a bug in React. Please file an issue.', mixedRef) : void 0; + var stringRef = '' + mixedRef; + // Check if previous string ref matches new string ref + if (current !== null && current.ref !== null && current.ref._stringRef === stringRef) { + return current.ref; + } + var ref = function (value) { + var refs = inst.refs === emptyObject_1 ? inst.refs = {} : inst.refs; + if (value === null) { + delete refs[stringRef]; + } else { + refs[stringRef] = value; + } + }; + ref._stringRef = stringRef; + return ref; + } else { + !(typeof mixedRef === 'string') ? invariant_1(false, 'Expected ref to be a function or a string.') : void 0; + !element._owner ? invariant_1(false, 'Element ref was specified as a string (%s) but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a functional component\n2. You may be adding a ref to a component that was not created inside a component\'s render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information.', mixedRef) : void 0; + } + } + return mixedRef; +} + +function throwOnInvalidObjectType(returnFiber, newChild) { + if (returnFiber.type !== 'textarea') { + var addendum = ''; + { + addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + (getCurrentFiberStackAddendum$2() || ''); + } + invariant_1(false, 'Objects are not valid as a React child (found: %s).%s', Object.prototype.toString.call(newChild) === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : newChild, addendum); + } +} + +function warnOnFunctionType() { + var currentComponentErrorInfo = 'Functions are not valid as a React child. This may happen if ' + 'you return a Component instead of from render. ' + 'Or maybe you meant to call this function rather than return it.' + (getCurrentFiberStackAddendum$2() || ''); + + if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) { + return; + } + ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true; + + warning_1(false, 'Functions are not valid as a React child. This may happen if ' + 'you return a Component instead of from render. ' + 'Or maybe you meant to call this function rather than return it.%s', getCurrentFiberStackAddendum$2() || ''); +} + +// This wrapper function exists because I expect to clone the code in each path +// to be able to optimize each path individually by branching early. This needs +// a compiler or we can do it manually. Helpers that don't need this branching +// live outside of this function. +function ChildReconciler(shouldTrackSideEffects) { + function deleteChild(returnFiber, childToDelete) { + if (!shouldTrackSideEffects) { + // Noop. + return; + } + // Deletions are added in reversed order so we add it to the front. + // At this point, the return fiber's effect list is empty except for + // deletions, so we can just append the deletion to the list. The remaining + // effects aren't added until the complete phase. Once we implement + // resuming, this may not be true. + var last = returnFiber.lastEffect; + if (last !== null) { + last.nextEffect = childToDelete; + returnFiber.lastEffect = childToDelete; + } else { + returnFiber.firstEffect = returnFiber.lastEffect = childToDelete; + } + childToDelete.nextEffect = null; + childToDelete.effectTag = Deletion; + } + + function deleteRemainingChildren(returnFiber, currentFirstChild) { + if (!shouldTrackSideEffects) { + // Noop. + return null; + } + + // TODO: For the shouldClone case, this could be micro-optimized a bit by + // assuming that after the first child we've already added everything. + var childToDelete = currentFirstChild; + while (childToDelete !== null) { + deleteChild(returnFiber, childToDelete); + childToDelete = childToDelete.sibling; + } + return null; + } + + function mapRemainingChildren(returnFiber, currentFirstChild) { + // Add the remaining children to a temporary map so that we can find them by + // keys quickly. Implicit (null) keys get added to this set with their index + var existingChildren = new Map(); + + var existingChild = currentFirstChild; + while (existingChild !== null) { + if (existingChild.key !== null) { + existingChildren.set(existingChild.key, existingChild); + } else { + existingChildren.set(existingChild.index, existingChild); + } + existingChild = existingChild.sibling; + } + return existingChildren; + } + + function useFiber(fiber, pendingProps, expirationTime) { + // We currently set sibling to null and index to 0 here because it is easy + // to forget to do before returning it. E.g. for the single child case. + var clone = createWorkInProgress(fiber, pendingProps, expirationTime); + clone.index = 0; + clone.sibling = null; + return clone; + } + + function placeChild(newFiber, lastPlacedIndex, newIndex) { + newFiber.index = newIndex; + if (!shouldTrackSideEffects) { + // Noop. + return lastPlacedIndex; + } + var current = newFiber.alternate; + if (current !== null) { + var oldIndex = current.index; + if (oldIndex < lastPlacedIndex) { + // This is a move. + newFiber.effectTag = Placement; + return lastPlacedIndex; + } else { + // This item can stay in place. + return oldIndex; + } + } else { + // This is an insertion. + newFiber.effectTag = Placement; + return lastPlacedIndex; + } + } + + function placeSingleChild(newFiber) { + // This is simpler for the single child case. We only need to do a + // placement for inserting new children. + if (shouldTrackSideEffects && newFiber.alternate === null) { + newFiber.effectTag = Placement; + } + return newFiber; + } + + function updateTextNode(returnFiber, current, textContent, expirationTime) { + if (current === null || current.tag !== HostText) { + // Insert + var created = createFiberFromText(textContent, returnFiber.mode, expirationTime); + created['return'] = returnFiber; + return created; + } else { + // Update + var existing = useFiber(current, textContent, expirationTime); + existing['return'] = returnFiber; + return existing; + } + } + + function updateElement(returnFiber, current, element, expirationTime) { + if (current !== null && current.type === element.type) { + // Move based on index + var existing = useFiber(current, element.props, expirationTime); + existing.ref = coerceRef(returnFiber, current, element); + existing['return'] = returnFiber; + { + existing._debugSource = element._source; + existing._debugOwner = element._owner; + } + return existing; + } else { + // Insert + var created = createFiberFromElement(element, returnFiber.mode, expirationTime); + created.ref = coerceRef(returnFiber, current, element); + created['return'] = returnFiber; + return created; + } + } + + function updatePortal(returnFiber, current, portal, expirationTime) { + if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) { + // Insert + var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime); + created['return'] = returnFiber; + return created; + } else { + // Update + var existing = useFiber(current, portal.children || [], expirationTime); + existing['return'] = returnFiber; + return existing; + } + } + + function updateFragment(returnFiber, current, fragment, expirationTime, key) { + if (current === null || current.tag !== Fragment) { + // Insert + var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key); + created['return'] = returnFiber; + return created; + } else { + // Update + var existing = useFiber(current, fragment, expirationTime); + existing['return'] = returnFiber; + return existing; + } + } + + function createChild(returnFiber, newChild, expirationTime) { + if (typeof newChild === 'string' || typeof newChild === 'number') { + // Text nodes don't have keys. If the previous node is implicitly keyed + // we can continue to replace it without aborting even if it is not a text + // node. + var created = createFiberFromText('' + newChild, returnFiber.mode, expirationTime); + created['return'] = returnFiber; + return created; + } + + if (typeof newChild === 'object' && newChild !== null) { + switch (newChild.$$typeof) { + case REACT_ELEMENT_TYPE: + { + var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime); + _created.ref = coerceRef(returnFiber, null, newChild); + _created['return'] = returnFiber; + return _created; + } + case REACT_PORTAL_TYPE: + { + var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime); + _created2['return'] = returnFiber; + return _created2; + } + } + + if (isArray$1(newChild) || getIteratorFn(newChild)) { + var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null); + _created3['return'] = returnFiber; + return _created3; + } + + throwOnInvalidObjectType(returnFiber, newChild); + } + + { + if (typeof newChild === 'function') { + warnOnFunctionType(); + } + } + + return null; + } + + function updateSlot(returnFiber, oldFiber, newChild, expirationTime) { + // Update the fiber if the keys match, otherwise return null. + + var key = oldFiber !== null ? oldFiber.key : null; + + if (typeof newChild === 'string' || typeof newChild === 'number') { + // Text nodes don't have keys. If the previous node is implicitly keyed + // we can continue to replace it without aborting even if it is not a text + // node. + if (key !== null) { + return null; + } + return updateTextNode(returnFiber, oldFiber, '' + newChild, expirationTime); + } + + if (typeof newChild === 'object' && newChild !== null) { + switch (newChild.$$typeof) { + case REACT_ELEMENT_TYPE: + { + if (newChild.key === key) { + if (newChild.type === REACT_FRAGMENT_TYPE) { + return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key); + } + return updateElement(returnFiber, oldFiber, newChild, expirationTime); + } else { + return null; + } + } + case REACT_PORTAL_TYPE: + { + if (newChild.key === key) { + return updatePortal(returnFiber, oldFiber, newChild, expirationTime); + } else { + return null; + } + } + } + + if (isArray$1(newChild) || getIteratorFn(newChild)) { + if (key !== null) { + return null; + } + + return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null); + } + + throwOnInvalidObjectType(returnFiber, newChild); + } + + { + if (typeof newChild === 'function') { + warnOnFunctionType(); + } + } + + return null; + } + + function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) { + if (typeof newChild === 'string' || typeof newChild === 'number') { + // Text nodes don't have keys, so we neither have to check the old nor + // new node for the key. If both are text nodes, they match. + var matchedFiber = existingChildren.get(newIdx) || null; + return updateTextNode(returnFiber, matchedFiber, '' + newChild, expirationTime); + } + + if (typeof newChild === 'object' && newChild !== null) { + switch (newChild.$$typeof) { + case REACT_ELEMENT_TYPE: + { + var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null; + if (newChild.type === REACT_FRAGMENT_TYPE) { + return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key); + } + return updateElement(returnFiber, _matchedFiber, newChild, expirationTime); + } + case REACT_PORTAL_TYPE: + { + var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null; + return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime); + } + } + + if (isArray$1(newChild) || getIteratorFn(newChild)) { + var _matchedFiber3 = existingChildren.get(newIdx) || null; + return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null); + } + + throwOnInvalidObjectType(returnFiber, newChild); + } + + { + if (typeof newChild === 'function') { + warnOnFunctionType(); + } + } + + return null; + } + + /** + * Warns if there is a duplicate or missing key + */ + function warnOnInvalidKey(child, knownKeys) { + { + if (typeof child !== 'object' || child === null) { + return knownKeys; + } + switch (child.$$typeof) { + case REACT_ELEMENT_TYPE: + case REACT_PORTAL_TYPE: + warnForMissingKey(child); + var key = child.key; + if (typeof key !== 'string') { + break; + } + if (knownKeys === null) { + knownKeys = new Set(); + knownKeys.add(key); + break; + } + if (!knownKeys.has(key)) { + knownKeys.add(key); + break; + } + warning_1(false, 'Encountered two children with the same key, `%s`. ' + 'Keys should be unique so that components maintain their identity ' + 'across updates. Non-unique keys may cause children to be ' + 'duplicated and/or omitted — the behavior is unsupported and ' + 'could change in a future version.%s', key, getCurrentFiberStackAddendum$2()); + break; + default: + break; + } + } + return knownKeys; + } + + function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) { + // This algorithm can't optimize by searching from boths ends since we + // don't have backpointers on fibers. I'm trying to see how far we can get + // with that model. If it ends up not being worth the tradeoffs, we can + // add it later. + + // Even with a two ended optimization, we'd want to optimize for the case + // where there are few changes and brute force the comparison instead of + // going for the Map. It'd like to explore hitting that path first in + // forward-only mode and only go for the Map once we notice that we need + // lots of look ahead. This doesn't handle reversal as well as two ended + // search but that's unusual. Besides, for the two ended optimization to + // work on Iterables, we'd need to copy the whole set. + + // In this first iteration, we'll just live with hitting the bad case + // (adding everything to a Map) in for every insert/move. + + // If you change this code, also update reconcileChildrenIterator() which + // uses the same algorithm. + + { + // First, validate keys. + var knownKeys = null; + for (var i = 0; i < newChildren.length; i++) { + var child = newChildren[i]; + knownKeys = warnOnInvalidKey(child, knownKeys); + } + } + + var resultingFirstChild = null; + var previousNewFiber = null; + + var oldFiber = currentFirstChild; + var lastPlacedIndex = 0; + var newIdx = 0; + var nextOldFiber = null; + for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) { + if (oldFiber.index > newIdx) { + nextOldFiber = oldFiber; + oldFiber = null; + } else { + nextOldFiber = oldFiber.sibling; + } + var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime); + if (newFiber === null) { + // TODO: This breaks on empty slots like null children. That's + // unfortunate because it triggers the slow path all the time. We need + // a better way to communicate whether this was a miss or null, + // boolean, undefined, etc. + if (oldFiber === null) { + oldFiber = nextOldFiber; + } + break; + } + if (shouldTrackSideEffects) { + if (oldFiber && newFiber.alternate === null) { + // We matched the slot, but we didn't reuse the existing fiber, so we + // need to delete the existing child. + deleteChild(returnFiber, oldFiber); + } + } + lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx); + if (previousNewFiber === null) { + // TODO: Move out of the loop. This only happens for the first run. + resultingFirstChild = newFiber; + } else { + // TODO: Defer siblings if we're not at the right index for this slot. + // I.e. if we had null values before, then we want to defer this + // for each null value. However, we also don't want to call updateSlot + // with the previous one. + previousNewFiber.sibling = newFiber; + } + previousNewFiber = newFiber; + oldFiber = nextOldFiber; + } + + if (newIdx === newChildren.length) { + // We've reached the end of the new children. We can delete the rest. + deleteRemainingChildren(returnFiber, oldFiber); + return resultingFirstChild; + } + + if (oldFiber === null) { + // If we don't have any more existing children we can choose a fast path + // since the rest will all be insertions. + for (; newIdx < newChildren.length; newIdx++) { + var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime); + if (!_newFiber) { + continue; + } + lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx); + if (previousNewFiber === null) { + // TODO: Move out of the loop. This only happens for the first run. + resultingFirstChild = _newFiber; + } else { + previousNewFiber.sibling = _newFiber; + } + previousNewFiber = _newFiber; + } + return resultingFirstChild; + } + + // Add all children to a key map for quick lookups. + var existingChildren = mapRemainingChildren(returnFiber, oldFiber); + + // Keep scanning and use the map to restore deleted items as moves. + for (; newIdx < newChildren.length; newIdx++) { + var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], expirationTime); + if (_newFiber2) { + if (shouldTrackSideEffects) { + if (_newFiber2.alternate !== null) { + // The new fiber is a work in progress, but if there exists a + // current, that means that we reused the fiber. We need to delete + // it from the child list so that we don't add it to the deletion + // list. + existingChildren['delete'](_newFiber2.key === null ? newIdx : _newFiber2.key); + } + } + lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx); + if (previousNewFiber === null) { + resultingFirstChild = _newFiber2; + } else { + previousNewFiber.sibling = _newFiber2; + } + previousNewFiber = _newFiber2; + } + } + + if (shouldTrackSideEffects) { + // Any existing children that weren't consumed above were deleted. We need + // to add them to the deletion list. + existingChildren.forEach(function (child) { + return deleteChild(returnFiber, child); + }); + } + + return resultingFirstChild; + } + + function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, expirationTime) { + // This is the same implementation as reconcileChildrenArray(), + // but using the iterator instead. + + var iteratorFn = getIteratorFn(newChildrenIterable); + !(typeof iteratorFn === 'function') ? invariant_1(false, 'An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.') : void 0; + + { + // Warn about using Maps as children + if (typeof newChildrenIterable.entries === 'function') { + var possibleMap = newChildrenIterable; + if (possibleMap.entries === iteratorFn) { + warning_1(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', getCurrentFiberStackAddendum$2()); + didWarnAboutMaps = true; + } + } + + // First, validate keys. + // We'll get a different iterator later for the main pass. + var _newChildren = iteratorFn.call(newChildrenIterable); + if (_newChildren) { + var knownKeys = null; + var _step = _newChildren.next(); + for (; !_step.done; _step = _newChildren.next()) { + var child = _step.value; + knownKeys = warnOnInvalidKey(child, knownKeys); + } + } + } + + var newChildren = iteratorFn.call(newChildrenIterable); + !(newChildren != null) ? invariant_1(false, 'An iterable object provided no iterator.') : void 0; + + var resultingFirstChild = null; + var previousNewFiber = null; + + var oldFiber = currentFirstChild; + var lastPlacedIndex = 0; + var newIdx = 0; + var nextOldFiber = null; + + var step = newChildren.next(); + for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) { + if (oldFiber.index > newIdx) { + nextOldFiber = oldFiber; + oldFiber = null; + } else { + nextOldFiber = oldFiber.sibling; + } + var newFiber = updateSlot(returnFiber, oldFiber, step.value, expirationTime); + if (newFiber === null) { + // TODO: This breaks on empty slots like null children. That's + // unfortunate because it triggers the slow path all the time. We need + // a better way to communicate whether this was a miss or null, + // boolean, undefined, etc. + if (!oldFiber) { + oldFiber = nextOldFiber; + } + break; + } + if (shouldTrackSideEffects) { + if (oldFiber && newFiber.alternate === null) { + // We matched the slot, but we didn't reuse the existing fiber, so we + // need to delete the existing child. + deleteChild(returnFiber, oldFiber); + } + } + lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx); + if (previousNewFiber === null) { + // TODO: Move out of the loop. This only happens for the first run. + resultingFirstChild = newFiber; + } else { + // TODO: Defer siblings if we're not at the right index for this slot. + // I.e. if we had null values before, then we want to defer this + // for each null value. However, we also don't want to call updateSlot + // with the previous one. + previousNewFiber.sibling = newFiber; + } + previousNewFiber = newFiber; + oldFiber = nextOldFiber; + } + + if (step.done) { + // We've reached the end of the new children. We can delete the rest. + deleteRemainingChildren(returnFiber, oldFiber); + return resultingFirstChild; + } + + if (oldFiber === null) { + // If we don't have any more existing children we can choose a fast path + // since the rest will all be insertions. + for (; !step.done; newIdx++, step = newChildren.next()) { + var _newFiber3 = createChild(returnFiber, step.value, expirationTime); + if (_newFiber3 === null) { + continue; + } + lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx); + if (previousNewFiber === null) { + // TODO: Move out of the loop. This only happens for the first run. + resultingFirstChild = _newFiber3; + } else { + previousNewFiber.sibling = _newFiber3; + } + previousNewFiber = _newFiber3; + } + return resultingFirstChild; + } + + // Add all children to a key map for quick lookups. + var existingChildren = mapRemainingChildren(returnFiber, oldFiber); + + // Keep scanning and use the map to restore deleted items as moves. + for (; !step.done; newIdx++, step = newChildren.next()) { + var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, expirationTime); + if (_newFiber4 !== null) { + if (shouldTrackSideEffects) { + if (_newFiber4.alternate !== null) { + // The new fiber is a work in progress, but if there exists a + // current, that means that we reused the fiber. We need to delete + // it from the child list so that we don't add it to the deletion + // list. + existingChildren['delete'](_newFiber4.key === null ? newIdx : _newFiber4.key); + } + } + lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx); + if (previousNewFiber === null) { + resultingFirstChild = _newFiber4; + } else { + previousNewFiber.sibling = _newFiber4; + } + previousNewFiber = _newFiber4; + } + } + + if (shouldTrackSideEffects) { + // Any existing children that weren't consumed above were deleted. We need + // to add them to the deletion list. + existingChildren.forEach(function (child) { + return deleteChild(returnFiber, child); + }); + } + + return resultingFirstChild; + } + + function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, expirationTime) { + // There's no need to check for keys on text nodes since we don't have a + // way to define them. + if (currentFirstChild !== null && currentFirstChild.tag === HostText) { + // We already have an existing node so let's just update it and delete + // the rest. + deleteRemainingChildren(returnFiber, currentFirstChild.sibling); + var existing = useFiber(currentFirstChild, textContent, expirationTime); + existing['return'] = returnFiber; + return existing; + } + // The existing first child is not a text node so we need to create one + // and delete the existing ones. + deleteRemainingChildren(returnFiber, currentFirstChild); + var created = createFiberFromText(textContent, returnFiber.mode, expirationTime); + created['return'] = returnFiber; + return created; + } + + function reconcileSingleElement(returnFiber, currentFirstChild, element, expirationTime) { + var key = element.key; + var child = currentFirstChild; + while (child !== null) { + // TODO: If key === null and child.key === null, then this only applies to + // the first item in the list. + if (child.key === key) { + if (child.tag === Fragment ? element.type === REACT_FRAGMENT_TYPE : child.type === element.type) { + deleteRemainingChildren(returnFiber, child.sibling); + var existing = useFiber(child, element.type === REACT_FRAGMENT_TYPE ? element.props.children : element.props, expirationTime); + existing.ref = coerceRef(returnFiber, child, element); + existing['return'] = returnFiber; + { + existing._debugSource = element._source; + existing._debugOwner = element._owner; + } + return existing; + } else { + deleteRemainingChildren(returnFiber, child); + break; + } + } else { + deleteChild(returnFiber, child); + } + child = child.sibling; + } + + if (element.type === REACT_FRAGMENT_TYPE) { + var created = createFiberFromFragment(element.props.children, returnFiber.mode, expirationTime, element.key); + created['return'] = returnFiber; + return created; + } else { + var _created4 = createFiberFromElement(element, returnFiber.mode, expirationTime); + _created4.ref = coerceRef(returnFiber, currentFirstChild, element); + _created4['return'] = returnFiber; + return _created4; + } + } + + function reconcileSinglePortal(returnFiber, currentFirstChild, portal, expirationTime) { + var key = portal.key; + var child = currentFirstChild; + while (child !== null) { + // TODO: If key === null and child.key === null, then this only applies to + // the first item in the list. + if (child.key === key) { + if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) { + deleteRemainingChildren(returnFiber, child.sibling); + var existing = useFiber(child, portal.children || [], expirationTime); + existing['return'] = returnFiber; + return existing; + } else { + deleteRemainingChildren(returnFiber, child); + break; + } + } else { + deleteChild(returnFiber, child); + } + child = child.sibling; + } + + var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime); + created['return'] = returnFiber; + return created; + } + + // This API will tag the children with the side-effect of the reconciliation + // itself. They will be added to the side-effect list as we pass through the + // children and the parent. + function reconcileChildFibers(returnFiber, currentFirstChild, newChild, expirationTime) { + // This function is not recursive. + // If the top level item is an array, we treat it as a set of children, + // not as a fragment. Nested arrays on the other hand will be treated as + // fragment nodes. Recursion happens at the normal flow. + + // Handle top level unkeyed fragments as if they were arrays. + // This leads to an ambiguity between <>{[...]} and <>.... + // We treat the ambiguous cases above the same. + if (typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null) { + newChild = newChild.props.children; + } + + // Handle object types + var isObject = typeof newChild === 'object' && newChild !== null; + + if (isObject) { + switch (newChild.$$typeof) { + case REACT_ELEMENT_TYPE: + return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, expirationTime)); + case REACT_PORTAL_TYPE: + return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, expirationTime)); + } + } + + if (typeof newChild === 'string' || typeof newChild === 'number') { + return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, expirationTime)); + } + + if (isArray$1(newChild)) { + return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime); + } + + if (getIteratorFn(newChild)) { + return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime); + } + + if (isObject) { + throwOnInvalidObjectType(returnFiber, newChild); + } + + { + if (typeof newChild === 'function') { + warnOnFunctionType(); + } + } + if (typeof newChild === 'undefined') { + // If the new child is undefined, and the return fiber is a composite + // component, throw an error. If Fiber return types are disabled, + // we already threw above. + switch (returnFiber.tag) { + case ClassComponent: + { + { + var instance = returnFiber.stateNode; + if (instance.render._isMockFunction) { + // We allow auto-mocks to proceed as if they're returning null. + break; + } + } + } + // Intentionally fall through to the next case, which handles both + // functions and classes + // eslint-disable-next-lined no-fallthrough + case FunctionalComponent: + { + var Component = returnFiber.type; + invariant_1(false, '%s(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.', Component.displayName || Component.name || 'Component'); + } + } + } + + // Remaining cases are all treated as empty. + return deleteRemainingChildren(returnFiber, currentFirstChild); + } + + return reconcileChildFibers; +} + +var reconcileChildFibers = ChildReconciler(true); +var mountChildFibers = ChildReconciler(false); + +function cloneChildFibers(current, workInProgress) { + !(current === null || workInProgress.child === current.child) ? invariant_1(false, 'Resuming work not yet implemented.') : void 0; + + if (workInProgress.child === null) { + return; + } + + var currentChild = workInProgress.child; + var newChild = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime); + workInProgress.child = newChild; + + newChild['return'] = workInProgress; + while (currentChild.sibling !== null) { + currentChild = currentChild.sibling; + newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime); + newChild['return'] = workInProgress; + } + newChild.sibling = null; +} + +var didWarnAboutBadClass = void 0; +var didWarnAboutGetDerivedStateOnFunctionalComponent = void 0; +var didWarnAboutStatelessRefs = void 0; + +{ + didWarnAboutBadClass = {}; + didWarnAboutGetDerivedStateOnFunctionalComponent = {}; + didWarnAboutStatelessRefs = {}; +} + +var ReactFiberBeginWork = function (config, hostContext, legacyContext, newContext, hydrationContext, scheduleWork, computeExpirationForFiber) { + var shouldSetTextContent = config.shouldSetTextContent, + shouldDeprioritizeSubtree = config.shouldDeprioritizeSubtree; + var pushHostContext = hostContext.pushHostContext, + pushHostContainer = hostContext.pushHostContainer; + var pushProvider = newContext.pushProvider; + var getMaskedContext = legacyContext.getMaskedContext, + getUnmaskedContext = legacyContext.getUnmaskedContext, + hasLegacyContextChanged = legacyContext.hasContextChanged, + pushLegacyContextProvider = legacyContext.pushContextProvider, + pushTopLevelContextObject = legacyContext.pushTopLevelContextObject, + invalidateContextProvider = legacyContext.invalidateContextProvider; + var enterHydrationState = hydrationContext.enterHydrationState, + resetHydrationState = hydrationContext.resetHydrationState, + tryToClaimNextHydratableInstance = hydrationContext.tryToClaimNextHydratableInstance; + + var _ReactFiberClassCompo = ReactFiberClassComponent(legacyContext, scheduleWork, computeExpirationForFiber, memoizeProps, memoizeState), + adoptClassInstance = _ReactFiberClassCompo.adoptClassInstance, + callGetDerivedStateFromProps = _ReactFiberClassCompo.callGetDerivedStateFromProps, + constructClassInstance = _ReactFiberClassCompo.constructClassInstance, + mountClassInstance = _ReactFiberClassCompo.mountClassInstance, + resumeMountClassInstance = _ReactFiberClassCompo.resumeMountClassInstance, + updateClassInstance = _ReactFiberClassCompo.updateClassInstance; + + // TODO: Remove this and use reconcileChildrenAtExpirationTime directly. + + + function reconcileChildren(current, workInProgress, nextChildren) { + reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, workInProgress.expirationTime); + } + + function reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime) { + if (current === null) { + // If this is a fresh new component that hasn't been rendered yet, we + // won't update its child set by applying minimal side-effects. Instead, + // we will add them all to the child before it gets rendered. That means + // we can optimize this reconciliation pass by not tracking side-effects. + workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime); + } else { + // If the current child is the same as the work in progress, it means that + // we haven't yet started any work on these children. Therefore, we use + // the clone algorithm to create a copy of all the current children. + + // If we had any progressed work already, that is invalid at this point so + // let's throw it out. + workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderExpirationTime); + } + } + + function updateForwardRef(current, workInProgress) { + var render = workInProgress.type.render; + var nextChildren = render(workInProgress.pendingProps, workInProgress.ref); + reconcileChildren(current, workInProgress, nextChildren); + memoizeProps(workInProgress, nextChildren); + return workInProgress.child; + } + + function updateFragment(current, workInProgress) { + var nextChildren = workInProgress.pendingProps; + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (workInProgress.memoizedProps === nextChildren) { + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + reconcileChildren(current, workInProgress, nextChildren); + memoizeProps(workInProgress, nextChildren); + return workInProgress.child; + } + + function updateMode(current, workInProgress) { + var nextChildren = workInProgress.pendingProps.children; + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (nextChildren === null || workInProgress.memoizedProps === nextChildren) { + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + reconcileChildren(current, workInProgress, nextChildren); + memoizeProps(workInProgress, nextChildren); + return workInProgress.child; + } + + function markRef(current, workInProgress) { + var ref = workInProgress.ref; + if (current === null && ref !== null || current !== null && current.ref !== ref) { + // Schedule a Ref effect + workInProgress.effectTag |= Ref; + } + } + + function updateFunctionalComponent(current, workInProgress) { + var fn = workInProgress.type; + var nextProps = workInProgress.pendingProps; + + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else { + if (workInProgress.memoizedProps === nextProps) { + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + // TODO: consider bringing fn.shouldComponentUpdate() back. + // It used to be here. + } + + var unmaskedContext = getUnmaskedContext(workInProgress); + var context = getMaskedContext(workInProgress, unmaskedContext); + + var nextChildren = void 0; + + { + ReactCurrentOwner.current = workInProgress; + ReactDebugCurrentFiber.setCurrentPhase('render'); + nextChildren = fn(nextProps, context); + ReactDebugCurrentFiber.setCurrentPhase(null); + } + // React DevTools reads this flag. + workInProgress.effectTag |= PerformedWork; + reconcileChildren(current, workInProgress, nextChildren); + memoizeProps(workInProgress, nextProps); + return workInProgress.child; + } + + function updateClassComponent(current, workInProgress, renderExpirationTime) { + // Push context providers early to prevent context stack mismatches. + // During mounting we don't know the child context yet as the instance doesn't exist. + // We will invalidate the child context in finishClassComponent() right after rendering. + var hasContext = pushLegacyContextProvider(workInProgress); + var shouldUpdate = void 0; + if (current === null) { + if (workInProgress.stateNode === null) { + // In the initial pass we might need to construct the instance. + constructClassInstance(workInProgress, workInProgress.pendingProps); + mountClassInstance(workInProgress, renderExpirationTime); + + shouldUpdate = true; + } else { + // In a resume, we'll already have an instance we can reuse. + shouldUpdate = resumeMountClassInstance(workInProgress, renderExpirationTime); + } + } else { + shouldUpdate = updateClassInstance(current, workInProgress, renderExpirationTime); + } + + // We processed the update queue inside updateClassInstance. It may have + // included some errors that were dispatched during the commit phase. + // TODO: Refactor class components so this is less awkward. + var didCaptureError = false; + var updateQueue = workInProgress.updateQueue; + if (updateQueue !== null && updateQueue.capturedValues !== null) { + shouldUpdate = true; + didCaptureError = true; + } + return finishClassComponent(current, workInProgress, shouldUpdate, hasContext, didCaptureError, renderExpirationTime); + } + + function finishClassComponent(current, workInProgress, shouldUpdate, hasContext, didCaptureError, renderExpirationTime) { + // Refs should update even if shouldComponentUpdate returns false + markRef(current, workInProgress); + + if (!shouldUpdate && !didCaptureError) { + // Context providers should defer to sCU for rendering + if (hasContext) { + invalidateContextProvider(workInProgress, false); + } + + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + + var ctor = workInProgress.type; + var instance = workInProgress.stateNode; + + // Rerender + ReactCurrentOwner.current = workInProgress; + var nextChildren = void 0; + if (didCaptureError && (!enableGetDerivedStateFromCatch || typeof ctor.getDerivedStateFromCatch !== 'function')) { + // If we captured an error, but getDerivedStateFrom catch is not defined, + // unmount all the children. componentDidCatch will schedule an update to + // re-render a fallback. This is temporary until we migrate everyone to + // the new API. + // TODO: Warn in a future release. + nextChildren = null; + } else { + { + ReactDebugCurrentFiber.setCurrentPhase('render'); + nextChildren = instance.render(); + if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) { + instance.render(); + } + ReactDebugCurrentFiber.setCurrentPhase(null); + } + } + + // React DevTools reads this flag. + workInProgress.effectTag |= PerformedWork; + if (didCaptureError) { + // If we're recovering from an error, reconcile twice: first to delete + // all the existing children. + reconcileChildrenAtExpirationTime(current, workInProgress, null, renderExpirationTime); + workInProgress.child = null; + // Now we can continue reconciling like normal. This has the effect of + // remounting all children regardless of whether their their + // identity matches. + } + reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime); + // Memoize props and state using the values we just used to render. + // TODO: Restructure so we never read values from the instance. + memoizeState(workInProgress, instance.state); + memoizeProps(workInProgress, instance.props); + + // The context might have changed so we need to recalculate it. + if (hasContext) { + invalidateContextProvider(workInProgress, true); + } + + return workInProgress.child; + } + + function pushHostRootContext(workInProgress) { + var root = workInProgress.stateNode; + if (root.pendingContext) { + pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context); + } else if (root.context) { + // Should always be set + pushTopLevelContextObject(workInProgress, root.context, false); + } + pushHostContainer(workInProgress, root.containerInfo); + } + + function updateHostRoot(current, workInProgress, renderExpirationTime) { + pushHostRootContext(workInProgress); + var updateQueue = workInProgress.updateQueue; + if (updateQueue !== null) { + var prevState = workInProgress.memoizedState; + var state = processUpdateQueue(current, workInProgress, updateQueue, null, null, renderExpirationTime); + memoizeState(workInProgress, state); + updateQueue = workInProgress.updateQueue; + + var element = void 0; + if (updateQueue !== null && updateQueue.capturedValues !== null) { + // There's an uncaught error. Unmount the whole root. + element = null; + } else if (prevState === state) { + // If the state is the same as before, that's a bailout because we had + // no work that expires at this time. + resetHydrationState(); + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } else { + element = state.element; + } + var root = workInProgress.stateNode; + if ((current === null || current.child === null) && root.hydrate && enterHydrationState(workInProgress)) { + // If we don't have any current children this might be the first pass. + // We always try to hydrate. If this isn't a hydration pass there won't + // be any children to hydrate which is effectively the same thing as + // not hydrating. + + // This is a bit of a hack. We track the host root as a placement to + // know that we're currently in a mounting state. That way isMounted + // works as expected. We must reset this before committing. + // TODO: Delete this when we delete isMounted and findDOMNode. + workInProgress.effectTag |= Placement; + + // Ensure that children mount into this root without tracking + // side-effects. This ensures that we don't store Placement effects on + // nodes that will be hydrated. + workInProgress.child = mountChildFibers(workInProgress, null, element, renderExpirationTime); + } else { + // Otherwise reset hydration state in case we aborted and resumed another + // root. + resetHydrationState(); + reconcileChildren(current, workInProgress, element); + } + memoizeState(workInProgress, state); + return workInProgress.child; + } + resetHydrationState(); + // If there is no update queue, that's a bailout because the root has no props. + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + + function updateHostComponent(current, workInProgress, renderExpirationTime) { + pushHostContext(workInProgress); + + if (current === null) { + tryToClaimNextHydratableInstance(workInProgress); + } + + var type = workInProgress.type; + var memoizedProps = workInProgress.memoizedProps; + var nextProps = workInProgress.pendingProps; + var prevProps = current !== null ? current.memoizedProps : null; + + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (memoizedProps === nextProps) { + var isHidden = workInProgress.mode & AsyncMode && shouldDeprioritizeSubtree(type, nextProps); + if (isHidden) { + // Before bailing out, make sure we've deprioritized a hidden component. + workInProgress.expirationTime = Never; + } + if (!isHidden || renderExpirationTime !== Never) { + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + // If we're rendering a hidden node at hidden priority, don't bailout. The + // parent is complete, but the children may not be. + } + + var nextChildren = nextProps.children; + var isDirectTextChild = shouldSetTextContent(type, nextProps); + + if (isDirectTextChild) { + // We special case a direct text child of a host node. This is a common + // case. We won't handle it as a reified child. We will instead handle + // this in the host environment that also have access to this prop. That + // avoids allocating another HostText fiber and traversing it. + nextChildren = null; + } else if (prevProps && shouldSetTextContent(type, prevProps)) { + // If we're switching from a direct text child to a normal child, or to + // empty, we need to schedule the text content to be reset. + workInProgress.effectTag |= ContentReset; + } + + markRef(current, workInProgress); + + // Check the host config to see if the children are offscreen/hidden. + if (renderExpirationTime !== Never && workInProgress.mode & AsyncMode && shouldDeprioritizeSubtree(type, nextProps)) { + // Down-prioritize the children. + workInProgress.expirationTime = Never; + // Bailout and come back to this fiber later. + workInProgress.memoizedProps = nextProps; + return null; + } + + reconcileChildren(current, workInProgress, nextChildren); + memoizeProps(workInProgress, nextProps); + return workInProgress.child; + } + + function updateHostText(current, workInProgress) { + if (current === null) { + tryToClaimNextHydratableInstance(workInProgress); + } + var nextProps = workInProgress.pendingProps; + memoizeProps(workInProgress, nextProps); + // Nothing to do here. This is terminal. We'll do the completion step + // immediately after. + return null; + } + + function mountIndeterminateComponent(current, workInProgress, renderExpirationTime) { + !(current === null) ? invariant_1(false, 'An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue.') : void 0; + var fn = workInProgress.type; + var props = workInProgress.pendingProps; + var unmaskedContext = getUnmaskedContext(workInProgress); + var context = getMaskedContext(workInProgress, unmaskedContext); + + var value = void 0; + + { + if (fn.prototype && typeof fn.prototype.render === 'function') { + var componentName = getComponentName(workInProgress) || 'Unknown'; + + if (!didWarnAboutBadClass[componentName]) { + warning_1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + 'This is likely to cause errors. Change %s to extend React.Component instead.', componentName, componentName); + didWarnAboutBadClass[componentName] = true; + } + } + ReactCurrentOwner.current = workInProgress; + value = fn(props, context); + } + // React DevTools reads this flag. + workInProgress.effectTag |= PerformedWork; + + if (typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) { + var Component = workInProgress.type; + + // Proceed under the assumption that this is a class instance + workInProgress.tag = ClassComponent; + + workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null; + + if (typeof Component.getDerivedStateFromProps === 'function') { + var partialState = callGetDerivedStateFromProps(workInProgress, value, props, workInProgress.memoizedState); + + if (partialState !== null && partialState !== undefined) { + workInProgress.memoizedState = _assign({}, workInProgress.memoizedState, partialState); + } + } + + // Push context providers early to prevent context stack mismatches. + // During mounting we don't know the child context yet as the instance doesn't exist. + // We will invalidate the child context in finishClassComponent() right after rendering. + var hasContext = pushLegacyContextProvider(workInProgress); + adoptClassInstance(workInProgress, value); + mountClassInstance(workInProgress, renderExpirationTime); + return finishClassComponent(current, workInProgress, true, hasContext, false, renderExpirationTime); + } else { + // Proceed under the assumption that this is a functional component + workInProgress.tag = FunctionalComponent; + { + var _Component = workInProgress.type; + + if (_Component) { + warning_1(!_Component.childContextTypes, '%s(...): childContextTypes cannot be defined on a functional component.', _Component.displayName || _Component.name || 'Component'); + } + if (workInProgress.ref !== null) { + var info = ''; + var ownerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName(); + if (ownerName) { + info += '\n\nCheck the render method of `' + ownerName + '`.'; + } + + var warningKey = ownerName || workInProgress._debugID || ''; + var debugSource = workInProgress._debugSource; + if (debugSource) { + warningKey = debugSource.fileName + ':' + debugSource.lineNumber; + } + if (!didWarnAboutStatelessRefs[warningKey]) { + didWarnAboutStatelessRefs[warningKey] = true; + warning_1(false, 'Stateless function components cannot be given refs. ' + 'Attempts to access this ref will fail.%s%s', info, ReactDebugCurrentFiber.getCurrentFiberStackAddendum()); + } + } + + if (typeof fn.getDerivedStateFromProps === 'function') { + var _componentName = getComponentName(workInProgress) || 'Unknown'; + + if (!didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName]) { + warning_1(false, '%s: Stateless functional components do not support getDerivedStateFromProps.', _componentName); + didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName] = true; + } + } + } + reconcileChildren(current, workInProgress, value); + memoizeProps(workInProgress, props); + return workInProgress.child; + } + } + + function updateCallComponent(current, workInProgress, renderExpirationTime) { + var nextProps = workInProgress.pendingProps; + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (workInProgress.memoizedProps === nextProps) { + nextProps = workInProgress.memoizedProps; + // TODO: When bailing out, we might need to return the stateNode instead + // of the child. To check it for work. + // return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + + var nextChildren = nextProps.children; + + // The following is a fork of reconcileChildrenAtExpirationTime but using + // stateNode to store the child. + if (current === null) { + workInProgress.stateNode = mountChildFibers(workInProgress, workInProgress.stateNode, nextChildren, renderExpirationTime); + } else { + workInProgress.stateNode = reconcileChildFibers(workInProgress, current.stateNode, nextChildren, renderExpirationTime); + } + + memoizeProps(workInProgress, nextProps); + // This doesn't take arbitrary time so we could synchronously just begin + // eagerly do the work of workInProgress.child as an optimization. + return workInProgress.stateNode; + } + + function updatePortalComponent(current, workInProgress, renderExpirationTime) { + pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo); + var nextChildren = workInProgress.pendingProps; + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (workInProgress.memoizedProps === nextChildren) { + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + + if (current === null) { + // Portals are special because we don't append the children during mount + // but at commit. Therefore we need to track insertions which the normal + // flow doesn't do during mount. This doesn't happen at the root because + // the root always starts with a "current" with a null child. + // TODO: Consider unifying this with how the root works. + workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime); + memoizeProps(workInProgress, nextChildren); + } else { + reconcileChildren(current, workInProgress, nextChildren); + memoizeProps(workInProgress, nextChildren); + } + return workInProgress.child; + } + + function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) { + var fiber = workInProgress.child; + if (fiber !== null) { + // Set the return pointer of the child to the work-in-progress fiber. + fiber['return'] = workInProgress; + } + while (fiber !== null) { + var nextFiber = void 0; + // Visit this fiber. + switch (fiber.tag) { + case ContextConsumer: + // Check if the context matches. + var observedBits = fiber.stateNode | 0; + if (fiber.type === context && (observedBits & changedBits) !== 0) { + // Update the expiration time of all the ancestors, including + // the alternates. + var node = fiber; + while (node !== null) { + var alternate = node.alternate; + if (node.expirationTime === NoWork || node.expirationTime > renderExpirationTime) { + node.expirationTime = renderExpirationTime; + if (alternate !== null && (alternate.expirationTime === NoWork || alternate.expirationTime > renderExpirationTime)) { + alternate.expirationTime = renderExpirationTime; + } + } else if (alternate !== null && (alternate.expirationTime === NoWork || alternate.expirationTime > renderExpirationTime)) { + alternate.expirationTime = renderExpirationTime; + } else { + // Neither alternate was updated, which means the rest of the + // ancestor path already has sufficient priority. + break; + } + node = node['return']; + } + // Don't scan deeper than a matching consumer. When we render the + // consumer, we'll continue scanning from that point. This way the + // scanning work is time-sliced. + nextFiber = null; + } else { + // Traverse down. + nextFiber = fiber.child; + } + break; + case ContextProvider: + // Don't scan deeper if this is a matching provider + nextFiber = fiber.type === workInProgress.type ? null : fiber.child; + break; + default: + // Traverse down. + nextFiber = fiber.child; + break; + } + if (nextFiber !== null) { + // Set the return pointer of the child to the work-in-progress fiber. + nextFiber['return'] = fiber; + } else { + // No child. Traverse to next sibling. + nextFiber = fiber; + while (nextFiber !== null) { + if (nextFiber === workInProgress) { + // We're back to the root of this subtree. Exit. + nextFiber = null; + break; + } + var sibling = nextFiber.sibling; + if (sibling !== null) { + nextFiber = sibling; + break; + } + // No more siblings. Traverse up. + nextFiber = nextFiber['return']; + } + } + fiber = nextFiber; + } + } + + function updateContextProvider(current, workInProgress, renderExpirationTime) { + var providerType = workInProgress.type; + var context = providerType.context; + + var newProps = workInProgress.pendingProps; + var oldProps = workInProgress.memoizedProps; + + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (oldProps === newProps) { + workInProgress.stateNode = 0; + pushProvider(workInProgress); + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + + var newValue = newProps.value; + workInProgress.memoizedProps = newProps; + + var changedBits = void 0; + if (oldProps === null) { + // Initial render + changedBits = MAX_SIGNED_31_BIT_INT; + } else { + if (oldProps.value === newProps.value) { + // No change. Bailout early if children are the same. + if (oldProps.children === newProps.children) { + workInProgress.stateNode = 0; + pushProvider(workInProgress); + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + changedBits = 0; + } else { + var oldValue = oldProps.value; + // Use Object.is to compare the new context value to the old value. + // Inlined Object.is polyfill. + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is + if (oldValue === newValue && (oldValue !== 0 || 1 / oldValue === 1 / newValue) || oldValue !== oldValue && newValue !== newValue // eslint-disable-line no-self-compare + ) { + // No change. Bailout early if children are the same. + if (oldProps.children === newProps.children) { + workInProgress.stateNode = 0; + pushProvider(workInProgress); + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + changedBits = 0; + } else { + changedBits = typeof context._calculateChangedBits === 'function' ? context._calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT; + { + warning_1((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: %s', changedBits); + } + changedBits |= 0; + + if (changedBits === 0) { + // No change. Bailout early if children are the same. + if (oldProps.children === newProps.children) { + workInProgress.stateNode = 0; + pushProvider(workInProgress); + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + } else { + propagateContextChange(workInProgress, context, changedBits, renderExpirationTime); + } + } + } + } + + workInProgress.stateNode = changedBits; + pushProvider(workInProgress); + + var newChildren = newProps.children; + reconcileChildren(current, workInProgress, newChildren); + return workInProgress.child; + } + + function updateContextConsumer(current, workInProgress, renderExpirationTime) { + var context = workInProgress.type; + var newProps = workInProgress.pendingProps; + var oldProps = workInProgress.memoizedProps; + + var newValue = context._currentValue; + var changedBits = context._changedBits; + + if (hasLegacyContextChanged()) { + // Normally we can bail out on props equality but if context has changed + // we don't do the bailout and we have to reuse existing props instead. + } else if (changedBits === 0 && oldProps === newProps) { + return bailoutOnAlreadyFinishedWork(current, workInProgress); + } + workInProgress.memoizedProps = newProps; + + var observedBits = newProps.unstable_observedBits; + if (observedBits === undefined || observedBits === null) { + // Subscribe to all changes by default + observedBits = MAX_SIGNED_31_BIT_INT; + } + // Store the observedBits on the fiber's stateNode for quick access. + workInProgress.stateNode = observedBits; + + if ((changedBits & observedBits) !== 0) { + // Context change propagation stops at matching consumers, for time- + // slicing. Continue the propagation here. + propagateContextChange(workInProgress, context, changedBits, renderExpirationTime); + } + // There is no bailout on `children` equality because we expect people + // to often pass a bound method as a child, but it may reference + // `this.state` or `this.props` (and thus needs to re-render on `setState`). + + var render = newProps.children; + + { + warning_1(typeof render === 'function', 'A context consumer was rendered with multiple children, or a child ' + "that isn't a function. A context consumer expects a single child " + 'that is a function. If you did pass a function, make sure there ' + 'is no trailing or leading whitespace around it.'); + } + + var newChildren = render(newValue); + reconcileChildren(current, workInProgress, newChildren); + return workInProgress.child; + } + + /* + function reuseChildrenEffects(returnFiber : Fiber, firstChild : Fiber) { + let child = firstChild; + do { + // Ensure that the first and last effect of the parent corresponds + // to the children's first and last effect. + if (!returnFiber.firstEffect) { + returnFiber.firstEffect = child.firstEffect; + } + if (child.lastEffect) { + if (returnFiber.lastEffect) { + returnFiber.lastEffect.nextEffect = child.firstEffect; + } + returnFiber.lastEffect = child.lastEffect; + } + } while (child = child.sibling); + } + */ + + function bailoutOnAlreadyFinishedWork(current, workInProgress) { + cancelWorkTimer(workInProgress); + + // TODO: We should ideally be able to bail out early if the children have no + // more work to do. However, since we don't have a separation of this + // Fiber's priority and its children yet - we don't know without doing lots + // of the same work we do anyway. Once we have that separation we can just + // bail out here if the children has no more work at this priority level. + // if (workInProgress.priorityOfChildren <= priorityLevel) { + // // If there are side-effects in these children that have not yet been + // // committed we need to ensure that they get properly transferred up. + // if (current && current.child !== workInProgress.child) { + // reuseChildrenEffects(workInProgress, child); + // } + // return null; + // } + + cloneChildFibers(current, workInProgress); + return workInProgress.child; + } + + function bailoutOnLowPriority(current, workInProgress) { + cancelWorkTimer(workInProgress); + + // TODO: Handle HostComponent tags here as well and call pushHostContext()? + // See PR 8590 discussion for context + switch (workInProgress.tag) { + case HostRoot: + pushHostRootContext(workInProgress); + break; + case ClassComponent: + pushLegacyContextProvider(workInProgress); + break; + case HostPortal: + pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo); + break; + case ContextProvider: + pushProvider(workInProgress); + break; + } + // TODO: What if this is currently in progress? + // How can that happen? How is this not being cloned? + return null; + } + + // TODO: Delete memoizeProps/State and move to reconcile/bailout instead + function memoizeProps(workInProgress, nextProps) { + workInProgress.memoizedProps = nextProps; + } + + function memoizeState(workInProgress, nextState) { + workInProgress.memoizedState = nextState; + // Don't reset the updateQueue, in case there are pending updates. Resetting + // is handled by processUpdateQueue. + } + + function beginWork(current, workInProgress, renderExpirationTime) { + if (workInProgress.expirationTime === NoWork || workInProgress.expirationTime > renderExpirationTime) { + return bailoutOnLowPriority(current, workInProgress); + } + + switch (workInProgress.tag) { + case IndeterminateComponent: + return mountIndeterminateComponent(current, workInProgress, renderExpirationTime); + case FunctionalComponent: + return updateFunctionalComponent(current, workInProgress); + case ClassComponent: + return updateClassComponent(current, workInProgress, renderExpirationTime); + case HostRoot: + return updateHostRoot(current, workInProgress, renderExpirationTime); + case HostComponent: + return updateHostComponent(current, workInProgress, renderExpirationTime); + case HostText: + return updateHostText(current, workInProgress); + case CallHandlerPhase: + // This is a restart. Reset the tag to the initial phase. + workInProgress.tag = CallComponent; + // Intentionally fall through since this is now the same. + case CallComponent: + return updateCallComponent(current, workInProgress, renderExpirationTime); + case ReturnComponent: + // A return component is just a placeholder, we can just run through the + // next one immediately. + return null; + case HostPortal: + return updatePortalComponent(current, workInProgress, renderExpirationTime); + case ForwardRef: + return updateForwardRef(current, workInProgress); + case Fragment: + return updateFragment(current, workInProgress); + case Mode: + return updateMode(current, workInProgress); + case ContextProvider: + return updateContextProvider(current, workInProgress, renderExpirationTime); + case ContextConsumer: + return updateContextConsumer(current, workInProgress, renderExpirationTime); + default: + invariant_1(false, 'Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.'); + } + } + + return { + beginWork: beginWork + }; +}; + +var ReactFiberCompleteWork = function (config, hostContext, legacyContext, newContext, hydrationContext) { + var createInstance = config.createInstance, + createTextInstance = config.createTextInstance, + appendInitialChild = config.appendInitialChild, + finalizeInitialChildren = config.finalizeInitialChildren, + prepareUpdate = config.prepareUpdate, + mutation = config.mutation, + persistence = config.persistence; + var getRootHostContainer = hostContext.getRootHostContainer, + popHostContext = hostContext.popHostContext, + getHostContext = hostContext.getHostContext, + popHostContainer = hostContext.popHostContainer; + var popLegacyContextProvider = legacyContext.popContextProvider, + popTopLevelLegacyContextObject = legacyContext.popTopLevelContextObject; + var popProvider = newContext.popProvider; + var prepareToHydrateHostInstance = hydrationContext.prepareToHydrateHostInstance, + prepareToHydrateHostTextInstance = hydrationContext.prepareToHydrateHostTextInstance, + popHydrationState = hydrationContext.popHydrationState; + + + function markUpdate(workInProgress) { + // Tag the fiber with an update effect. This turns a Placement into + // an UpdateAndPlacement. + workInProgress.effectTag |= Update; + } + + function markRef(workInProgress) { + workInProgress.effectTag |= Ref; + } + + function appendAllReturns(returns, workInProgress) { + var node = workInProgress.stateNode; + if (node) { + node['return'] = workInProgress; + } + while (node !== null) { + if (node.tag === HostComponent || node.tag === HostText || node.tag === HostPortal) { + invariant_1(false, 'A call cannot have host component children.'); + } else if (node.tag === ReturnComponent) { + returns.push(node.pendingProps.value); + } else if (node.child !== null) { + node.child['return'] = node; + node = node.child; + continue; + } + while (node.sibling === null) { + if (node['return'] === null || node['return'] === workInProgress) { + return; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + } + + function moveCallToHandlerPhase(current, workInProgress, renderExpirationTime) { + var props = workInProgress.memoizedProps; + !props ? invariant_1(false, 'Should be resolved by now. This error is likely caused by a bug in React. Please file an issue.') : void 0; + + // First step of the call has completed. Now we need to do the second. + // TODO: It would be nice to have a multi stage call represented by a + // single component, or at least tail call optimize nested ones. Currently + // that requires additional fields that we don't want to add to the fiber. + // So this requires nested handlers. + // Note: This doesn't mutate the alternate node. I don't think it needs to + // since this stage is reset for every pass. + workInProgress.tag = CallHandlerPhase; + + // Build up the returns. + // TODO: Compare this to a generator or opaque helpers like Children. + var returns = []; + appendAllReturns(returns, workInProgress); + var fn = props.handler; + var childProps = props.props; + var nextChildren = fn(childProps, returns); + + var currentFirstChild = current !== null ? current.child : null; + workInProgress.child = reconcileChildFibers(workInProgress, currentFirstChild, nextChildren, renderExpirationTime); + return workInProgress.child; + } + + function appendAllChildren(parent, workInProgress) { + // We only have the top Fiber that was created but we need recurse down its + // children to find all the terminal nodes. + var node = workInProgress.child; + while (node !== null) { + if (node.tag === HostComponent || node.tag === HostText) { + appendInitialChild(parent, node.stateNode); + } else if (node.tag === HostPortal) { + // If we have a portal child, then we don't want to traverse + // down its children. Instead, we'll get insertions from each child in + // the portal directly. + } else if (node.child !== null) { + node.child['return'] = node; + node = node.child; + continue; + } + if (node === workInProgress) { + return; + } + while (node.sibling === null) { + if (node['return'] === null || node['return'] === workInProgress) { + return; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + } + + var updateHostContainer = void 0; + var updateHostComponent = void 0; + var updateHostText = void 0; + if (mutation) { + if (enableMutatingReconciler) { + // Mutation mode + updateHostContainer = function (workInProgress) { + // Noop + }; + updateHostComponent = function (current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) { + // TODO: Type this specific to this type of component. + workInProgress.updateQueue = updatePayload; + // If the update payload indicates that there is a change or if there + // is a new ref we mark this as an update. All the work is done in commitWork. + if (updatePayload) { + markUpdate(workInProgress); + } + }; + updateHostText = function (current, workInProgress, oldText, newText) { + // If the text differs, mark it as an update. All the work in done in commitWork. + if (oldText !== newText) { + markUpdate(workInProgress); + } + }; + } else { + invariant_1(false, 'Mutating reconciler is disabled.'); + } + } else if (persistence) { + if (enablePersistentReconciler) { + // Persistent host tree mode + var cloneInstance = persistence.cloneInstance, + createContainerChildSet = persistence.createContainerChildSet, + appendChildToContainerChildSet = persistence.appendChildToContainerChildSet, + finalizeContainerChildren = persistence.finalizeContainerChildren; + + // An unfortunate fork of appendAllChildren because we have two different parent types. + + var appendAllChildrenToContainer = function (containerChildSet, workInProgress) { + // We only have the top Fiber that was created but we need recurse down its + // children to find all the terminal nodes. + var node = workInProgress.child; + while (node !== null) { + if (node.tag === HostComponent || node.tag === HostText) { + appendChildToContainerChildSet(containerChildSet, node.stateNode); + } else if (node.tag === HostPortal) { + // If we have a portal child, then we don't want to traverse + // down its children. Instead, we'll get insertions from each child in + // the portal directly. + } else if (node.child !== null) { + node.child['return'] = node; + node = node.child; + continue; + } + if (node === workInProgress) { + return; + } + while (node.sibling === null) { + if (node['return'] === null || node['return'] === workInProgress) { + return; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + }; + updateHostContainer = function (workInProgress) { + var portalOrRoot = workInProgress.stateNode; + var childrenUnchanged = workInProgress.firstEffect === null; + if (childrenUnchanged) { + // No changes, just reuse the existing instance. + } else { + var container = portalOrRoot.containerInfo; + var newChildSet = createContainerChildSet(container); + // If children might have changed, we have to add them all to the set. + appendAllChildrenToContainer(newChildSet, workInProgress); + portalOrRoot.pendingChildren = newChildSet; + // Schedule an update on the container to swap out the container. + markUpdate(workInProgress); + finalizeContainerChildren(container, newChildSet); + } + }; + updateHostComponent = function (current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) { + // If there are no effects associated with this node, then none of our children had any updates. + // This guarantees that we can reuse all of them. + var childrenUnchanged = workInProgress.firstEffect === null; + var currentInstance = current.stateNode; + if (childrenUnchanged && updatePayload === null) { + // No changes, just reuse the existing instance. + // Note that this might release a previous clone. + workInProgress.stateNode = currentInstance; + } else { + var recyclableInstance = workInProgress.stateNode; + var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance); + if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) { + markUpdate(workInProgress); + } + workInProgress.stateNode = newInstance; + if (childrenUnchanged) { + // If there are no other effects in this tree, we need to flag this node as having one. + // Even though we're not going to use it for anything. + // Otherwise parents won't know that there are new children to propagate upwards. + markUpdate(workInProgress); + } else { + // If children might have changed, we have to add them all to the set. + appendAllChildren(newInstance, workInProgress); + } + } + }; + updateHostText = function (current, workInProgress, oldText, newText) { + if (oldText !== newText) { + // If the text content differs, we'll create a new text instance for it. + var rootContainerInstance = getRootHostContainer(); + var currentHostContext = getHostContext(); + workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress); + // We'll have to mark it as having an effect, even though we won't use the effect for anything. + // This lets the parents know that at least one of their children has changed. + markUpdate(workInProgress); + } + }; + } else { + invariant_1(false, 'Persistent reconciler is disabled.'); + } + } else { + if (enableNoopReconciler) { + // No host operations + updateHostContainer = function (workInProgress) { + // Noop + }; + updateHostComponent = function (current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) { + // Noop + }; + updateHostText = function (current, workInProgress, oldText, newText) { + // Noop + }; + } else { + invariant_1(false, 'Noop reconciler is disabled.'); + } + } + + function completeWork(current, workInProgress, renderExpirationTime) { + var newProps = workInProgress.pendingProps; + switch (workInProgress.tag) { + case FunctionalComponent: + return null; + case ClassComponent: + { + // We are leaving this subtree, so pop context if any. + popLegacyContextProvider(workInProgress); + + // If this component caught an error, schedule an error log effect. + var instance = workInProgress.stateNode; + var updateQueue = workInProgress.updateQueue; + if (updateQueue !== null && updateQueue.capturedValues !== null) { + workInProgress.effectTag &= ~DidCapture; + if (typeof instance.componentDidCatch === 'function') { + workInProgress.effectTag |= ErrLog; + } else { + // Normally we clear this in the commit phase, but since we did not + // schedule an effect, we need to reset it here. + updateQueue.capturedValues = null; + } + } + return null; + } + case HostRoot: + { + popHostContainer(workInProgress); + popTopLevelLegacyContextObject(workInProgress); + var fiberRoot = workInProgress.stateNode; + if (fiberRoot.pendingContext) { + fiberRoot.context = fiberRoot.pendingContext; + fiberRoot.pendingContext = null; + } + if (current === null || current.child === null) { + // If we hydrated, pop so that we can delete any remaining children + // that weren't hydrated. + popHydrationState(workInProgress); + // This resets the hacky state to fix isMounted before committing. + // TODO: Delete this when we delete isMounted and findDOMNode. + workInProgress.effectTag &= ~Placement; + } + updateHostContainer(workInProgress); + + var _updateQueue = workInProgress.updateQueue; + if (_updateQueue !== null && _updateQueue.capturedValues !== null) { + workInProgress.effectTag |= ErrLog; + } + return null; + } + case HostComponent: + { + popHostContext(workInProgress); + var rootContainerInstance = getRootHostContainer(); + var type = workInProgress.type; + if (current !== null && workInProgress.stateNode != null) { + // If we have an alternate, that means this is an update and we need to + // schedule a side-effect to do the updates. + var oldProps = current.memoizedProps; + // If we get updated because one of our children updated, we don't + // have newProps so we'll have to reuse them. + // TODO: Split the update API as separate for the props vs. children. + // Even better would be if children weren't special cased at all tho. + var _instance = workInProgress.stateNode; + var currentHostContext = getHostContext(); + // TODO: Experiencing an error where oldProps is null. Suggests a host + // component is hitting the resume path. Figure out why. Possibly + // related to `hidden`. + var updatePayload = prepareUpdate(_instance, type, oldProps, newProps, rootContainerInstance, currentHostContext); + + updateHostComponent(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext); + + if (current.ref !== workInProgress.ref) { + markRef(workInProgress); + } + } else { + if (!newProps) { + !(workInProgress.stateNode !== null) ? invariant_1(false, 'We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.') : void 0; + // This can happen when we abort work. + return null; + } + + var _currentHostContext = getHostContext(); + // TODO: Move createInstance to beginWork and keep it on a context + // "stack" as the parent. Then append children as we go in beginWork + // or completeWork depending on we want to add then top->down or + // bottom->up. Top->down is faster in IE11. + var wasHydrated = popHydrationState(workInProgress); + if (wasHydrated) { + // TODO: Move this and createInstance step into the beginPhase + // to consolidate. + if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, _currentHostContext)) { + // If changes to the hydrated node needs to be applied at the + // commit-phase we mark this as such. + markUpdate(workInProgress); + } + } else { + var _instance2 = createInstance(type, newProps, rootContainerInstance, _currentHostContext, workInProgress); + + appendAllChildren(_instance2, workInProgress); + + // Certain renderers require commit-time effects for initial mount. + // (eg DOM renderer supports auto-focus for certain elements). + // Make sure such renderers get scheduled for later work. + if (finalizeInitialChildren(_instance2, type, newProps, rootContainerInstance, _currentHostContext)) { + markUpdate(workInProgress); + } + workInProgress.stateNode = _instance2; + } + + if (workInProgress.ref !== null) { + // If there is a ref on a host node we need to schedule a callback + markRef(workInProgress); + } + } + return null; + } + case HostText: + { + var newText = newProps; + if (current && workInProgress.stateNode != null) { + var oldText = current.memoizedProps; + // If we have an alternate, that means this is an update and we need + // to schedule a side-effect to do the updates. + updateHostText(current, workInProgress, oldText, newText); + } else { + if (typeof newText !== 'string') { + !(workInProgress.stateNode !== null) ? invariant_1(false, 'We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.') : void 0; + // This can happen when we abort work. + return null; + } + var _rootContainerInstance = getRootHostContainer(); + var _currentHostContext2 = getHostContext(); + var _wasHydrated = popHydrationState(workInProgress); + if (_wasHydrated) { + if (prepareToHydrateHostTextInstance(workInProgress)) { + markUpdate(workInProgress); + } + } else { + workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext2, workInProgress); + } + } + return null; + } + case CallComponent: + return moveCallToHandlerPhase(current, workInProgress, renderExpirationTime); + case CallHandlerPhase: + // Reset the tag to now be a first phase call. + workInProgress.tag = CallComponent; + return null; + case ReturnComponent: + // Does nothing. + return null; + case ForwardRef: + return null; + case Fragment: + return null; + case Mode: + return null; + case HostPortal: + popHostContainer(workInProgress); + updateHostContainer(workInProgress); + return null; + case ContextProvider: + // Pop provider fiber + popProvider(workInProgress); + return null; + case ContextConsumer: + return null; + // Error cases + case IndeterminateComponent: + invariant_1(false, 'An indeterminate component should have become determinate before completing. This error is likely caused by a bug in React. Please file an issue.'); + // eslint-disable-next-line no-fallthrough + default: + invariant_1(false, 'Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.'); + } + } + + return { + completeWork: completeWork + }; +}; + +function createCapturedValue(value, source) { + // If the value is an error, call this function immediately after it is thrown + // so the stack is accurate. + return { + value: value, + source: source, + stack: getStackAddendumByWorkInProgressFiber(source) + }; +} + +var ReactFiberUnwindWork = function (hostContext, legacyContext, newContext, scheduleWork, isAlreadyFailedLegacyErrorBoundary) { + var popHostContainer = hostContext.popHostContainer, + popHostContext = hostContext.popHostContext; + var popLegacyContextProvider = legacyContext.popContextProvider, + popTopLevelLegacyContextObject = legacyContext.popTopLevelContextObject; + var popProvider = newContext.popProvider; + + + function throwException(returnFiber, sourceFiber, rawValue) { + // The source fiber did not complete. + sourceFiber.effectTag |= Incomplete; + // Its effect list is no longer valid. + sourceFiber.firstEffect = sourceFiber.lastEffect = null; + + var value = createCapturedValue(rawValue, sourceFiber); + + var workInProgress = returnFiber; + do { + switch (workInProgress.tag) { + case HostRoot: + { + // Uncaught error + var errorInfo = value; + ensureUpdateQueues(workInProgress); + var updateQueue = workInProgress.updateQueue; + updateQueue.capturedValues = [errorInfo]; + workInProgress.effectTag |= ShouldCapture; + return; + } + case ClassComponent: + // Capture and retry + var ctor = workInProgress.type; + var _instance = workInProgress.stateNode; + if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromCatch === 'function' && enableGetDerivedStateFromCatch || _instance !== null && typeof _instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(_instance))) { + ensureUpdateQueues(workInProgress); + var _updateQueue = workInProgress.updateQueue; + var capturedValues = _updateQueue.capturedValues; + if (capturedValues === null) { + _updateQueue.capturedValues = [value]; + } else { + capturedValues.push(value); + } + workInProgress.effectTag |= ShouldCapture; + return; + } + break; + default: + break; + } + workInProgress = workInProgress['return']; + } while (workInProgress !== null); + } + + function unwindWork(workInProgress) { + switch (workInProgress.tag) { + case ClassComponent: + { + popLegacyContextProvider(workInProgress); + var effectTag = workInProgress.effectTag; + if (effectTag & ShouldCapture) { + workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture; + return workInProgress; + } + return null; + } + case HostRoot: + { + popHostContainer(workInProgress); + popTopLevelLegacyContextObject(workInProgress); + var _effectTag = workInProgress.effectTag; + if (_effectTag & ShouldCapture) { + workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture; + return workInProgress; + } + return null; + } + case HostComponent: + { + popHostContext(workInProgress); + return null; + } + case HostPortal: + popHostContainer(workInProgress); + return null; + case ContextProvider: + popProvider(workInProgress); + return null; + default: + return null; + } + } + + function unwindInterruptedWork(interruptedWork) { + switch (interruptedWork.tag) { + case ClassComponent: + { + popLegacyContextProvider(interruptedWork); + break; + } + case HostRoot: + { + popHostContainer(interruptedWork); + popTopLevelLegacyContextObject(interruptedWork); + break; + } + case HostComponent: + { + popHostContext(interruptedWork); + break; + } + case HostPortal: + popHostContainer(interruptedWork); + break; + case ContextProvider: + popProvider(interruptedWork); + break; + default: + break; + } + } + + return { + throwException: throwException, + unwindWork: unwindWork, + unwindInterruptedWork: unwindInterruptedWork + }; +}; + +// This module is forked in different environments. +// By default, return `true` to log errors to the console. +// Forks can return `false` if this isn't desirable. +function showErrorDialog(capturedError) { + return true; +} + +function logCapturedError(capturedError) { + var logError = showErrorDialog(capturedError); + + // Allow injected showErrorDialog() to prevent default console.error logging. + // This enables renderers like ReactNative to better manage redbox behavior. + if (logError === false) { + return; + } + + var error = capturedError.error; + var suppressLogging = error && error.suppressReactErrorLogging; + if (suppressLogging) { + return; + } + + { + var componentName = capturedError.componentName, + componentStack = capturedError.componentStack, + errorBoundaryName = capturedError.errorBoundaryName, + errorBoundaryFound = capturedError.errorBoundaryFound, + willRetry = capturedError.willRetry; + + + var componentNameMessage = componentName ? 'The above error occurred in the <' + componentName + '> component:' : 'The above error occurred in one of your React components:'; + + var errorBoundaryMessage = void 0; + // errorBoundaryFound check is sufficient; errorBoundaryName check is to satisfy Flow. + if (errorBoundaryFound && errorBoundaryName) { + if (willRetry) { + errorBoundaryMessage = 'React will try to recreate this component tree from scratch ' + ('using the error boundary you provided, ' + errorBoundaryName + '.'); + } else { + errorBoundaryMessage = 'This error was initially handled by the error boundary ' + errorBoundaryName + '.\n' + 'Recreating the tree from scratch failed so React will unmount the tree.'; + } + } else { + errorBoundaryMessage = 'Consider adding an error boundary to your tree to customize error handling behavior.\n' + 'Visit https://fb.me/react-error-boundaries to learn more about error boundaries.'; + } + var combinedMessage = '' + componentNameMessage + componentStack + '\n\n' + ('' + errorBoundaryMessage); + + // In development, we provide our own message with just the component stack. + // We don't include the original error message and JS stack because the browser + // has already printed it. Even if the application swallows the error, it is still + // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils. + console.error(combinedMessage); + } +} + +var invokeGuardedCallback$3 = ReactErrorUtils.invokeGuardedCallback; +var hasCaughtError$1 = ReactErrorUtils.hasCaughtError; +var clearCaughtError$1 = ReactErrorUtils.clearCaughtError; + + +var didWarnAboutUndefinedSnapshotBeforeUpdate = null; +{ + didWarnAboutUndefinedSnapshotBeforeUpdate = new Set(); +} + +function logError(boundary, errorInfo) { + var source = errorInfo.source; + var stack = errorInfo.stack; + if (stack === null) { + stack = getStackAddendumByWorkInProgressFiber(source); + } + + var capturedError = { + componentName: source !== null ? getComponentName(source) : null, + componentStack: stack !== null ? stack : '', + error: errorInfo.value, + errorBoundary: null, + errorBoundaryName: null, + errorBoundaryFound: false, + willRetry: false + }; + + if (boundary !== null && boundary.tag === ClassComponent) { + capturedError.errorBoundary = boundary.stateNode; + capturedError.errorBoundaryName = getComponentName(boundary); + capturedError.errorBoundaryFound = true; + capturedError.willRetry = true; + } + + try { + logCapturedError(capturedError); + } catch (e) { + // Prevent cycle if logCapturedError() throws. + // A cycle may still occur if logCapturedError renders a component that throws. + var suppressLogging = e && e.suppressReactErrorLogging; + if (!suppressLogging) { + console.error(e); + } + } +} + +var ReactFiberCommitWork = function (config, captureError, scheduleWork, computeExpirationForFiber, markLegacyErrorBoundaryAsFailed, recalculateCurrentTime) { + var getPublicInstance = config.getPublicInstance, + mutation = config.mutation, + persistence = config.persistence; + + + var callComponentWillUnmountWithTimer = function (current, instance) { + startPhaseTimer(current, 'componentWillUnmount'); + instance.props = current.memoizedProps; + instance.state = current.memoizedState; + instance.componentWillUnmount(); + stopPhaseTimer(); + }; + + // Capture errors so they don't interrupt unmounting. + function safelyCallComponentWillUnmount(current, instance) { + { + invokeGuardedCallback$3(null, callComponentWillUnmountWithTimer, null, current, instance); + if (hasCaughtError$1()) { + var unmountError = clearCaughtError$1(); + captureError(current, unmountError); + } + } + } + + function safelyDetachRef(current) { + var ref = current.ref; + if (ref !== null) { + if (typeof ref === 'function') { + { + invokeGuardedCallback$3(null, ref, null, null); + if (hasCaughtError$1()) { + var refError = clearCaughtError$1(); + captureError(current, refError); + } + } + } else { + ref.current = null; + } + } + } + + function commitBeforeMutationLifeCycles(current, finishedWork) { + switch (finishedWork.tag) { + case ClassComponent: + { + if (finishedWork.effectTag & Snapshot) { + if (current !== null) { + var prevProps = current.memoizedProps; + var prevState = current.memoizedState; + startPhaseTimer(finishedWork, 'getSnapshotBeforeUpdate'); + var _instance = finishedWork.stateNode; + _instance.props = finishedWork.memoizedProps; + _instance.state = finishedWork.memoizedState; + var snapshot = _instance.getSnapshotBeforeUpdate(prevProps, prevState); + { + var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate; + if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) { + didWarnSet.add(finishedWork.type); + warning_1(false, '%s.getSnapshotBeforeUpdate(): A snapshot value (or null) ' + 'must be returned. You have returned undefined.', getComponentName(finishedWork)); + } + } + _instance.__reactInternalSnapshotBeforeUpdate = snapshot; + stopPhaseTimer(); + } + } + return; + } + case HostRoot: + case HostComponent: + case HostText: + case HostPortal: + // Nothing to do for these component types + return; + default: + { + invariant_1(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.'); + } + } + } + + function commitLifeCycles(finishedRoot, current, finishedWork, currentTime, committedExpirationTime) { + switch (finishedWork.tag) { + case ClassComponent: + { + var _instance2 = finishedWork.stateNode; + if (finishedWork.effectTag & Update) { + if (current === null) { + startPhaseTimer(finishedWork, 'componentDidMount'); + _instance2.props = finishedWork.memoizedProps; + _instance2.state = finishedWork.memoizedState; + _instance2.componentDidMount(); + stopPhaseTimer(); + } else { + var prevProps = current.memoizedProps; + var prevState = current.memoizedState; + startPhaseTimer(finishedWork, 'componentDidUpdate'); + _instance2.props = finishedWork.memoizedProps; + _instance2.state = finishedWork.memoizedState; + _instance2.componentDidUpdate(prevProps, prevState, _instance2.__reactInternalSnapshotBeforeUpdate); + stopPhaseTimer(); + } + } + var updateQueue = finishedWork.updateQueue; + if (updateQueue !== null) { + commitCallbacks(updateQueue, _instance2); + } + return; + } + case HostRoot: + { + var _updateQueue = finishedWork.updateQueue; + if (_updateQueue !== null) { + var _instance3 = null; + if (finishedWork.child !== null) { + switch (finishedWork.child.tag) { + case HostComponent: + _instance3 = getPublicInstance(finishedWork.child.stateNode); + break; + case ClassComponent: + _instance3 = finishedWork.child.stateNode; + break; + } + } + commitCallbacks(_updateQueue, _instance3); + } + return; + } + case HostComponent: + { + var _instance4 = finishedWork.stateNode; + + // Renderers may schedule work to be done after host components are mounted + // (eg DOM renderer may schedule auto-focus for inputs and form controls). + // These effects should only be committed when components are first mounted, + // aka when there is no current/alternate. + if (current === null && finishedWork.effectTag & Update) { + var type = finishedWork.type; + var props = finishedWork.memoizedProps; + commitMount(_instance4, type, props, finishedWork); + } + + return; + } + case HostText: + { + // We have no life-cycles associated with text. + return; + } + case HostPortal: + { + // We have no life-cycles associated with portals. + return; + } + default: + { + invariant_1(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.'); + } + } + } + + function commitErrorLogging(finishedWork, onUncaughtError) { + switch (finishedWork.tag) { + case ClassComponent: + { + var ctor = finishedWork.type; + var _instance5 = finishedWork.stateNode; + var updateQueue = finishedWork.updateQueue; + !(updateQueue !== null && updateQueue.capturedValues !== null) ? invariant_1(false, 'An error logging effect should not have been scheduled if no errors were captured. This error is likely caused by a bug in React. Please file an issue.') : void 0; + var capturedErrors = updateQueue.capturedValues; + updateQueue.capturedValues = null; + + if (typeof ctor.getDerivedStateFromCatch !== 'function') { + // To preserve the preexisting retry behavior of error boundaries, + // we keep track of which ones already failed during this batch. + // This gets reset before we yield back to the browser. + // TODO: Warn in strict mode if getDerivedStateFromCatch is + // not defined. + markLegacyErrorBoundaryAsFailed(_instance5); + } + + _instance5.props = finishedWork.memoizedProps; + _instance5.state = finishedWork.memoizedState; + for (var i = 0; i < capturedErrors.length; i++) { + var errorInfo = capturedErrors[i]; + var _error = errorInfo.value; + var stack = errorInfo.stack; + logError(finishedWork, errorInfo); + _instance5.componentDidCatch(_error, { + componentStack: stack !== null ? stack : '' + }); + } + } + break; + case HostRoot: + { + var _updateQueue2 = finishedWork.updateQueue; + !(_updateQueue2 !== null && _updateQueue2.capturedValues !== null) ? invariant_1(false, 'An error logging effect should not have been scheduled if no errors were captured. This error is likely caused by a bug in React. Please file an issue.') : void 0; + var _capturedErrors = _updateQueue2.capturedValues; + _updateQueue2.capturedValues = null; + for (var _i = 0; _i < _capturedErrors.length; _i++) { + var _errorInfo = _capturedErrors[_i]; + logError(finishedWork, _errorInfo); + onUncaughtError(_errorInfo.value); + } + break; + } + default: + invariant_1(false, 'This unit of work tag cannot capture errors. This error is likely caused by a bug in React. Please file an issue.'); + } + } + + function commitAttachRef(finishedWork) { + var ref = finishedWork.ref; + if (ref !== null) { + var _instance6 = finishedWork.stateNode; + var instanceToUse = void 0; + switch (finishedWork.tag) { + case HostComponent: + instanceToUse = getPublicInstance(_instance6); + break; + default: + instanceToUse = _instance6; + } + if (typeof ref === 'function') { + ref(instanceToUse); + } else { + { + if (!ref.hasOwnProperty('current')) { + warning_1(false, 'Unexpected ref object provided for %s. ' + 'Use either a ref-setter function or React.createRef().%s', getComponentName(finishedWork), getStackAddendumByWorkInProgressFiber(finishedWork)); + } + } + + ref.current = instanceToUse; + } + } + } + + function commitDetachRef(current) { + var currentRef = current.ref; + if (currentRef !== null) { + if (typeof currentRef === 'function') { + currentRef(null); + } else { + currentRef.current = null; + } + } + } + + // User-originating errors (lifecycles and refs) should not interrupt + // deletion, so don't let them throw. Host-originating errors should + // interrupt deletion, so it's okay + function commitUnmount(current) { + if (typeof onCommitUnmount === 'function') { + onCommitUnmount(current); + } + + switch (current.tag) { + case ClassComponent: + { + safelyDetachRef(current); + var _instance7 = current.stateNode; + if (typeof _instance7.componentWillUnmount === 'function') { + safelyCallComponentWillUnmount(current, _instance7); + } + return; + } + case HostComponent: + { + safelyDetachRef(current); + return; + } + case CallComponent: + { + commitNestedUnmounts(current.stateNode); + return; + } + case HostPortal: + { + // TODO: this is recursive. + // We are also not using this parent because + // the portal will get pushed immediately. + if (enableMutatingReconciler && mutation) { + unmountHostComponents(current); + } else if (enablePersistentReconciler && persistence) { + emptyPortalContainer(current); + } + return; + } + } + } + + function commitNestedUnmounts(root) { + // While we're inside a removed host node we don't want to call + // removeChild on the inner nodes because they're removed by the top + // call anyway. We also want to call componentWillUnmount on all + // composites before this host node is removed from the tree. Therefore + var node = root; + while (true) { + commitUnmount(node); + // Visit children because they may contain more composite or host nodes. + // Skip portals because commitUnmount() currently visits them recursively. + if (node.child !== null && ( + // If we use mutation we drill down into portals using commitUnmount above. + // If we don't use mutation we drill down into portals here instead. + !mutation || node.tag !== HostPortal)) { + node.child['return'] = node; + node = node.child; + continue; + } + if (node === root) { + return; + } + while (node.sibling === null) { + if (node['return'] === null || node['return'] === root) { + return; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + } + + function detachFiber(current) { + // Cut off the return pointers to disconnect it from the tree. Ideally, we + // should clear the child pointer of the parent alternate to let this + // get GC:ed but we don't know which for sure which parent is the current + // one so we'll settle for GC:ing the subtree of this child. This child + // itself will be GC:ed when the parent updates the next time. + current['return'] = null; + current.child = null; + if (current.alternate) { + current.alternate.child = null; + current.alternate['return'] = null; + } + } + + var emptyPortalContainer = void 0; + + if (!mutation) { + var commitContainer = void 0; + if (persistence) { + var replaceContainerChildren = persistence.replaceContainerChildren, + createContainerChildSet = persistence.createContainerChildSet; + + emptyPortalContainer = function (current) { + var portal = current.stateNode; + var containerInfo = portal.containerInfo; + + var emptyChildSet = createContainerChildSet(containerInfo); + replaceContainerChildren(containerInfo, emptyChildSet); + }; + commitContainer = function (finishedWork) { + switch (finishedWork.tag) { + case ClassComponent: + { + return; + } + case HostComponent: + { + return; + } + case HostText: + { + return; + } + case HostRoot: + case HostPortal: + { + var portalOrRoot = finishedWork.stateNode; + var containerInfo = portalOrRoot.containerInfo, + _pendingChildren = portalOrRoot.pendingChildren; + + replaceContainerChildren(containerInfo, _pendingChildren); + return; + } + default: + { + invariant_1(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.'); + } + } + }; + } else { + commitContainer = function (finishedWork) { + // Noop + }; + } + if (enablePersistentReconciler || enableNoopReconciler) { + return { + commitResetTextContent: function (finishedWork) {}, + commitPlacement: function (finishedWork) {}, + commitDeletion: function (current) { + // Detach refs and call componentWillUnmount() on the whole subtree. + commitNestedUnmounts(current); + detachFiber(current); + }, + commitWork: function (current, finishedWork) { + commitContainer(finishedWork); + }, + + commitLifeCycles: commitLifeCycles, + commitBeforeMutationLifeCycles: commitBeforeMutationLifeCycles, + commitErrorLogging: commitErrorLogging, + commitAttachRef: commitAttachRef, + commitDetachRef: commitDetachRef + }; + } else if (persistence) { + invariant_1(false, 'Persistent reconciler is disabled.'); + } else { + invariant_1(false, 'Noop reconciler is disabled.'); + } + } + var commitMount = mutation.commitMount, + commitUpdate = mutation.commitUpdate, + resetTextContent = mutation.resetTextContent, + commitTextUpdate = mutation.commitTextUpdate, + appendChild = mutation.appendChild, + appendChildToContainer = mutation.appendChildToContainer, + insertBefore = mutation.insertBefore, + insertInContainerBefore = mutation.insertInContainerBefore, + removeChild = mutation.removeChild, + removeChildFromContainer = mutation.removeChildFromContainer; + + + function getHostParentFiber(fiber) { + var parent = fiber['return']; + while (parent !== null) { + if (isHostParent(parent)) { + return parent; + } + parent = parent['return']; + } + invariant_1(false, 'Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.'); + } + + function isHostParent(fiber) { + return fiber.tag === HostComponent || fiber.tag === HostRoot || fiber.tag === HostPortal; + } + + function getHostSibling(fiber) { + // We're going to search forward into the tree until we find a sibling host + // node. Unfortunately, if multiple insertions are done in a row we have to + // search past them. This leads to exponential search for the next sibling. + var node = fiber; + siblings: while (true) { + // If we didn't find anything, let's try the next sibling. + while (node.sibling === null) { + if (node['return'] === null || isHostParent(node['return'])) { + // If we pop out of the root or hit the parent the fiber we are the + // last sibling. + return null; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + while (node.tag !== HostComponent && node.tag !== HostText) { + // If it is not host node and, we might have a host node inside it. + // Try to search down until we find one. + if (node.effectTag & Placement) { + // If we don't have a child, try the siblings instead. + continue siblings; + } + // If we don't have a child, try the siblings instead. + // We also skip portals because they are not part of this host tree. + if (node.child === null || node.tag === HostPortal) { + continue siblings; + } else { + node.child['return'] = node; + node = node.child; + } + } + // Check if this host node is stable or about to be placed. + if (!(node.effectTag & Placement)) { + // Found it! + return node.stateNode; + } + } + } + + function commitPlacement(finishedWork) { + // Recursively insert all host nodes into the parent. + var parentFiber = getHostParentFiber(finishedWork); + var parent = void 0; + var isContainer = void 0; + switch (parentFiber.tag) { + case HostComponent: + parent = parentFiber.stateNode; + isContainer = false; + break; + case HostRoot: + parent = parentFiber.stateNode.containerInfo; + isContainer = true; + break; + case HostPortal: + parent = parentFiber.stateNode.containerInfo; + isContainer = true; + break; + default: + invariant_1(false, 'Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.'); + } + if (parentFiber.effectTag & ContentReset) { + // Reset the text content of the parent before doing any insertions + resetTextContent(parent); + // Clear ContentReset from the effect tag + parentFiber.effectTag &= ~ContentReset; + } + + var before = getHostSibling(finishedWork); + // We only have the top Fiber that was inserted but we need recurse down its + // children to find all the terminal nodes. + var node = finishedWork; + while (true) { + if (node.tag === HostComponent || node.tag === HostText) { + if (before) { + if (isContainer) { + insertInContainerBefore(parent, node.stateNode, before); + } else { + insertBefore(parent, node.stateNode, before); + } + } else { + if (isContainer) { + appendChildToContainer(parent, node.stateNode); + } else { + appendChild(parent, node.stateNode); + } + } + } else if (node.tag === HostPortal) { + // If the insertion itself is a portal, then we don't want to traverse + // down its children. Instead, we'll get insertions from each child in + // the portal directly. + } else if (node.child !== null) { + node.child['return'] = node; + node = node.child; + continue; + } + if (node === finishedWork) { + return; + } + while (node.sibling === null) { + if (node['return'] === null || node['return'] === finishedWork) { + return; + } + node = node['return']; + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + } + + function unmountHostComponents(current) { + // We only have the top Fiber that was inserted but we need recurse down its + var node = current; + + // Each iteration, currentParent is populated with node's host parent if not + // currentParentIsValid. + var currentParentIsValid = false; + var currentParent = void 0; + var currentParentIsContainer = void 0; + + while (true) { + if (!currentParentIsValid) { + var parent = node['return']; + findParent: while (true) { + !(parent !== null) ? invariant_1(false, 'Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.') : void 0; + switch (parent.tag) { + case HostComponent: + currentParent = parent.stateNode; + currentParentIsContainer = false; + break findParent; + case HostRoot: + currentParent = parent.stateNode.containerInfo; + currentParentIsContainer = true; + break findParent; + case HostPortal: + currentParent = parent.stateNode.containerInfo; + currentParentIsContainer = true; + break findParent; + } + parent = parent['return']; + } + currentParentIsValid = true; + } + + if (node.tag === HostComponent || node.tag === HostText) { + commitNestedUnmounts(node); + // After all the children have unmounted, it is now safe to remove the + // node from the tree. + if (currentParentIsContainer) { + removeChildFromContainer(currentParent, node.stateNode); + } else { + removeChild(currentParent, node.stateNode); + } + // Don't visit children because we already visited them. + } else if (node.tag === HostPortal) { + // When we go into a portal, it becomes the parent to remove from. + // We will reassign it back when we pop the portal on the way up. + currentParent = node.stateNode.containerInfo; + // Visit children because portals might contain host components. + if (node.child !== null) { + node.child['return'] = node; + node = node.child; + continue; + } + } else { + commitUnmount(node); + // Visit children because we may find more host components below. + if (node.child !== null) { + node.child['return'] = node; + node = node.child; + continue; + } + } + if (node === current) { + return; + } + while (node.sibling === null) { + if (node['return'] === null || node['return'] === current) { + return; + } + node = node['return']; + if (node.tag === HostPortal) { + // When we go out of the portal, we need to restore the parent. + // Since we don't keep a stack of them, we will search for it. + currentParentIsValid = false; + } + } + node.sibling['return'] = node['return']; + node = node.sibling; + } + } + + function commitDeletion(current) { + // Recursively delete all host nodes from the parent. + // Detach refs and call componentWillUnmount() on the whole subtree. + unmountHostComponents(current); + detachFiber(current); + } + + function commitWork(current, finishedWork) { + switch (finishedWork.tag) { + case ClassComponent: + { + return; + } + case HostComponent: + { + var _instance8 = finishedWork.stateNode; + if (_instance8 != null) { + // Commit the work prepared earlier. + var newProps = finishedWork.memoizedProps; + // For hydration we reuse the update path but we treat the oldProps + // as the newProps. The updatePayload will contain the real change in + // this case. + var oldProps = current !== null ? current.memoizedProps : newProps; + var type = finishedWork.type; + // TODO: Type the updateQueue to be specific to host components. + var updatePayload = finishedWork.updateQueue; + finishedWork.updateQueue = null; + if (updatePayload !== null) { + commitUpdate(_instance8, updatePayload, type, oldProps, newProps, finishedWork); + } + } + return; + } + case HostText: + { + !(finishedWork.stateNode !== null) ? invariant_1(false, 'This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.') : void 0; + var textInstance = finishedWork.stateNode; + var newText = finishedWork.memoizedProps; + // For hydration we reuse the update path but we treat the oldProps + // as the newProps. The updatePayload will contain the real change in + // this case. + var oldText = current !== null ? current.memoizedProps : newText; + commitTextUpdate(textInstance, oldText, newText); + return; + } + case HostRoot: + { + return; + } + default: + { + invariant_1(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.'); + } + } + } + + function commitResetTextContent(current) { + resetTextContent(current.stateNode); + } + + if (enableMutatingReconciler) { + return { + commitBeforeMutationLifeCycles: commitBeforeMutationLifeCycles, + commitResetTextContent: commitResetTextContent, + commitPlacement: commitPlacement, + commitDeletion: commitDeletion, + commitWork: commitWork, + commitLifeCycles: commitLifeCycles, + commitErrorLogging: commitErrorLogging, + commitAttachRef: commitAttachRef, + commitDetachRef: commitDetachRef + }; + } else { + invariant_1(false, 'Mutating reconciler is disabled.'); + } +}; + +var NO_CONTEXT = {}; + +var ReactFiberHostContext = function (config, stack) { + var getChildHostContext = config.getChildHostContext, + getRootHostContext = config.getRootHostContext; + var createCursor = stack.createCursor, + push = stack.push, + pop = stack.pop; + + + var contextStackCursor = createCursor(NO_CONTEXT); + var contextFiberStackCursor = createCursor(NO_CONTEXT); + var rootInstanceStackCursor = createCursor(NO_CONTEXT); + + function requiredContext(c) { + !(c !== NO_CONTEXT) ? invariant_1(false, 'Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.') : void 0; + return c; + } + + function getRootHostContainer() { + var rootInstance = requiredContext(rootInstanceStackCursor.current); + return rootInstance; + } + + function pushHostContainer(fiber, nextRootInstance) { + // Push current root instance onto the stack; + // This allows us to reset root when portals are popped. + push(rootInstanceStackCursor, nextRootInstance, fiber); + + var nextRootContext = getRootHostContext(nextRootInstance); + + // Track the context and the Fiber that provided it. + // This enables us to pop only Fibers that provide unique contexts. + push(contextFiberStackCursor, fiber, fiber); + push(contextStackCursor, nextRootContext, fiber); + } + + function popHostContainer(fiber) { + pop(contextStackCursor, fiber); + pop(contextFiberStackCursor, fiber); + pop(rootInstanceStackCursor, fiber); + } + + function getHostContext() { + var context = requiredContext(contextStackCursor.current); + return context; + } + + function pushHostContext(fiber) { + var rootInstance = requiredContext(rootInstanceStackCursor.current); + var context = requiredContext(contextStackCursor.current); + var nextContext = getChildHostContext(context, fiber.type, rootInstance); + + // Don't push this Fiber's context unless it's unique. + if (context === nextContext) { + return; + } + + // Track the context and the Fiber that provided it. + // This enables us to pop only Fibers that provide unique contexts. + push(contextFiberStackCursor, fiber, fiber); + push(contextStackCursor, nextContext, fiber); + } + + function popHostContext(fiber) { + // Do not pop unless this Fiber provided the current context. + // pushHostContext() only pushes Fibers that provide unique contexts. + if (contextFiberStackCursor.current !== fiber) { + return; + } + + pop(contextStackCursor, fiber); + pop(contextFiberStackCursor, fiber); + } + + return { + getHostContext: getHostContext, + getRootHostContainer: getRootHostContainer, + popHostContainer: popHostContainer, + popHostContext: popHostContext, + pushHostContainer: pushHostContainer, + pushHostContext: pushHostContext + }; +}; + +var ReactFiberHydrationContext = function (config) { + var shouldSetTextContent = config.shouldSetTextContent, + hydration = config.hydration; + + // If this doesn't have hydration mode. + + if (!hydration) { + return { + enterHydrationState: function () { + return false; + }, + resetHydrationState: function () {}, + tryToClaimNextHydratableInstance: function () {}, + prepareToHydrateHostInstance: function () { + invariant_1(false, 'Expected prepareToHydrateHostInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.'); + }, + prepareToHydrateHostTextInstance: function () { + invariant_1(false, 'Expected prepareToHydrateHostTextInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.'); + }, + popHydrationState: function (fiber) { + return false; + } + }; + } + + var canHydrateInstance = hydration.canHydrateInstance, + canHydrateTextInstance = hydration.canHydrateTextInstance, + getNextHydratableSibling = hydration.getNextHydratableSibling, + getFirstHydratableChild = hydration.getFirstHydratableChild, + hydrateInstance = hydration.hydrateInstance, + hydrateTextInstance = hydration.hydrateTextInstance, + didNotMatchHydratedContainerTextInstance = hydration.didNotMatchHydratedContainerTextInstance, + didNotMatchHydratedTextInstance = hydration.didNotMatchHydratedTextInstance, + didNotHydrateContainerInstance = hydration.didNotHydrateContainerInstance, + didNotHydrateInstance = hydration.didNotHydrateInstance, + didNotFindHydratableContainerInstance = hydration.didNotFindHydratableContainerInstance, + didNotFindHydratableContainerTextInstance = hydration.didNotFindHydratableContainerTextInstance, + didNotFindHydratableInstance = hydration.didNotFindHydratableInstance, + didNotFindHydratableTextInstance = hydration.didNotFindHydratableTextInstance; + + // The deepest Fiber on the stack involved in a hydration context. + // This may have been an insertion or a hydration. + + var hydrationParentFiber = null; + var nextHydratableInstance = null; + var isHydrating = false; + + function enterHydrationState(fiber) { + var parentInstance = fiber.stateNode.containerInfo; + nextHydratableInstance = getFirstHydratableChild(parentInstance); + hydrationParentFiber = fiber; + isHydrating = true; + return true; + } + + function deleteHydratableInstance(returnFiber, instance) { + { + switch (returnFiber.tag) { + case HostRoot: + didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance); + break; + case HostComponent: + didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance); + break; + } + } + + var childToDelete = createFiberFromHostInstanceForDeletion(); + childToDelete.stateNode = instance; + childToDelete['return'] = returnFiber; + childToDelete.effectTag = Deletion; + + // This might seem like it belongs on progressedFirstDeletion. However, + // these children are not part of the reconciliation list of children. + // Even if we abort and rereconcile the children, that will try to hydrate + // again and the nodes are still in the host tree so these will be + // recreated. + if (returnFiber.lastEffect !== null) { + returnFiber.lastEffect.nextEffect = childToDelete; + returnFiber.lastEffect = childToDelete; + } else { + returnFiber.firstEffect = returnFiber.lastEffect = childToDelete; + } + } + + function insertNonHydratedInstance(returnFiber, fiber) { + fiber.effectTag |= Placement; + { + switch (returnFiber.tag) { + case HostRoot: + { + var parentContainer = returnFiber.stateNode.containerInfo; + switch (fiber.tag) { + case HostComponent: + var type = fiber.type; + var props = fiber.pendingProps; + didNotFindHydratableContainerInstance(parentContainer, type, props); + break; + case HostText: + var text = fiber.pendingProps; + didNotFindHydratableContainerTextInstance(parentContainer, text); + break; + } + break; + } + case HostComponent: + { + var parentType = returnFiber.type; + var parentProps = returnFiber.memoizedProps; + var parentInstance = returnFiber.stateNode; + switch (fiber.tag) { + case HostComponent: + var _type = fiber.type; + var _props = fiber.pendingProps; + didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props); + break; + case HostText: + var _text = fiber.pendingProps; + didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text); + break; + } + break; + } + default: + return; + } + } + } + + function tryHydrate(fiber, nextInstance) { + switch (fiber.tag) { + case HostComponent: + { + var type = fiber.type; + var props = fiber.pendingProps; + var instance = canHydrateInstance(nextInstance, type, props); + if (instance !== null) { + fiber.stateNode = instance; + return true; + } + return false; + } + case HostText: + { + var text = fiber.pendingProps; + var textInstance = canHydrateTextInstance(nextInstance, text); + if (textInstance !== null) { + fiber.stateNode = textInstance; + return true; + } + return false; + } + default: + return false; + } + } + + function tryToClaimNextHydratableInstance(fiber) { + if (!isHydrating) { + return; + } + var nextInstance = nextHydratableInstance; + if (!nextInstance) { + // Nothing to hydrate. Make it an insertion. + insertNonHydratedInstance(hydrationParentFiber, fiber); + isHydrating = false; + hydrationParentFiber = fiber; + return; + } + if (!tryHydrate(fiber, nextInstance)) { + // If we can't hydrate this instance let's try the next one. + // We use this as a heuristic. It's based on intuition and not data so it + // might be flawed or unnecessary. + nextInstance = getNextHydratableSibling(nextInstance); + if (!nextInstance || !tryHydrate(fiber, nextInstance)) { + // Nothing to hydrate. Make it an insertion. + insertNonHydratedInstance(hydrationParentFiber, fiber); + isHydrating = false; + hydrationParentFiber = fiber; + return; + } + // We matched the next one, we'll now assume that the first one was + // superfluous and we'll delete it. Since we can't eagerly delete it + // we'll have to schedule a deletion. To do that, this node needs a dummy + // fiber associated with it. + deleteHydratableInstance(hydrationParentFiber, nextHydratableInstance); + } + hydrationParentFiber = fiber; + nextHydratableInstance = getFirstHydratableChild(nextInstance); + } + + function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) { + var instance = fiber.stateNode; + var updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, hostContext, fiber); + // TODO: Type this specific to this type of component. + fiber.updateQueue = updatePayload; + // If the update payload indicates that there is a change or if there + // is a new ref we mark this as an update. + if (updatePayload !== null) { + return true; + } + return false; + } + + function prepareToHydrateHostTextInstance(fiber) { + var textInstance = fiber.stateNode; + var textContent = fiber.memoizedProps; + var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber); + { + if (shouldUpdate) { + // We assume that prepareToHydrateHostTextInstance is called in a context where the + // hydration parent is the parent host component of this host text. + var returnFiber = hydrationParentFiber; + if (returnFiber !== null) { + switch (returnFiber.tag) { + case HostRoot: + { + var parentContainer = returnFiber.stateNode.containerInfo; + didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent); + break; + } + case HostComponent: + { + var parentType = returnFiber.type; + var parentProps = returnFiber.memoizedProps; + var parentInstance = returnFiber.stateNode; + didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent); + break; + } + } + } + } + } + return shouldUpdate; + } + + function popToNextHostParent(fiber) { + var parent = fiber['return']; + while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot) { + parent = parent['return']; + } + hydrationParentFiber = parent; + } + + function popHydrationState(fiber) { + if (fiber !== hydrationParentFiber) { + // We're deeper than the current hydration context, inside an inserted + // tree. + return false; + } + if (!isHydrating) { + // If we're not currently hydrating but we're in a hydration context, then + // we were an insertion and now need to pop up reenter hydration of our + // siblings. + popToNextHostParent(fiber); + isHydrating = true; + return false; + } + + var type = fiber.type; + + // If we have any remaining hydratable nodes, we need to delete them now. + // We only do this deeper than head and body since they tend to have random + // other nodes in them. We also ignore components with pure text content in + // side of them. + // TODO: Better heuristic. + if (fiber.tag !== HostComponent || type !== 'head' && type !== 'body' && !shouldSetTextContent(type, fiber.memoizedProps)) { + var nextInstance = nextHydratableInstance; + while (nextInstance) { + deleteHydratableInstance(fiber, nextInstance); + nextInstance = getNextHydratableSibling(nextInstance); + } + } + + popToNextHostParent(fiber); + nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null; + return true; + } + + function resetHydrationState() { + hydrationParentFiber = null; + nextHydratableInstance = null; + isHydrating = false; + } + + return { + enterHydrationState: enterHydrationState, + resetHydrationState: resetHydrationState, + tryToClaimNextHydratableInstance: tryToClaimNextHydratableInstance, + prepareToHydrateHostInstance: prepareToHydrateHostInstance, + prepareToHydrateHostTextInstance: prepareToHydrateHostTextInstance, + popHydrationState: popHydrationState + }; +}; + +// This lets us hook into Fiber to debug what it's doing. +// See https://github.com/facebook/react/pull/8033. +// This is not part of the public API, not even for React DevTools. +// You may only inject a debugTool if you work on React Fiber itself. +var ReactFiberInstrumentation = { + debugTool: null +}; + +var ReactFiberInstrumentation_1 = ReactFiberInstrumentation; + +var warnedAboutMissingGetChildContext = void 0; + +{ + warnedAboutMissingGetChildContext = {}; +} + +var ReactFiberLegacyContext = function (stack) { + var createCursor = stack.createCursor, + push = stack.push, + pop = stack.pop; + + // A cursor to the current merged context object on the stack. + + var contextStackCursor = createCursor(emptyObject_1); + // A cursor to a boolean indicating whether the context has changed. + var didPerformWorkStackCursor = createCursor(false); + // Keep track of the previous context object that was on the stack. + // We use this to get access to the parent context after we have already + // pushed the next context provider, and now need to merge their contexts. + var previousContext = emptyObject_1; + + function getUnmaskedContext(workInProgress) { + var hasOwnContext = isContextProvider(workInProgress); + if (hasOwnContext) { + // If the fiber is a context provider itself, when we read its context + // we have already pushed its own child context on the stack. A context + // provider should not "see" its own child context. Therefore we read the + // previous (parent) context instead for a context provider. + return previousContext; + } + return contextStackCursor.current; + } + + function cacheContext(workInProgress, unmaskedContext, maskedContext) { + var instance = workInProgress.stateNode; + instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext; + instance.__reactInternalMemoizedMaskedChildContext = maskedContext; + } + + function getMaskedContext(workInProgress, unmaskedContext) { + var type = workInProgress.type; + var contextTypes = type.contextTypes; + if (!contextTypes) { + return emptyObject_1; + } + + // Avoid recreating masked context unless unmasked context has changed. + // Failing to do this will result in unnecessary calls to componentWillReceiveProps. + // This may trigger infinite loops if componentWillReceiveProps calls setState. + var instance = workInProgress.stateNode; + if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) { + return instance.__reactInternalMemoizedMaskedChildContext; + } + + var context = {}; + for (var key in contextTypes) { + context[key] = unmaskedContext[key]; + } + + { + var name = getComponentName(workInProgress) || 'Unknown'; + checkPropTypes_1(contextTypes, context, 'context', name, ReactDebugCurrentFiber.getCurrentFiberStackAddendum); + } + + // Cache unmasked context so we can avoid recreating masked context unless necessary. + // Context is created before the class component is instantiated so check for instance. + if (instance) { + cacheContext(workInProgress, unmaskedContext, context); + } + + return context; + } + + function hasContextChanged() { + return didPerformWorkStackCursor.current; + } + + function isContextConsumer(fiber) { + return fiber.tag === ClassComponent && fiber.type.contextTypes != null; + } + + function isContextProvider(fiber) { + return fiber.tag === ClassComponent && fiber.type.childContextTypes != null; + } + + function popContextProvider(fiber) { + if (!isContextProvider(fiber)) { + return; + } + + pop(didPerformWorkStackCursor, fiber); + pop(contextStackCursor, fiber); + } + + function popTopLevelContextObject(fiber) { + pop(didPerformWorkStackCursor, fiber); + pop(contextStackCursor, fiber); + } + + function pushTopLevelContextObject(fiber, context, didChange) { + !(contextStackCursor.cursor == null) ? invariant_1(false, 'Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.') : void 0; + + push(contextStackCursor, context, fiber); + push(didPerformWorkStackCursor, didChange, fiber); + } + + function processChildContext(fiber, parentContext) { + var instance = fiber.stateNode; + var childContextTypes = fiber.type.childContextTypes; + + // TODO (bvaughn) Replace this behavior with an invariant() in the future. + // It has only been added in Fiber to match the (unintentional) behavior in Stack. + if (typeof instance.getChildContext !== 'function') { + { + var componentName = getComponentName(fiber) || 'Unknown'; + + if (!warnedAboutMissingGetChildContext[componentName]) { + warnedAboutMissingGetChildContext[componentName] = true; + warning_1(false, '%s.childContextTypes is specified but there is no getChildContext() method ' + 'on the instance. You can either define getChildContext() on %s or remove ' + 'childContextTypes from it.', componentName, componentName); + } + } + return parentContext; + } + + var childContext = void 0; + { + ReactDebugCurrentFiber.setCurrentPhase('getChildContext'); + } + startPhaseTimer(fiber, 'getChildContext'); + childContext = instance.getChildContext(); + stopPhaseTimer(); + { + ReactDebugCurrentFiber.setCurrentPhase(null); + } + for (var contextKey in childContext) { + !(contextKey in childContextTypes) ? invariant_1(false, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(fiber) || 'Unknown', contextKey) : void 0; + } + { + var name = getComponentName(fiber) || 'Unknown'; + checkPropTypes_1(childContextTypes, childContext, 'child context', name, + // In practice, there is one case in which we won't get a stack. It's when + // somebody calls unstable_renderSubtreeIntoContainer() and we process + // context from the parent component instance. The stack will be missing + // because it's outside of the reconciliation, and so the pointer has not + // been set. This is rare and doesn't matter. We'll also remove that API. + ReactDebugCurrentFiber.getCurrentFiberStackAddendum); + } + + return _assign({}, parentContext, childContext); + } + + function pushContextProvider(workInProgress) { + if (!isContextProvider(workInProgress)) { + return false; + } + + var instance = workInProgress.stateNode; + // We push the context as early as possible to ensure stack integrity. + // If the instance does not exist yet, we will push null at first, + // and replace it on the stack later when invalidating the context. + var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject_1; + + // Remember the parent context so we can merge with it later. + // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates. + previousContext = contextStackCursor.current; + push(contextStackCursor, memoizedMergedChildContext, workInProgress); + push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress); + + return true; + } + + function invalidateContextProvider(workInProgress, didChange) { + var instance = workInProgress.stateNode; + !instance ? invariant_1(false, 'Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.') : void 0; + + if (didChange) { + // Merge parent and own context. + // Skip this if we're not updating due to sCU. + // This avoids unnecessarily recomputing memoized values. + var mergedContext = processChildContext(workInProgress, previousContext); + instance.__reactInternalMemoizedMergedChildContext = mergedContext; + + // Replace the old (or empty) context with the new one. + // It is important to unwind the context in the reverse order. + pop(didPerformWorkStackCursor, workInProgress); + pop(contextStackCursor, workInProgress); + // Now push the new context and mark that it has changed. + push(contextStackCursor, mergedContext, workInProgress); + push(didPerformWorkStackCursor, didChange, workInProgress); + } else { + pop(didPerformWorkStackCursor, workInProgress); + push(didPerformWorkStackCursor, didChange, workInProgress); + } + } + + function findCurrentUnmaskedContext(fiber) { + // Currently this is only used with renderSubtreeIntoContainer; not sure if it + // makes sense elsewhere + !(isFiberMounted(fiber) && fiber.tag === ClassComponent) ? invariant_1(false, 'Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.') : void 0; + + var node = fiber; + while (node.tag !== HostRoot) { + if (isContextProvider(node)) { + return node.stateNode.__reactInternalMemoizedMergedChildContext; + } + var parent = node['return']; + !parent ? invariant_1(false, 'Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.') : void 0; + node = parent; + } + return node.stateNode.context; + } + + return { + getUnmaskedContext: getUnmaskedContext, + cacheContext: cacheContext, + getMaskedContext: getMaskedContext, + hasContextChanged: hasContextChanged, + isContextConsumer: isContextConsumer, + isContextProvider: isContextProvider, + popContextProvider: popContextProvider, + popTopLevelContextObject: popTopLevelContextObject, + pushTopLevelContextObject: pushTopLevelContextObject, + processChildContext: processChildContext, + pushContextProvider: pushContextProvider, + invalidateContextProvider: invalidateContextProvider, + findCurrentUnmaskedContext: findCurrentUnmaskedContext + }; +}; + +var ReactFiberNewContext = function (stack) { + var createCursor = stack.createCursor, + push = stack.push, + pop = stack.pop; + + + var providerCursor = createCursor(null); + var valueCursor = createCursor(null); + var changedBitsCursor = createCursor(0); + + var rendererSigil = void 0; + { + // Use this to detect multiple renderers using the same context + rendererSigil = {}; + } + + function pushProvider(providerFiber) { + var context = providerFiber.type.context; + + push(changedBitsCursor, context._changedBits, providerFiber); + push(valueCursor, context._currentValue, providerFiber); + push(providerCursor, providerFiber, providerFiber); + + context._currentValue = providerFiber.pendingProps.value; + context._changedBits = providerFiber.stateNode; + + { + warning_1(context._currentRenderer === null || context._currentRenderer === rendererSigil, 'Detected multiple renderers concurrently rendering the ' + 'same context provider. This is currently unsupported.'); + context._currentRenderer = rendererSigil; + } + } + + function popProvider(providerFiber) { + var changedBits = changedBitsCursor.current; + var currentValue = valueCursor.current; + + pop(providerCursor, providerFiber); + pop(valueCursor, providerFiber); + pop(changedBitsCursor, providerFiber); + + var context = providerFiber.type.context; + context._currentValue = currentValue; + context._changedBits = changedBits; + } + + return { + pushProvider: pushProvider, + popProvider: popProvider + }; +}; + +var ReactFiberStack = function () { + var valueStack = []; + + var fiberStack = void 0; + + { + fiberStack = []; + } + + var index = -1; + + function createCursor(defaultValue) { + return { + current: defaultValue + }; + } + + function isEmpty() { + return index === -1; + } + + function pop(cursor, fiber) { + if (index < 0) { + { + warning_1(false, 'Unexpected pop.'); + } + return; + } + + { + if (fiber !== fiberStack[index]) { + warning_1(false, 'Unexpected Fiber popped.'); + } + } + + cursor.current = valueStack[index]; + + valueStack[index] = null; + + { + fiberStack[index] = null; + } + + index--; + } + + function push(cursor, value, fiber) { + index++; + + valueStack[index] = cursor.current; + + { + fiberStack[index] = fiber; + } + + cursor.current = value; + } + + function checkThatStackIsEmpty() { + { + if (index !== -1) { + warning_1(false, 'Expected an empty stack. Something was not reset properly.'); + } + } + } + + function resetStackAfterFatalErrorInDev() { + { + index = -1; + valueStack.length = 0; + fiberStack.length = 0; + } + } + + return { + createCursor: createCursor, + isEmpty: isEmpty, + pop: pop, + push: push, + checkThatStackIsEmpty: checkThatStackIsEmpty, + resetStackAfterFatalErrorInDev: resetStackAfterFatalErrorInDev + }; +}; + +var invokeGuardedCallback$2 = ReactErrorUtils.invokeGuardedCallback; +var hasCaughtError = ReactErrorUtils.hasCaughtError; +var clearCaughtError = ReactErrorUtils.clearCaughtError; + + +var didWarnAboutStateTransition = void 0; +var didWarnSetStateChildContext = void 0; +var warnAboutUpdateOnUnmounted = void 0; +var warnAboutInvalidUpdates = void 0; + +{ + didWarnAboutStateTransition = false; + didWarnSetStateChildContext = false; + var didWarnStateUpdateForUnmountedComponent = {}; + + warnAboutUpdateOnUnmounted = function (fiber) { + // We show the whole stack but dedupe on the top component's name because + // the problematic code almost always lies inside that component. + var componentName = getComponentName(fiber) || 'ReactClass'; + if (didWarnStateUpdateForUnmountedComponent[componentName]) { + return; + } + warning_1(false, "Can't call setState (or forceUpdate) on an unmounted component. This " + 'is a no-op, but it indicates a memory leak in your application. To ' + 'fix, cancel all subscriptions and asynchronous tasks in the ' + 'componentWillUnmount method.%s', getStackAddendumByWorkInProgressFiber(fiber)); + didWarnStateUpdateForUnmountedComponent[componentName] = true; + }; + + warnAboutInvalidUpdates = function (instance) { + switch (ReactDebugCurrentFiber.phase) { + case 'getChildContext': + if (didWarnSetStateChildContext) { + return; + } + warning_1(false, 'setState(...): Cannot call setState() inside getChildContext()'); + didWarnSetStateChildContext = true; + break; + case 'render': + if (didWarnAboutStateTransition) { + return; + } + warning_1(false, 'Cannot update during an existing state transition (such as within ' + "`render` or another component's constructor). Render methods should " + 'be a pure function of props and state; constructor side-effects are ' + 'an anti-pattern, but can be moved to `componentWillMount`.'); + didWarnAboutStateTransition = true; + break; + } + }; +} + +var ReactFiberScheduler = function (config) { + var stack = ReactFiberStack(); + var hostContext = ReactFiberHostContext(config, stack); + var legacyContext = ReactFiberLegacyContext(stack); + var newContext = ReactFiberNewContext(stack); + var popHostContext = hostContext.popHostContext, + popHostContainer = hostContext.popHostContainer; + var popTopLevelLegacyContextObject = legacyContext.popTopLevelContextObject, + popLegacyContextProvider = legacyContext.popContextProvider; + var popProvider = newContext.popProvider; + + var hydrationContext = ReactFiberHydrationContext(config); + + var _ReactFiberBeginWork = ReactFiberBeginWork(config, hostContext, legacyContext, newContext, hydrationContext, scheduleWork, computeExpirationForFiber), + beginWork = _ReactFiberBeginWork.beginWork; + + var _ReactFiberCompleteWo = ReactFiberCompleteWork(config, hostContext, legacyContext, newContext, hydrationContext), + completeWork = _ReactFiberCompleteWo.completeWork; + + var _ReactFiberUnwindWork = ReactFiberUnwindWork(hostContext, legacyContext, newContext, scheduleWork, isAlreadyFailedLegacyErrorBoundary), + throwException = _ReactFiberUnwindWork.throwException, + unwindWork = _ReactFiberUnwindWork.unwindWork, + unwindInterruptedWork = _ReactFiberUnwindWork.unwindInterruptedWork; + + var _ReactFiberCommitWork = ReactFiberCommitWork(config, onCommitPhaseError, scheduleWork, computeExpirationForFiber, markLegacyErrorBoundaryAsFailed, recalculateCurrentTime), + commitBeforeMutationLifeCycles = _ReactFiberCommitWork.commitBeforeMutationLifeCycles, + commitResetTextContent = _ReactFiberCommitWork.commitResetTextContent, + commitPlacement = _ReactFiberCommitWork.commitPlacement, + commitDeletion = _ReactFiberCommitWork.commitDeletion, + commitWork = _ReactFiberCommitWork.commitWork, + commitLifeCycles = _ReactFiberCommitWork.commitLifeCycles, + commitErrorLogging = _ReactFiberCommitWork.commitErrorLogging, + commitAttachRef = _ReactFiberCommitWork.commitAttachRef, + commitDetachRef = _ReactFiberCommitWork.commitDetachRef; + + var now = config.now, + scheduleDeferredCallback = config.scheduleDeferredCallback, + cancelDeferredCallback = config.cancelDeferredCallback, + prepareForCommit = config.prepareForCommit, + resetAfterCommit = config.resetAfterCommit; + + // Represents the current time in ms. + + var originalStartTimeMs = now(); + var mostRecentCurrentTime = msToExpirationTime(0); + var mostRecentCurrentTimeMs = originalStartTimeMs; + + // Used to ensure computeUniqueAsyncExpiration is monotonically increases. + var lastUniqueAsyncExpiration = 0; + + // Represents the expiration time that incoming updates should use. (If this + // is NoWork, use the default strategy: async updates in async mode, sync + // updates in sync mode.) + var expirationContext = NoWork; + + var isWorking = false; + + // The next work in progress fiber that we're currently working on. + var nextUnitOfWork = null; + var nextRoot = null; + // The time at which we're currently rendering work. + var nextRenderExpirationTime = NoWork; + + // The next fiber with an effect that we're currently committing. + var nextEffect = null; + + var isCommitting = false; + + var isRootReadyForCommit = false; + + var legacyErrorBoundariesThatAlreadyFailed = null; + + // Used for performance tracking. + var interruptedBy = null; + + var stashedWorkInProgressProperties = void 0; + var replayUnitOfWork = void 0; + if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) { + stashedWorkInProgressProperties = null; + replayUnitOfWork = function (failedUnitOfWork, isAsync) { + // Retore the original state of the work-in-progress + _assign(failedUnitOfWork, stashedWorkInProgressProperties); + switch (failedUnitOfWork.tag) { + case HostRoot: + popHostContainer(failedUnitOfWork); + popTopLevelLegacyContextObject(failedUnitOfWork); + break; + case HostComponent: + popHostContext(failedUnitOfWork); + break; + case ClassComponent: + popLegacyContextProvider(failedUnitOfWork); + break; + case HostPortal: + popHostContainer(failedUnitOfWork); + break; + case ContextProvider: + popProvider(failedUnitOfWork); + break; + } + // Replay the begin phase. + invokeGuardedCallback$2(null, workLoop, null, isAsync); + if (hasCaughtError()) { + clearCaughtError(); + } else { + // This should be unreachable because the render phase is + // idempotent + } + }; + } + + function resetStack() { + if (nextUnitOfWork !== null) { + var interruptedWork = nextUnitOfWork['return']; + while (interruptedWork !== null) { + unwindInterruptedWork(interruptedWork); + interruptedWork = interruptedWork['return']; + } + } + + { + ReactStrictModeWarnings.discardPendingWarnings(); + stack.checkThatStackIsEmpty(); + } + + nextRoot = null; + nextRenderExpirationTime = NoWork; + nextUnitOfWork = null; + + isRootReadyForCommit = false; + } + + function commitAllHostEffects() { + while (nextEffect !== null) { + { + ReactDebugCurrentFiber.setCurrentFiber(nextEffect); + } + recordEffect(); + + var effectTag = nextEffect.effectTag; + + if (effectTag & ContentReset) { + commitResetTextContent(nextEffect); + } + + if (effectTag & Ref) { + var current = nextEffect.alternate; + if (current !== null) { + commitDetachRef(current); + } + } + + // The following switch statement is only concerned about placement, + // updates, and deletions. To avoid needing to add a case for every + // possible bitmap value, we remove the secondary effects from the + // effect tag and switch on that value. + var primaryEffectTag = effectTag & (Placement | Update | Deletion); + switch (primaryEffectTag) { + case Placement: + { + commitPlacement(nextEffect); + // Clear the "placement" from effect tag so that we know that this is inserted, before + // any life-cycles like componentDidMount gets called. + // TODO: findDOMNode doesn't rely on this any more but isMounted + // does and isMounted is deprecated anyway so we should be able + // to kill this. + nextEffect.effectTag &= ~Placement; + break; + } + case PlacementAndUpdate: + { + // Placement + commitPlacement(nextEffect); + // Clear the "placement" from effect tag so that we know that this is inserted, before + // any life-cycles like componentDidMount gets called. + nextEffect.effectTag &= ~Placement; + + // Update + var _current = nextEffect.alternate; + commitWork(_current, nextEffect); + break; + } + case Update: + { + var _current2 = nextEffect.alternate; + commitWork(_current2, nextEffect); + break; + } + case Deletion: + { + commitDeletion(nextEffect); + break; + } + } + nextEffect = nextEffect.nextEffect; + } + + { + ReactDebugCurrentFiber.resetCurrentFiber(); + } + } + + function commitBeforeMutationLifecycles() { + while (nextEffect !== null) { + var effectTag = nextEffect.effectTag; + + if (effectTag & Snapshot) { + recordEffect(); + var current = nextEffect.alternate; + commitBeforeMutationLifeCycles(current, nextEffect); + } + + // Don't cleanup effects yet; + // This will be done by commitAllLifeCycles() + nextEffect = nextEffect.nextEffect; + } + } + + function commitAllLifeCycles(finishedRoot, currentTime, committedExpirationTime) { + { + ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings(); + + if (warnAboutDeprecatedLifecycles) { + ReactStrictModeWarnings.flushPendingDeprecationWarnings(); + } + } + while (nextEffect !== null) { + var effectTag = nextEffect.effectTag; + + if (effectTag & (Update | Callback)) { + recordEffect(); + var current = nextEffect.alternate; + commitLifeCycles(finishedRoot, current, nextEffect, currentTime, committedExpirationTime); + } + + if (effectTag & ErrLog) { + commitErrorLogging(nextEffect, onUncaughtError); + } + + if (effectTag & Ref) { + recordEffect(); + commitAttachRef(nextEffect); + } + + var next = nextEffect.nextEffect; + // Ensure that we clean these up so that we don't accidentally keep them. + // I'm not actually sure this matters because we can't reset firstEffect + // and lastEffect since they're on every node, not just the effectful + // ones. So we have to clean everything as we reuse nodes anyway. + nextEffect.nextEffect = null; + // Ensure that we reset the effectTag here so that we can rely on effect + // tags to reason about the current life-cycle. + nextEffect = next; + } + } + + function isAlreadyFailedLegacyErrorBoundary(instance) { + return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance); + } + + function markLegacyErrorBoundaryAsFailed(instance) { + if (legacyErrorBoundariesThatAlreadyFailed === null) { + legacyErrorBoundariesThatAlreadyFailed = new Set([instance]); + } else { + legacyErrorBoundariesThatAlreadyFailed.add(instance); + } + } + + function commitRoot(finishedWork) { + isWorking = true; + isCommitting = true; + startCommitTimer(); + + var root = finishedWork.stateNode; + !(root.current !== finishedWork) ? invariant_1(false, 'Cannot commit the same tree as before. This is probably a bug related to the return field. This error is likely caused by a bug in React. Please file an issue.') : void 0; + var committedExpirationTime = root.pendingCommitExpirationTime; + !(committedExpirationTime !== NoWork) ? invariant_1(false, 'Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.') : void 0; + root.pendingCommitExpirationTime = NoWork; + + var currentTime = recalculateCurrentTime(); + + // Reset this to null before calling lifecycles + ReactCurrentOwner.current = null; + + var firstEffect = void 0; + if (finishedWork.effectTag > PerformedWork) { + // A fiber's effect list consists only of its children, not itself. So if + // the root has an effect, we need to add it to the end of the list. The + // resulting list is the set that would belong to the root's parent, if + // it had one; that is, all the effects in the tree including the root. + if (finishedWork.lastEffect !== null) { + finishedWork.lastEffect.nextEffect = finishedWork; + firstEffect = finishedWork.firstEffect; + } else { + firstEffect = finishedWork; + } + } else { + // There is no effect on the root. + firstEffect = finishedWork.firstEffect; + } + + prepareForCommit(root.containerInfo); + + // Invoke instances of getSnapshotBeforeUpdate before mutation. + nextEffect = firstEffect; + startCommitSnapshotEffectsTimer(); + while (nextEffect !== null) { + var didError = false; + var error = void 0; + { + invokeGuardedCallback$2(null, commitBeforeMutationLifecycles, null); + if (hasCaughtError()) { + didError = true; + error = clearCaughtError(); + } + } + if (didError) { + !(nextEffect !== null) ? invariant_1(false, 'Should have next effect. This error is likely caused by a bug in React. Please file an issue.') : void 0; + onCommitPhaseError(nextEffect, error); + // Clean-up + if (nextEffect !== null) { + nextEffect = nextEffect.nextEffect; + } + } + } + stopCommitSnapshotEffectsTimer(); + + // Commit all the side-effects within a tree. We'll do this in two passes. + // The first pass performs all the host insertions, updates, deletions and + // ref unmounts. + nextEffect = firstEffect; + startCommitHostEffectsTimer(); + while (nextEffect !== null) { + var _didError = false; + var _error = void 0; + { + invokeGuardedCallback$2(null, commitAllHostEffects, null); + if (hasCaughtError()) { + _didError = true; + _error = clearCaughtError(); + } + } + if (_didError) { + !(nextEffect !== null) ? invariant_1(false, 'Should have next effect. This error is likely caused by a bug in React. Please file an issue.') : void 0; + onCommitPhaseError(nextEffect, _error); + // Clean-up + if (nextEffect !== null) { + nextEffect = nextEffect.nextEffect; + } + } + } + stopCommitHostEffectsTimer(); + + resetAfterCommit(root.containerInfo); + + // The work-in-progress tree is now the current tree. This must come after + // the first pass of the commit phase, so that the previous tree is still + // current during componentWillUnmount, but before the second pass, so that + // the finished work is current during componentDidMount/Update. + root.current = finishedWork; + + // In the second pass we'll perform all life-cycles and ref callbacks. + // Life-cycles happen as a separate pass so that all placements, updates, + // and deletions in the entire tree have already been invoked. + // This pass also triggers any renderer-specific initial effects. + nextEffect = firstEffect; + startCommitLifeCyclesTimer(); + while (nextEffect !== null) { + var _didError2 = false; + var _error2 = void 0; + { + invokeGuardedCallback$2(null, commitAllLifeCycles, null, root, currentTime, committedExpirationTime); + if (hasCaughtError()) { + _didError2 = true; + _error2 = clearCaughtError(); + } + } + if (_didError2) { + !(nextEffect !== null) ? invariant_1(false, 'Should have next effect. This error is likely caused by a bug in React. Please file an issue.') : void 0; + onCommitPhaseError(nextEffect, _error2); + if (nextEffect !== null) { + nextEffect = nextEffect.nextEffect; + } + } + } + + isCommitting = false; + isWorking = false; + stopCommitLifeCyclesTimer(); + stopCommitTimer(); + if (typeof onCommitRoot === 'function') { + onCommitRoot(finishedWork.stateNode); + } + if (true && ReactFiberInstrumentation_1.debugTool) { + ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork); + } + + var remainingTime = root.current.expirationTime; + if (remainingTime === NoWork) { + // If there's no remaining work, we can clear the set of already failed + // error boundaries. + legacyErrorBoundariesThatAlreadyFailed = null; + } + return remainingTime; + } + + function resetExpirationTime(workInProgress, renderTime) { + if (renderTime !== Never && workInProgress.expirationTime === Never) { + // The children of this component are hidden. Don't bubble their + // expiration times. + return; + } + + // Check for pending updates. + var newExpirationTime = getUpdateExpirationTime(workInProgress); + + // TODO: Calls need to visit stateNode + + // Bubble up the earliest expiration time. + var child = workInProgress.child; + while (child !== null) { + if (child.expirationTime !== NoWork && (newExpirationTime === NoWork || newExpirationTime > child.expirationTime)) { + newExpirationTime = child.expirationTime; + } + child = child.sibling; + } + workInProgress.expirationTime = newExpirationTime; + } + + function completeUnitOfWork(workInProgress) { + // Attempt to complete the current unit of work, then move to the + // next sibling. If there are no more siblings, return to the + // parent fiber. + while (true) { + // The current, flushed, state of this fiber is the alternate. + // Ideally nothing should rely on this, but relying on it here + // means that we don't need an additional field on the work in + // progress. + var current = workInProgress.alternate; + { + ReactDebugCurrentFiber.setCurrentFiber(workInProgress); + } + + var returnFiber = workInProgress['return']; + var siblingFiber = workInProgress.sibling; + + if ((workInProgress.effectTag & Incomplete) === NoEffect) { + // This fiber completed. + var next = completeWork(current, workInProgress, nextRenderExpirationTime); + stopWorkTimer(workInProgress); + resetExpirationTime(workInProgress, nextRenderExpirationTime); + { + ReactDebugCurrentFiber.resetCurrentFiber(); + } + + if (next !== null) { + stopWorkTimer(workInProgress); + if (true && ReactFiberInstrumentation_1.debugTool) { + ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress); + } + // If completing this work spawned new work, do that next. We'll come + // back here again. + return next; + } + + if (returnFiber !== null && + // Do not append effects to parents if a sibling failed to complete + (returnFiber.effectTag & Incomplete) === NoEffect) { + // Append all the effects of the subtree and this fiber onto the effect + // list of the parent. The completion order of the children affects the + // side-effect order. + if (returnFiber.firstEffect === null) { + returnFiber.firstEffect = workInProgress.firstEffect; + } + if (workInProgress.lastEffect !== null) { + if (returnFiber.lastEffect !== null) { + returnFiber.lastEffect.nextEffect = workInProgress.firstEffect; + } + returnFiber.lastEffect = workInProgress.lastEffect; + } + + // If this fiber had side-effects, we append it AFTER the children's + // side-effects. We can perform certain side-effects earlier if + // needed, by doing multiple passes over the effect list. We don't want + // to schedule our own side-effect on our own list because if end up + // reusing children we'll schedule this effect onto itself since we're + // at the end. + var effectTag = workInProgress.effectTag; + // Skip both NoWork and PerformedWork tags when creating the effect list. + // PerformedWork effect is read by React DevTools but shouldn't be committed. + if (effectTag > PerformedWork) { + if (returnFiber.lastEffect !== null) { + returnFiber.lastEffect.nextEffect = workInProgress; + } else { + returnFiber.firstEffect = workInProgress; + } + returnFiber.lastEffect = workInProgress; + } + } + + if (true && ReactFiberInstrumentation_1.debugTool) { + ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress); + } + + if (siblingFiber !== null) { + // If there is more work to do in this returnFiber, do that next. + return siblingFiber; + } else if (returnFiber !== null) { + // If there's no more work in this returnFiber. Complete the returnFiber. + workInProgress = returnFiber; + continue; + } else { + // We've reached the root. + isRootReadyForCommit = true; + return null; + } + } else { + // This fiber did not complete because something threw. Pop values off + // the stack without entering the complete phase. If this is a boundary, + // capture values if possible. + var _next = unwindWork(workInProgress); + // Because this fiber did not complete, don't reset its expiration time. + if (workInProgress.effectTag & DidCapture) { + // Restarting an error boundary + stopFailedWorkTimer(workInProgress); + } else { + stopWorkTimer(workInProgress); + } + + { + ReactDebugCurrentFiber.resetCurrentFiber(); + } + + if (_next !== null) { + stopWorkTimer(workInProgress); + if (true && ReactFiberInstrumentation_1.debugTool) { + ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress); + } + // If completing this work spawned new work, do that next. We'll come + // back here again. + // Since we're restarting, remove anything that is not a host effect + // from the effect tag. + _next.effectTag &= HostEffectMask; + return _next; + } + + if (returnFiber !== null) { + // Mark the parent fiber as incomplete and clear its effect list. + returnFiber.firstEffect = returnFiber.lastEffect = null; + returnFiber.effectTag |= Incomplete; + } + + if (true && ReactFiberInstrumentation_1.debugTool) { + ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress); + } + + if (siblingFiber !== null) { + // If there is more work to do in this returnFiber, do that next. + return siblingFiber; + } else if (returnFiber !== null) { + // If there's no more work in this returnFiber. Complete the returnFiber. + workInProgress = returnFiber; + continue; + } else { + return null; + } + } + } + + // Without this explicit null return Flow complains of invalid return type + // TODO Remove the above while(true) loop + // eslint-disable-next-line no-unreachable + return null; + } + + function performUnitOfWork(workInProgress) { + // The current, flushed, state of this fiber is the alternate. + // Ideally nothing should rely on this, but relying on it here + // means that we don't need an additional field on the work in + // progress. + var current = workInProgress.alternate; + + // See if beginning this work spawns more work. + startWorkTimer(workInProgress); + { + ReactDebugCurrentFiber.setCurrentFiber(workInProgress); + } + + if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) { + stashedWorkInProgressProperties = _assign({}, workInProgress); + } + var next = beginWork(current, workInProgress, nextRenderExpirationTime); + + { + ReactDebugCurrentFiber.resetCurrentFiber(); + } + if (true && ReactFiberInstrumentation_1.debugTool) { + ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress); + } + + if (next === null) { + // If this doesn't spawn new work, complete the current work. + next = completeUnitOfWork(workInProgress); + } + + ReactCurrentOwner.current = null; + + return next; + } + + function workLoop(isAsync) { + if (!isAsync) { + // Flush all expired work. + while (nextUnitOfWork !== null) { + nextUnitOfWork = performUnitOfWork(nextUnitOfWork); + } + } else { + // Flush asynchronous work until the deadline runs out of time. + while (nextUnitOfWork !== null && !shouldYield()) { + nextUnitOfWork = performUnitOfWork(nextUnitOfWork); + } + } + } + + function renderRoot(root, expirationTime, isAsync) { + !!isWorking ? invariant_1(false, 'renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.') : void 0; + isWorking = true; + + // Check if we're starting from a fresh stack, or if we're resuming from + // previously yielded work. + if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) { + // Reset the stack and start working from the root. + resetStack(); + nextRoot = root; + nextRenderExpirationTime = expirationTime; + nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime); + root.pendingCommitExpirationTime = NoWork; + } + + var didFatal = false; + + startWorkLoopTimer(nextUnitOfWork); + + do { + try { + workLoop(isAsync); + } catch (thrownValue) { + if (nextUnitOfWork === null) { + // This is a fatal error. + didFatal = true; + onUncaughtError(thrownValue); + break; + } + + if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) { + var failedUnitOfWork = nextUnitOfWork; + replayUnitOfWork(failedUnitOfWork, isAsync); + } + + var sourceFiber = nextUnitOfWork; + var returnFiber = sourceFiber['return']; + if (returnFiber === null) { + // This is the root. The root could capture its own errors. However, + // we don't know if it errors before or after we pushed the host + // context. This information is needed to avoid a stack mismatch. + // Because we're not sure, treat this as a fatal error. We could track + // which phase it fails in, but doesn't seem worth it. At least + // for now. + didFatal = true; + onUncaughtError(thrownValue); + break; + } + throwException(returnFiber, sourceFiber, thrownValue); + nextUnitOfWork = completeUnitOfWork(sourceFiber); + } + break; + } while (true); + + // We're done performing work. Time to clean up. + stopWorkLoopTimer(interruptedBy); + interruptedBy = null; + isWorking = false; + + // Yield back to main thread. + if (didFatal) { + // There was a fatal error. + { + stack.resetStackAfterFatalErrorInDev(); + } + return null; + } else if (nextUnitOfWork === null) { + // We reached the root. + if (isRootReadyForCommit) { + // The root successfully completed. It's ready for commit. + root.pendingCommitExpirationTime = expirationTime; + var finishedWork = root.current.alternate; + return finishedWork; + } else { + // The root did not complete. + invariant_1(false, 'Expired work should have completed. This error is likely caused by a bug in React. Please file an issue.'); + } + } else { + // There's more work to do, but we ran out of time. Yield back to + // the renderer. + return null; + } + } + + function scheduleCapture(sourceFiber, boundaryFiber, value, expirationTime) { + // TODO: We only support dispatching errors. + var capturedValue = createCapturedValue(value, sourceFiber); + var update = { + expirationTime: expirationTime, + partialState: null, + callback: null, + isReplace: false, + isForced: false, + capturedValue: capturedValue, + next: null + }; + insertUpdateIntoFiber(boundaryFiber, update); + scheduleWork(boundaryFiber, expirationTime); + } + + function dispatch(sourceFiber, value, expirationTime) { + !(!isWorking || isCommitting) ? invariant_1(false, 'dispatch: Cannot dispatch during the render phase.') : void 0; + + // TODO: Handle arrays + + var fiber = sourceFiber['return']; + while (fiber !== null) { + switch (fiber.tag) { + case ClassComponent: + var ctor = fiber.type; + var instance = fiber.stateNode; + if (typeof ctor.getDerivedStateFromCatch === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) { + scheduleCapture(sourceFiber, fiber, value, expirationTime); + return; + } + break; + // TODO: Handle async boundaries + case HostRoot: + scheduleCapture(sourceFiber, fiber, value, expirationTime); + return; + } + fiber = fiber['return']; + } + + if (sourceFiber.tag === HostRoot) { + // Error was thrown at the root. There is no parent, so the root + // itself should capture it. + scheduleCapture(sourceFiber, sourceFiber, value, expirationTime); + } + } + + function onCommitPhaseError(fiber, error) { + return dispatch(fiber, error, Sync); + } + + function computeAsyncExpiration(currentTime) { + // Given the current clock time, returns an expiration time. We use rounding + // to batch like updates together. + // Should complete within ~1000ms. 1200ms max. + var expirationMs = 5000; + var bucketSizeMs = 250; + return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs); + } + + function computeInteractiveExpiration(currentTime) { + // Should complete within ~500ms. 600ms max. + var expirationMs = 500; + var bucketSizeMs = 100; + return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs); + } + + // Creates a unique async expiration time. + function computeUniqueAsyncExpiration() { + var currentTime = recalculateCurrentTime(); + var result = computeAsyncExpiration(currentTime); + if (result <= lastUniqueAsyncExpiration) { + // Since we assume the current time monotonically increases, we only hit + // this branch when computeUniqueAsyncExpiration is fired multiple times + // within a 200ms window (or whatever the async bucket size is). + result = lastUniqueAsyncExpiration + 1; + } + lastUniqueAsyncExpiration = result; + return lastUniqueAsyncExpiration; + } + + function computeExpirationForFiber(fiber) { + var expirationTime = void 0; + if (expirationContext !== NoWork) { + // An explicit expiration context was set; + expirationTime = expirationContext; + } else if (isWorking) { + if (isCommitting) { + // Updates that occur during the commit phase should have sync priority + // by default. + expirationTime = Sync; + } else { + // Updates during the render phase should expire at the same time as + // the work that is being rendered. + expirationTime = nextRenderExpirationTime; + } + } else { + // No explicit expiration context was set, and we're not currently + // performing work. Calculate a new expiration time. + if (fiber.mode & AsyncMode) { + if (isBatchingInteractiveUpdates) { + // This is an interactive update + var currentTime = recalculateCurrentTime(); + expirationTime = computeInteractiveExpiration(currentTime); + } else { + // This is an async update + var _currentTime = recalculateCurrentTime(); + expirationTime = computeAsyncExpiration(_currentTime); + } + } else { + // This is a sync update + expirationTime = Sync; + } + } + if (isBatchingInteractiveUpdates) { + // This is an interactive update. Keep track of the lowest pending + // interactive expiration time. This allows us to synchronously flush + // all interactive updates when needed. + if (lowestPendingInteractiveExpirationTime === NoWork || expirationTime > lowestPendingInteractiveExpirationTime) { + lowestPendingInteractiveExpirationTime = expirationTime; + } + } + return expirationTime; + } + + function scheduleWork(fiber, expirationTime) { + return scheduleWorkImpl(fiber, expirationTime, false); + } + + function scheduleWorkImpl(fiber, expirationTime, isErrorRecovery) { + recordScheduleUpdate(); + + { + if (!isErrorRecovery && fiber.tag === ClassComponent) { + var instance = fiber.stateNode; + warnAboutInvalidUpdates(instance); + } + } + + var node = fiber; + while (node !== null) { + // Walk the parent path to the root and update each node's + // expiration time. + if (node.expirationTime === NoWork || node.expirationTime > expirationTime) { + node.expirationTime = expirationTime; + } + if (node.alternate !== null) { + if (node.alternate.expirationTime === NoWork || node.alternate.expirationTime > expirationTime) { + node.alternate.expirationTime = expirationTime; + } + } + if (node['return'] === null) { + if (node.tag === HostRoot) { + var root = node.stateNode; + if (!isWorking && nextRenderExpirationTime !== NoWork && expirationTime < nextRenderExpirationTime) { + // This is an interruption. (Used for performance tracking.) + interruptedBy = fiber; + resetStack(); + } + if ( + // If we're in the render phase, we don't need to schedule this root + // for an update, because we'll do it before we exit... + !isWorking || isCommitting || + // ...unless this is a different root than the one we're rendering. + nextRoot !== root) { + // Add this root to the root schedule. + requestWork(root, expirationTime); + } + if (nestedUpdateCount > NESTED_UPDATE_LIMIT) { + invariant_1(false, 'Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.'); + } + } else { + { + if (!isErrorRecovery && fiber.tag === ClassComponent) { + warnAboutUpdateOnUnmounted(fiber); + } + } + return; + } + } + node = node['return']; + } + } + + function recalculateCurrentTime() { + // Subtract initial time so it fits inside 32bits + mostRecentCurrentTimeMs = now() - originalStartTimeMs; + mostRecentCurrentTime = msToExpirationTime(mostRecentCurrentTimeMs); + return mostRecentCurrentTime; + } + + function deferredUpdates(fn) { + var previousExpirationContext = expirationContext; + var currentTime = recalculateCurrentTime(); + expirationContext = computeAsyncExpiration(currentTime); + try { + return fn(); + } finally { + expirationContext = previousExpirationContext; + } + } + function syncUpdates(fn, a, b, c, d) { + var previousExpirationContext = expirationContext; + expirationContext = Sync; + try { + return fn(a, b, c, d); + } finally { + expirationContext = previousExpirationContext; + } + } + + // TODO: Everything below this is written as if it has been lifted to the + // renderers. I'll do this in a follow-up. + + // Linked-list of roots + var firstScheduledRoot = null; + var lastScheduledRoot = null; + + var callbackExpirationTime = NoWork; + var callbackID = -1; + var isRendering = false; + var nextFlushedRoot = null; + var nextFlushedExpirationTime = NoWork; + var lowestPendingInteractiveExpirationTime = NoWork; + var deadlineDidExpire = false; + var hasUnhandledError = false; + var unhandledError = null; + var deadline = null; + + var isBatchingUpdates = false; + var isUnbatchingUpdates = false; + var isBatchingInteractiveUpdates = false; + + var completedBatches = null; + + // Use these to prevent an infinite loop of nested updates + var NESTED_UPDATE_LIMIT = 1000; + var nestedUpdateCount = 0; + + var timeHeuristicForUnitOfWork = 1; + + function scheduleCallbackWithExpiration(expirationTime) { + if (callbackExpirationTime !== NoWork) { + // A callback is already scheduled. Check its expiration time (timeout). + if (expirationTime > callbackExpirationTime) { + // Existing callback has sufficient timeout. Exit. + return; + } else { + // Existing callback has insufficient timeout. Cancel and schedule a + // new one. + cancelDeferredCallback(callbackID); + } + // The request callback timer is already running. Don't start a new one. + } else { + startRequestCallbackTimer(); + } + + // Compute a timeout for the given expiration time. + var currentMs = now() - originalStartTimeMs; + var expirationMs = expirationTimeToMs(expirationTime); + var timeout = expirationMs - currentMs; + + callbackExpirationTime = expirationTime; + callbackID = scheduleDeferredCallback(performAsyncWork, { timeout: timeout }); + } + + // requestWork is called by the scheduler whenever a root receives an update. + // It's up to the renderer to call renderRoot at some point in the future. + function requestWork(root, expirationTime) { + addRootToSchedule(root, expirationTime); + + if (isRendering) { + // Prevent reentrancy. Remaining work will be scheduled at the end of + // the currently rendering batch. + return; + } + + if (isBatchingUpdates) { + // Flush work at the end of the batch. + if (isUnbatchingUpdates) { + // ...unless we're inside unbatchedUpdates, in which case we should + // flush it now. + nextFlushedRoot = root; + nextFlushedExpirationTime = Sync; + performWorkOnRoot(root, Sync, false); + } + return; + } + + // TODO: Get rid of Sync and use current time? + if (expirationTime === Sync) { + performSyncWork(); + } else { + scheduleCallbackWithExpiration(expirationTime); + } + } + + function addRootToSchedule(root, expirationTime) { + // Add the root to the schedule. + // Check if this root is already part of the schedule. + if (root.nextScheduledRoot === null) { + // This root is not already scheduled. Add it. + root.remainingExpirationTime = expirationTime; + if (lastScheduledRoot === null) { + firstScheduledRoot = lastScheduledRoot = root; + root.nextScheduledRoot = root; + } else { + lastScheduledRoot.nextScheduledRoot = root; + lastScheduledRoot = root; + lastScheduledRoot.nextScheduledRoot = firstScheduledRoot; + } + } else { + // This root is already scheduled, but its priority may have increased. + var remainingExpirationTime = root.remainingExpirationTime; + if (remainingExpirationTime === NoWork || expirationTime < remainingExpirationTime) { + // Update the priority. + root.remainingExpirationTime = expirationTime; + } + } + } + + function findHighestPriorityRoot() { + var highestPriorityWork = NoWork; + var highestPriorityRoot = null; + if (lastScheduledRoot !== null) { + var previousScheduledRoot = lastScheduledRoot; + var root = firstScheduledRoot; + while (root !== null) { + var remainingExpirationTime = root.remainingExpirationTime; + if (remainingExpirationTime === NoWork) { + // This root no longer has work. Remove it from the scheduler. + + // TODO: This check is redudant, but Flow is confused by the branch + // below where we set lastScheduledRoot to null, even though we break + // from the loop right after. + !(previousScheduledRoot !== null && lastScheduledRoot !== null) ? invariant_1(false, 'Should have a previous and last root. This error is likely caused by a bug in React. Please file an issue.') : void 0; + if (root === root.nextScheduledRoot) { + // This is the only root in the list. + root.nextScheduledRoot = null; + firstScheduledRoot = lastScheduledRoot = null; + break; + } else if (root === firstScheduledRoot) { + // This is the first root in the list. + var next = root.nextScheduledRoot; + firstScheduledRoot = next; + lastScheduledRoot.nextScheduledRoot = next; + root.nextScheduledRoot = null; + } else if (root === lastScheduledRoot) { + // This is the last root in the list. + lastScheduledRoot = previousScheduledRoot; + lastScheduledRoot.nextScheduledRoot = firstScheduledRoot; + root.nextScheduledRoot = null; + break; + } else { + previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot; + root.nextScheduledRoot = null; + } + root = previousScheduledRoot.nextScheduledRoot; + } else { + if (highestPriorityWork === NoWork || remainingExpirationTime < highestPriorityWork) { + // Update the priority, if it's higher + highestPriorityWork = remainingExpirationTime; + highestPriorityRoot = root; + } + if (root === lastScheduledRoot) { + break; + } + previousScheduledRoot = root; + root = root.nextScheduledRoot; + } + } + } + + // If the next root is the same as the previous root, this is a nested + // update. To prevent an infinite loop, increment the nested update count. + var previousFlushedRoot = nextFlushedRoot; + if (previousFlushedRoot !== null && previousFlushedRoot === highestPriorityRoot && highestPriorityWork === Sync) { + nestedUpdateCount++; + } else { + // Reset whenever we switch roots. + nestedUpdateCount = 0; + } + nextFlushedRoot = highestPriorityRoot; + nextFlushedExpirationTime = highestPriorityWork; + } + + function performAsyncWork(dl) { + performWork(NoWork, true, dl); + } + + function performSyncWork() { + performWork(Sync, false, null); + } + + function performWork(minExpirationTime, isAsync, dl) { + deadline = dl; + + // Keep working on roots until there's no more work, or until the we reach + // the deadline. + findHighestPriorityRoot(); + + if (enableUserTimingAPI && deadline !== null) { + var didExpire = nextFlushedExpirationTime < recalculateCurrentTime(); + var timeout = expirationTimeToMs(nextFlushedExpirationTime); + stopRequestCallbackTimer(didExpire, timeout); + } + + if (isAsync) { + while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || minExpirationTime >= nextFlushedExpirationTime) && (!deadlineDidExpire || recalculateCurrentTime() >= nextFlushedExpirationTime)) { + performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !deadlineDidExpire); + findHighestPriorityRoot(); + } + } else { + while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || minExpirationTime >= nextFlushedExpirationTime)) { + performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false); + findHighestPriorityRoot(); + } + } + + // We're done flushing work. Either we ran out of time in this callback, + // or there's no more work left with sufficient priority. + + // If we're inside a callback, set this to false since we just completed it. + if (deadline !== null) { + callbackExpirationTime = NoWork; + callbackID = -1; + } + // If there's work left over, schedule a new callback. + if (nextFlushedExpirationTime !== NoWork) { + scheduleCallbackWithExpiration(nextFlushedExpirationTime); + } + + // Clean-up. + deadline = null; + deadlineDidExpire = false; + + finishRendering(); + } + + function flushRoot(root, expirationTime) { + !!isRendering ? invariant_1(false, 'work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.') : void 0; + // Perform work on root as if the given expiration time is the current time. + // This has the effect of synchronously flushing all work up to and + // including the given time. + nextFlushedRoot = root; + nextFlushedExpirationTime = expirationTime; + performWorkOnRoot(root, expirationTime, false); + // Flush any sync work that was scheduled by lifecycles + performSyncWork(); + finishRendering(); + } + + function finishRendering() { + nestedUpdateCount = 0; + + if (completedBatches !== null) { + var batches = completedBatches; + completedBatches = null; + for (var i = 0; i < batches.length; i++) { + var batch = batches[i]; + try { + batch._onComplete(); + } catch (error) { + if (!hasUnhandledError) { + hasUnhandledError = true; + unhandledError = error; + } + } + } + } + + if (hasUnhandledError) { + var error = unhandledError; + unhandledError = null; + hasUnhandledError = false; + throw error; + } + } + + function performWorkOnRoot(root, expirationTime, isAsync) { + !!isRendering ? invariant_1(false, 'performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.') : void 0; + + isRendering = true; + + // Check if this is async work or sync/expired work. + if (!isAsync) { + // Flush sync work. + var finishedWork = root.finishedWork; + if (finishedWork !== null) { + // This root is already complete. We can commit it. + completeRoot(root, finishedWork, expirationTime); + } else { + root.finishedWork = null; + finishedWork = renderRoot(root, expirationTime, false); + if (finishedWork !== null) { + // We've completed the root. Commit it. + completeRoot(root, finishedWork, expirationTime); + } + } + } else { + // Flush async work. + var _finishedWork = root.finishedWork; + if (_finishedWork !== null) { + // This root is already complete. We can commit it. + completeRoot(root, _finishedWork, expirationTime); + } else { + root.finishedWork = null; + _finishedWork = renderRoot(root, expirationTime, true); + if (_finishedWork !== null) { + // We've completed the root. Check the deadline one more time + // before committing. + if (!shouldYield()) { + // Still time left. Commit the root. + completeRoot(root, _finishedWork, expirationTime); + } else { + // There's no time left. Mark this root as complete. We'll come + // back and commit it later. + root.finishedWork = _finishedWork; + } + } + } + } + + isRendering = false; + } + + function completeRoot(root, finishedWork, expirationTime) { + // Check if there's a batch that matches this expiration time. + var firstBatch = root.firstBatch; + if (firstBatch !== null && firstBatch._expirationTime <= expirationTime) { + if (completedBatches === null) { + completedBatches = [firstBatch]; + } else { + completedBatches.push(firstBatch); + } + if (firstBatch._defer) { + // This root is blocked from committing by a batch. Unschedule it until + // we receive another update. + root.finishedWork = finishedWork; + root.remainingExpirationTime = NoWork; + return; + } + } + + // Commit the root. + root.finishedWork = null; + root.remainingExpirationTime = commitRoot(finishedWork); + } + + // When working on async work, the reconciler asks the renderer if it should + // yield execution. For DOM, we implement this with requestIdleCallback. + function shouldYield() { + if (deadline === null) { + return false; + } + if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) { + // Disregard deadline.didTimeout. Only expired work should be flushed + // during a timeout. This path is only hit for non-expired work. + return false; + } + deadlineDidExpire = true; + return true; + } + + function onUncaughtError(error) { + !(nextFlushedRoot !== null) ? invariant_1(false, 'Should be working on a root. This error is likely caused by a bug in React. Please file an issue.') : void 0; + // Unschedule this root so we don't work on it again until there's + // another update. + nextFlushedRoot.remainingExpirationTime = NoWork; + if (!hasUnhandledError) { + hasUnhandledError = true; + unhandledError = error; + } + } + + // TODO: Batching should be implemented at the renderer level, not inside + // the reconciler. + function batchedUpdates(fn, a) { + var previousIsBatchingUpdates = isBatchingUpdates; + isBatchingUpdates = true; + try { + return fn(a); + } finally { + isBatchingUpdates = previousIsBatchingUpdates; + if (!isBatchingUpdates && !isRendering) { + performSyncWork(); + } + } + } + + // TODO: Batching should be implemented at the renderer level, not inside + // the reconciler. + function unbatchedUpdates(fn, a) { + if (isBatchingUpdates && !isUnbatchingUpdates) { + isUnbatchingUpdates = true; + try { + return fn(a); + } finally { + isUnbatchingUpdates = false; + } + } + return fn(a); + } + + // TODO: Batching should be implemented at the renderer level, not within + // the reconciler. + function flushSync(fn, a) { + !!isRendering ? invariant_1(false, 'flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering.') : void 0; + var previousIsBatchingUpdates = isBatchingUpdates; + isBatchingUpdates = true; + try { + return syncUpdates(fn, a); + } finally { + isBatchingUpdates = previousIsBatchingUpdates; + performSyncWork(); + } + } + + function interactiveUpdates(fn, a, b) { + if (isBatchingInteractiveUpdates) { + return fn(a, b); + } + // If there are any pending interactive updates, synchronously flush them. + // This needs to happen before we read any handlers, because the effect of + // the previous event may influence which handlers are called during + // this event. + if (!isBatchingUpdates && !isRendering && lowestPendingInteractiveExpirationTime !== NoWork) { + // Synchronously flush pending interactive updates. + performWork(lowestPendingInteractiveExpirationTime, false, null); + lowestPendingInteractiveExpirationTime = NoWork; + } + var previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates; + var previousIsBatchingUpdates = isBatchingUpdates; + isBatchingInteractiveUpdates = true; + isBatchingUpdates = true; + try { + return fn(a, b); + } finally { + isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates; + isBatchingUpdates = previousIsBatchingUpdates; + if (!isBatchingUpdates && !isRendering) { + performSyncWork(); + } + } + } + + function flushInteractiveUpdates() { + if (!isRendering && lowestPendingInteractiveExpirationTime !== NoWork) { + // Synchronously flush pending interactive updates. + performWork(lowestPendingInteractiveExpirationTime, false, null); + lowestPendingInteractiveExpirationTime = NoWork; + } + } + + function flushControlled(fn) { + var previousIsBatchingUpdates = isBatchingUpdates; + isBatchingUpdates = true; + try { + syncUpdates(fn); + } finally { + isBatchingUpdates = previousIsBatchingUpdates; + if (!isBatchingUpdates && !isRendering) { + performWork(Sync, false, null); + } + } + } + + return { + recalculateCurrentTime: recalculateCurrentTime, + computeExpirationForFiber: computeExpirationForFiber, + scheduleWork: scheduleWork, + requestWork: requestWork, + flushRoot: flushRoot, + batchedUpdates: batchedUpdates, + unbatchedUpdates: unbatchedUpdates, + flushSync: flushSync, + flushControlled: flushControlled, + deferredUpdates: deferredUpdates, + syncUpdates: syncUpdates, + interactiveUpdates: interactiveUpdates, + flushInteractiveUpdates: flushInteractiveUpdates, + computeUniqueAsyncExpiration: computeUniqueAsyncExpiration, + legacyContext: legacyContext + }; +}; + +var didWarnAboutNestedUpdates = void 0; + +{ + didWarnAboutNestedUpdates = false; +} + +// 0 is PROD, 1 is DEV. +// Might add PROFILE later. + + +var ReactFiberReconciler$1 = function (config) { + var getPublicInstance = config.getPublicInstance; + + var _ReactFiberScheduler = ReactFiberScheduler(config), + computeUniqueAsyncExpiration = _ReactFiberScheduler.computeUniqueAsyncExpiration, + recalculateCurrentTime = _ReactFiberScheduler.recalculateCurrentTime, + computeExpirationForFiber = _ReactFiberScheduler.computeExpirationForFiber, + scheduleWork = _ReactFiberScheduler.scheduleWork, + requestWork = _ReactFiberScheduler.requestWork, + flushRoot = _ReactFiberScheduler.flushRoot, + batchedUpdates = _ReactFiberScheduler.batchedUpdates, + unbatchedUpdates = _ReactFiberScheduler.unbatchedUpdates, + flushSync = _ReactFiberScheduler.flushSync, + flushControlled = _ReactFiberScheduler.flushControlled, + deferredUpdates = _ReactFiberScheduler.deferredUpdates, + syncUpdates = _ReactFiberScheduler.syncUpdates, + interactiveUpdates = _ReactFiberScheduler.interactiveUpdates, + flushInteractiveUpdates = _ReactFiberScheduler.flushInteractiveUpdates, + legacyContext = _ReactFiberScheduler.legacyContext; + + var findCurrentUnmaskedContext = legacyContext.findCurrentUnmaskedContext, + isContextProvider = legacyContext.isContextProvider, + processChildContext = legacyContext.processChildContext; + + + function getContextForSubtree(parentComponent) { + if (!parentComponent) { + return emptyObject_1; + } + + var fiber = get(parentComponent); + var parentContext = findCurrentUnmaskedContext(fiber); + return isContextProvider(fiber) ? processChildContext(fiber, parentContext) : parentContext; + } + + function scheduleRootUpdate(current, element, currentTime, expirationTime, callback) { + { + if (ReactDebugCurrentFiber.phase === 'render' && ReactDebugCurrentFiber.current !== null && !didWarnAboutNestedUpdates) { + didWarnAboutNestedUpdates = true; + warning_1(false, 'Render methods should be a pure function of props and state; ' + 'triggering nested component updates from render is not allowed. ' + 'If necessary, trigger nested updates in componentDidUpdate.\n\n' + 'Check the render method of %s.', getComponentName(ReactDebugCurrentFiber.current) || 'Unknown'); + } + } + + callback = callback === undefined ? null : callback; + { + warning_1(callback === null || typeof callback === 'function', 'render(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callback); + } + + var update = { + expirationTime: expirationTime, + partialState: { element: element }, + callback: callback, + isReplace: false, + isForced: false, + capturedValue: null, + next: null + }; + insertUpdateIntoFiber(current, update); + scheduleWork(current, expirationTime); + + return expirationTime; + } + + function updateContainerAtExpirationTime(element, container, parentComponent, currentTime, expirationTime, callback) { + // TODO: If this is a nested container, this won't be the root. + var current = container.current; + + { + if (ReactFiberInstrumentation_1.debugTool) { + if (current.alternate === null) { + ReactFiberInstrumentation_1.debugTool.onMountContainer(container); + } else if (element === null) { + ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container); + } else { + ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container); + } + } + } + + var context = getContextForSubtree(parentComponent); + if (container.context === null) { + container.context = context; + } else { + container.pendingContext = context; + } + + return scheduleRootUpdate(current, element, currentTime, expirationTime, callback); + } + + function findHostInstance(fiber) { + var hostFiber = findCurrentHostFiber(fiber); + if (hostFiber === null) { + return null; + } + return hostFiber.stateNode; + } + + return { + createContainer: function (containerInfo, isAsync, hydrate) { + return createFiberRoot(containerInfo, isAsync, hydrate); + }, + updateContainer: function (element, container, parentComponent, callback) { + var current = container.current; + var currentTime = recalculateCurrentTime(); + var expirationTime = computeExpirationForFiber(current); + return updateContainerAtExpirationTime(element, container, parentComponent, currentTime, expirationTime, callback); + }, + updateContainerAtExpirationTime: function (element, container, parentComponent, expirationTime, callback) { + var currentTime = recalculateCurrentTime(); + return updateContainerAtExpirationTime(element, container, parentComponent, currentTime, expirationTime, callback); + }, + + + flushRoot: flushRoot, + + requestWork: requestWork, + + computeUniqueAsyncExpiration: computeUniqueAsyncExpiration, + + batchedUpdates: batchedUpdates, + + unbatchedUpdates: unbatchedUpdates, + + deferredUpdates: deferredUpdates, + + syncUpdates: syncUpdates, + + interactiveUpdates: interactiveUpdates, + + flushInteractiveUpdates: flushInteractiveUpdates, + + flushControlled: flushControlled, + + flushSync: flushSync, + + getPublicRootInstance: function (container) { + var containerFiber = container.current; + if (!containerFiber.child) { + return null; + } + switch (containerFiber.child.tag) { + case HostComponent: + return getPublicInstance(containerFiber.child.stateNode); + default: + return containerFiber.child.stateNode; + } + }, + + + findHostInstance: findHostInstance, + + findHostInstanceWithNoPortals: function (fiber) { + var hostFiber = findCurrentHostFiberWithNoPortals(fiber); + if (hostFiber === null) { + return null; + } + return hostFiber.stateNode; + }, + injectIntoDevTools: function (devToolsConfig) { + var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance; + + return injectInternals(_assign({}, devToolsConfig, { + findHostInstanceByFiber: function (fiber) { + return findHostInstance(fiber); + }, + findFiberByHostInstance: function (instance) { + if (!findFiberByHostInstance) { + // Might not be implemented by the renderer. + return null; + } + return findFiberByHostInstance(instance); + } + })); + } + }; +}; + +var ReactFiberReconciler$2 = Object.freeze({ + default: ReactFiberReconciler$1 +}); + +var ReactFiberReconciler$3 = ( ReactFiberReconciler$2 && ReactFiberReconciler$1 ) || ReactFiberReconciler$2; + +// TODO: bundle Flow types with the package. + + + +// TODO: decide on the top-level export form. +// This is hacky but makes it work with both Rollup and Jest. +var reactReconciler = ReactFiberReconciler$3['default'] ? ReactFiberReconciler$3['default'] : ReactFiberReconciler$3; + +function createPortal$1(children, containerInfo, +// TODO: figure out the API for cross-renderer implementation. +implementation) { + var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; + + return { + // This tag allow us to uniquely identify this as a React Portal + $$typeof: REACT_PORTAL_TYPE, + key: key == null ? null : '' + key, + children: children, + containerInfo: containerInfo, + implementation: implementation + }; +} + +// TODO: this is special because it gets imported during build. + +var ReactVersion = '16.3.0'; + +// a requestAnimationFrame, storing the time for the start of the frame, then +// scheduling a postMessage which gets scheduled after paint. Within the +// postMessage handler do as much work as possible until time + frame rate. +// By separating the idle call into a separate event tick we ensure that +// layout, paint and other browser work is counted against the available time. +// The frame rate is dynamically adjusted. + +{ + if (ExecutionEnvironment_1.canUseDOM && typeof requestAnimationFrame !== 'function') { + warning_1(false, 'React depends on requestAnimationFrame. Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills'); + } +} + +var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function'; + +var now = void 0; +if (hasNativePerformanceNow) { + now = function () { + return performance.now(); + }; +} else { + now = function () { + return Date.now(); + }; +} + +// TODO: There's no way to cancel, because Fiber doesn't atm. +var rIC = void 0; +var cIC = void 0; + +if (!ExecutionEnvironment_1.canUseDOM) { + rIC = function (frameCallback) { + return setTimeout(function () { + frameCallback({ + timeRemaining: function () { + return Infinity; + }, + + didTimeout: false + }); + }); + }; + cIC = function (timeoutID) { + clearTimeout(timeoutID); + }; +} else if (alwaysUseRequestIdleCallbackPolyfill || typeof requestIdleCallback !== 'function' || typeof cancelIdleCallback !== 'function') { + // Polyfill requestIdleCallback and cancelIdleCallback + + var scheduledRICCallback = null; + var isIdleScheduled = false; + var timeoutTime = -1; + + var isAnimationFrameScheduled = false; + + var frameDeadline = 0; + // We start out assuming that we run at 30fps but then the heuristic tracking + // will adjust this value to a faster fps if we get more frequent animation + // frames. + var previousFrameTime = 33; + var activeFrameTime = 33; + + var frameDeadlineObject = void 0; + if (hasNativePerformanceNow) { + frameDeadlineObject = { + didTimeout: false, + timeRemaining: function () { + // We assume that if we have a performance timer that the rAF callback + // gets a performance timer value. Not sure if this is always true. + var remaining = frameDeadline - performance.now(); + return remaining > 0 ? remaining : 0; + } + }; + } else { + frameDeadlineObject = { + didTimeout: false, + timeRemaining: function () { + // Fallback to Date.now() + var remaining = frameDeadline - Date.now(); + return remaining > 0 ? remaining : 0; + } + }; + } + + // We use the postMessage trick to defer idle work until after the repaint. + var messageKey = '__reactIdleCallback$' + Math.random().toString(36).slice(2); + var idleTick = function (event) { + if (event.source !== window || event.data !== messageKey) { + return; + } + + isIdleScheduled = false; + + var currentTime = now(); + if (frameDeadline - currentTime <= 0) { + // There's no time left in this idle period. Check if the callback has + // a timeout and whether it's been exceeded. + if (timeoutTime !== -1 && timeoutTime <= currentTime) { + // Exceeded the timeout. Invoke the callback even though there's no + // time left. + frameDeadlineObject.didTimeout = true; + } else { + // No timeout. + if (!isAnimationFrameScheduled) { + // Schedule another animation callback so we retry later. + isAnimationFrameScheduled = true; + requestAnimationFrame(animationTick); + } + // Exit without invoking the callback. + return; + } + } else { + // There's still time left in this idle period. + frameDeadlineObject.didTimeout = false; + } + + timeoutTime = -1; + var callback = scheduledRICCallback; + scheduledRICCallback = null; + if (callback !== null) { + callback(frameDeadlineObject); + } + }; + // Assumes that we have addEventListener in this environment. Might need + // something better for old IE. + window.addEventListener('message', idleTick, false); + + var animationTick = function (rafTime) { + isAnimationFrameScheduled = false; + var nextFrameTime = rafTime - frameDeadline + activeFrameTime; + if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) { + if (nextFrameTime < 8) { + // Defensive coding. We don't support higher frame rates than 120hz. + // If we get lower than that, it is probably a bug. + nextFrameTime = 8; + } + // If one frame goes long, then the next one can be short to catch up. + // If two frames are short in a row, then that's an indication that we + // actually have a higher frame rate than what we're currently optimizing. + // We adjust our heuristic dynamically accordingly. For example, if we're + // running on 120hz display or 90hz VR display. + // Take the max of the two in case one of them was an anomaly due to + // missed frame deadlines. + activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime; + } else { + previousFrameTime = nextFrameTime; + } + frameDeadline = rafTime + activeFrameTime; + if (!isIdleScheduled) { + isIdleScheduled = true; + window.postMessage(messageKey, '*'); + } + }; + + rIC = function (callback, options) { + // This assumes that we only schedule one callback at a time because that's + // how Fiber uses it. + scheduledRICCallback = callback; + if (options != null && typeof options.timeout === 'number') { + timeoutTime = now() + options.timeout; + } + if (!isAnimationFrameScheduled) { + // If rAF didn't already schedule one, we need to schedule a frame. + // TODO: If this rAF doesn't materialize because the browser throttles, we + // might want to still have setTimeout trigger rIC as a backup to ensure + // that we keep performing work. + isAnimationFrameScheduled = true; + requestAnimationFrame(animationTick); + } + return 0; + }; + + cIC = function () { + scheduledRICCallback = null; + isIdleScheduled = false; + timeoutTime = -1; + }; +} else { + rIC = window.requestIdleCallback; + cIC = window.cancelIdleCallback; +} + +var didWarnSelectedSetOnOption = false; + +function flattenChildren(children) { + var content = ''; + + // Flatten children and warn if they aren't strings or numbers; + // invalid types are ignored. + // We can silently skip them because invalid DOM nesting warning + // catches these cases in Fiber. + React.Children.forEach(children, function (child) { + if (child == null) { + return; + } + if (typeof child === 'string' || typeof child === 'number') { + content += child; + } + }); + + return content; +} + +/** + * Implements an