["^ ","~:foreign-libs",[],"~:externs",[],"~:resources",[["^ ","~:js-str-offsets",[],"~:classpath",true,"~:js-esm",false,"~:cache-key",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"~:js-imports",[],"~:js-invalid-requires",[],"~:goog-provides",[],"~:js-language","es3","~:goog-module",null,"~:ns","~$module$shadow$boot$esm","~:output-name","module$shadow$boot$esm.js","~:resource-id",["~:shadow.build.classpath/resource","shadow/boot/esm.js"],"~:resource-name","shadow/boot/esm.js","~:type","~:js","~:js-requires",[],"~:source","var SHADOW_ENV = $CLJS.SHADOW_ENV = (function() {\n    var env = {};\n\n    var loadedFiles = env.loadedFiles = {};\n\n    env.setLoaded = function(name) {\n        loadedFiles[name] = true;\n    };\n\n    env.load = function(opts, paths) {\n        paths.forEach(function(name) {\n            env.setLoaded(name);\n        });\n    };\n\n    env.isLoaded = function(name) {\n        return loadedFiles[name] || false;\n    }\n\n    return env;\n})();\n","~:last-modified",1605061761213,"~:requires",["~#set",[]],"~:goog-requires",[],"~:inspect-info",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"~:uses-global-buffer",false,"~:uses-global-process",false],"~:url",["~#url","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/boot/esm.js"],"~:provides",["^H",["^="]],"^K",false,"~:from-jar",true,"~:deps",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es6","^;",null,"^<","~$module$shadow$boot$browser","^>","module$shadow$boot$browser.js","^?",["^@","shadow/boot/browser.js"],"^A","shadow/boot/browser.js","^B","^C","^D",[],"^E","var SHADOW_ENV = function() {\n  var loadedFiles = {};\n\n  var env = {};\n\n  var doc = goog.global.document;\n\n  if (!doc) {\n    throw new Error(\"browser bootstrap used in incorrect target\");\n  }\n\n  var scriptBase = goog.global.window.location.origin;\n  if (CLOSURE_BASE_PATH[0] == '/') {\n    scriptBase = scriptBase + CLOSURE_BASE_PATH;\n  } else {\n    // FIXME: need to handle relative paths\n    scriptBase = CLOSURE_BASE_PATH;\n  }\n\n  env.scriptBase = scriptBase;\n\n  var wentAsync = false;\n\n  var canDocumentWrite = function() {\n    return !wentAsync && doc.readyState == \"loading\";\n  };\n\n  var asyncLoad = (function() {\n    var loadOrder = [];\n    var loadState = {};\n\n    function loadPending() {\n      for (var i = 0, len = loadOrder.length; i < len; i++) {\n        var uri = loadOrder[i];\n        var state = loadState[uri];\n\n        if (typeof state === \"string\") {\n          loadState[uri] = true;\n          if (state != \"\") {\n            var code = state + \"\\n//# sourceURL=\" + uri + \"\\n\";\n            try {\n              goog.globalEval(code);\n            } catch (e) {\n              console.error(\"An error occurred when loading\", uri);\n              console.error(e.stack);\n            }\n          }\n        } else if (state === true) {\n          continue;\n        } else {\n          break;\n        }\n      }\n    }\n\n    // ie11 doesn't have fetch, use xhr instead\n    // FIXME: not sure if fetch provides any benefit over xhr\n    if (typeof window.fetch === \"undefined\") {\n      return function asyncXhr(uri) {\n        loadOrder.push(uri);\n        loadState[uri] = false;\n        var req = new XMLHttpRequest();\n        req.onload = function(e) {\n          loadState[uri] = req.responseText;\n          loadPending();\n        };\n        req.open(\"GET\", uri);\n        req.send();\n      }\n    } else {\n      function responseText(response) {\n        // FIXME: check status\n        return response.text();\n      }\n\n      function evalFetch(uri) {\n        return function(code) {\n          loadState[uri] = code;\n          loadPending();\n        };\n      }\n\n      return function asyncFetch(uri) {\n        if (loadState[uri] == undefined) {\n          loadState[uri] = false;\n          loadOrder.push(uri);\n          fetch(uri)\n            .then(responseText)\n            .then(evalFetch(uri));\n        }\n      };\n    }\n  })();\n\n  env.load = function(opts, paths) {\n    var docWrite = opts.forceAsync ? false : canDocumentWrite();\n\n    paths.forEach(function(path) {\n      if (!loadedFiles[path]) {\n        loadedFiles[path] = true;\n\n        var uri = scriptBase + path;\n\n        if (docWrite) {\n          document.write(\n            \"<script src='\" + uri + \"' type='text/javascript'></script>\"\n          );\n        } else {\n          // once async always async\n          wentAsync = true;\n          asyncLoad(uri);\n        }\n      }\n    });\n  };\n\n  env.isLoaded = function(path) {\n    return loadedFiles[path] || false; // false is better than undefined\n  };\n\n  env.setLoaded = function(path) {\n    loadedFiles[path] = true;\n  };\n\n  env.evalLoad = function(path, sourceMap, code) {\n    loadedFiles[path] = true;\n    code += (\"\\n//# sourceURL=\" + scriptBase + path);\n    if (sourceMap) {\n      code += (\"\\n//# sourceMappingURL=\" + path + \".map\");\n    }\n    try {\n      goog.globalEval(code);\n    } catch (e) {\n      console.error(\"An error occurred when loading\", path);\n      console.error(e.stack);\n    }\n  }\n\n  return env;\n}.call(this);\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es6","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/boot/browser.js"],"^O",["^H",["^R"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$build$targets$external_boilerplate","^>","module$shadow$build$targets$external_boilerplate.js","^?",["^@","shadow/build/targets/external_boilerplate.js"],"^A","shadow/build/targets/external_boilerplate.js","^B","^C","^D",[],"^E","global.shadow$bridge = function shadow$bridge(name) {\n  var ret = ALL[name];\n\n  if (ret === undefined) {\n     throw new Error(\"Dependency: \" + name + \" not provided by external JS. Do you maybe need a recompile?\");\n  }\n\n  return ret;\n};\n\nshadow$bridge.ALL = ALL;","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/build/targets/external_boilerplate.js"],"^O",["^H",["^S"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$build$targets$graaljs_bootstrap","^>","module$shadow$build$targets$graaljs_bootstrap.js","^?",["^@","shadow/build/targets/graaljs_bootstrap.js"],"^A","shadow/build/targets/graaljs_bootstrap.js","^B","^C","^D",[],"^E","function graaljs_async_not_supported() {\r\n  // FIXME: I'm hesitant to introduce threads from inside the JS context\r\n  // need to figure out some kind of event loop from the JVM side\r\n  throw new Error(\"async functions not supported in graaljs engine.\");\r\n}\r\n\r\nfunction setInterval() {\r\n  graaljs_async_not_supported();\r\n}\r\n\r\nfunction clearInterval(future) {\r\n  graaljs_async_not_supported();\r\n}\r\n\r\nfunction setTimeout() {\r\n  graaljs_async_not_supported();\r\n}\r\n\r\nfunction clearTimeout() {\r\n  graaljs_async_not_supported();\r\n}\r\n\r\nfunction setImmediate() {\r\n  graaljs_async_not_supported();\r\n}\r\n\r\nfunction clearImmediate(future) {\r\n  graaljs_async_not_supported();\r\n}\r\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/build/targets/graaljs_bootstrap.js"],"^O",["^H",["^T"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$build$targets$npm_module_goog_overrides","^>","module$shadow$build$targets$npm_module_goog_overrides.js","^?",["^@","shadow/build/targets/npm_module_goog_overrides.js"],"^A","shadow/build/targets/npm_module_goog_overrides.js","^B","^C","^D",[],"^E","\nvar originalGoogExportPath = goog.exportPath_;\n\ngoog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {\n  // must keep the export to global for things like (goog/exportSymbol js/React ...)\n  originalGoogExportPath(name, opt_object, opt_objectToExportTo);\n  // goog.module.declareLegacyNamespace() otherwise only exports to global but we need it on the $CLJS object\n  if (goog.isInModuleLoader_()) {\n    originalGoogExportPath(name, opt_object, $CLJS);\n  }\n}\n\ngoog.provide = function(name) {\n  return originalGoogExportPath(name, undefined, $CLJS);\n};\n\ngoog.require = function(name) {\n  return goog.getObjectByName(name, $CLJS);\n};\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/build/targets/npm_module_goog_overrides.js"],"^O",["^H",["^U"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$boot$react_native","^>","module$shadow$boot$react_native.js","^?",["^@","shadow/boot/react-native.js"],"^A","shadow/boot/react-native.js","^B","^C","^D",[],"^E","var SHADOW_ENV = $CLJS.SHADOW_ENV = (function() {\n    var env = {};\n\n    var loadedFiles = {};\n\n    env.setLoaded = function(name) {\n        loadedFiles[name] = true;\n    };\n\n    env.load = function(opts, paths) {\n        paths.forEach(function(name) {\n            env.setLoaded(name);\n        });\n    };\n\n    env.isLoaded = function(name) {\n        // this is only used by live-reload checking if it should reload a file\n        // since all files will always be loaded we don't really need to track this?\n        return true;\n        // return loadedFiles[name] || false;\n    }\n\n    env.evalLoad = function(name, code) {\n        goog.globalEval(code);\n    };\n\n    return env;\n})();\n\n// object of require->fn to \"trigger\" the actual require\n// mostly to remain semantics of \"when\" something is included\n// rather than forcefully including everything at the top of the file\n$CLJS.shadow$js = {};\n$CLJS.shadow$jsRequire = function(name) {\n  var fn = $CLJS.shadow$js[name];\n\n  if (typeof fn == 'function') {\n    return fn();\n  } else {\n    throw new Error(\"require \" + name + \" not found. If you require'd this manually you may need to reload the app so metro can process it.\")\n  }\n};\n\n// fake require function since metro replaced all static require calls already\n// and require is actually undefined otherwise. Ideally CLJS would have emitted\n// another function call as well but that would require adjusting the compiler more\nglobal.require = function(name) {\n    return $CLJS.shadow$jsRequire(name);\n};\n\n// make js/global accessible in eval'd sources since it isn't actually a global\nglobal.global = global;","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/boot/react-native.js"],"^O",["^H",["^V"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^>","shadow.loader.js","^?",["^@","shadow/loader.js"],"^A","shadow/loader.js","^B","~:goog","^E","goog.provide(\"shadow.loader\");\ngoog.require(\"goog.module.ModuleManager\");\ngoog.require(\"goog.module.ModuleLoader\");\ngoog.require(\"goog.object\");\ngoog.require(\"goog.html.uncheckedconversions\");\ngoog.require(\"goog.string.Const\");\n\n// this is written in JS so it doesn't depend on cljs.core\n\nshadow.loader.ml = new goog.module.ModuleLoader();\nshadow.loader.ml.setSourceUrlInjection(true);\n\nshadow.loader.mm = goog.module.ModuleManager.getInstance();\nshadow.loader.mm.setLoader(shadow.loader.ml);\n\nshadow.loader.initCalled = false;\n\nshadow.loader.ensureInitWasCalled = function() {\n  if (!shadow.loader.initCalled) {\n    throw new Error(\"shadow.loader API was called before shadow.loader.init!\\n\" +\n        \"You are probably calling module loader too early before shadow-cljs got fully initialized.\");\n  }\n}\n\nshadow.loader.init = function(uriPrefix) {\n  if (shadow.loader.initCalled) {\n    throw new Error(\"shadow.loader.init was already called! If you are calling it manually set :module-loader-init false in your config.\");\n  }\n\n  if (goog.global.shadow$modules) {\n    var mm = shadow.loader.mm;\n    mm.setAllModuleInfo(goog.global.shadow$modules[\"infos\"]);\n\n    var uris = goog.global.shadow$modules[\"uris\"];\n\n    // this is absurd. the uris are generated by the compiler. should be trusted already.\n    // I would really like to know how Google integrates this data into their builds\n    var trustReason = goog.string.Const.from(\"generated by compiler\");\n\n    goog.object.getKeys(uris).forEach(function(key) {\n      var module_uris = uris[key];\n      if (module_uris.length == 0) {\n        // default module is added without uris since it will always be loaded\n        // when this is called\n        mm.getModuleInfo(key).setLoaded();\n      } else {\n        var trusted_uris = [];\n        module_uris.forEach(function(module_uri) {\n          var trusted = goog.html.uncheckedconversions.trustedResourceUrlFromStringKnownToSatisfyTypeContract(\n            trustReason,\n            uriPrefix + module_uri\n          );\n          trusted_uris.push(trusted);\n        });\n        mm.getModuleInfo(key).setTrustedUris(trusted_uris);\n      }\n    });\n\n    shadow.loader.initCalled = true;\n  }\n};\n\nshadow.loader.getModuleManager = function() {\n  return shadow.loader.mm;\n};\n\nshadow.loader.getModuleLoader = function() {\n  return shadow.loader.ml;\n};\n\n// allow calling (shadow.loader/load :with-a-keyword)\nshadow.loader.string_id = function(id) {\n  var result = id.toString();\n  if (result.charAt(0) == \":\") {\n    result = result.substring(1);\n  }\n  return result;\n};\n\nshadow.loader.set_load_start = function(id) {\n  shadow.loader.mm.beforeLoadModuleCode(id);\n};\n\n// FIXME: id no longer required, just keeping it in case someone ends up using old closure lib\nshadow.loader.set_loaded = function(id) {\n  shadow.loader.mm.setLoaded(id);\n};\n\n// ignored. only for cljs.loader compat\nshadow.loader.set_loaded_BANG_ = function() {};\n\nshadow.loader.loaded_QMARK_ = function(id) {\n  return shadow.loader.mm.getModuleInfo(shadow.loader.string_id(id)).isLoaded();\n};\n\nshadow.loader.with_module = function(\n  moduleId,\n  fn,\n  opt_handler,\n  opt_noLoad,\n  opt_userInitiated,\n  opt_preferSynchronous\n) {\n  shadow.loader.ensureInitWasCalled();\n  return shadow.loader.mm.execOnLoad(\n    shadow.loader.string_id(moduleId),\n    fn,\n    opt_handler,\n    opt_noLoad,\n    opt_userInitiated,\n    opt_preferSynchronous\n  );\n};\n\nshadow.loader.load = function(id, cb) {\n  shadow.loader.ensureInitWasCalled();\n  id = shadow.loader.string_id(id);\n  if (cb) {\n    shadow.loader.mm.execOnLoad(id, cb);\n  }\n  return shadow.loader.mm.load(id);\n};\n\nshadow.loader.load_multiple = function(ids, opt_userInitiated) {\n  shadow.loader.ensureInitWasCalled();\n  return shadow.loader.mm.loadMultiple(ids, opt_userInitiated);\n};\n\nshadow.loader.prefetch = function(id) {\n  shadow.loader.ensureInitWasCalled();\n  shadow.loader.mm.prefetchModule(shadow.loader.string_id(id));\n};\n\nshadow.loader.preload = function(id) {\n  shadow.loader.ensureInitWasCalled();\n  return shadow.loader.mm.preloadModule(shadow.loader.string_id(id));\n};\n","^F",1605061761213,"^G",["^H",["~$goog.module.ModuleManager","~$goog","~$goog.object","~$goog.html.uncheckedconversions","~$goog.string.Const","~$goog.module.ModuleLoader"]],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",["shadow.loader"],"^:","es3","^;",null,"^D",[],"^I",["goog.module.ModuleManager","goog.module.ModuleLoader","goog.object","goog.html.uncheckedconversions","goog.string.Const"],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/loader.js"],"^O",["^H",["~$shadow.loader"]],"^P",true,"^Q",["^Y","^X","^11","^Z","^[","^10"]],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$cljs$externs$process","^>","module$shadow$cljs$externs$process.js","^?",["^@","shadow/cljs/externs/process.js"],"^A","shadow/cljs/externs/process.js","^B","^C","^D",[],"^E","/**\n * these things are in cljs.core only they are only relevant to self-hosted\n * hopefully they will be moved out in the future\n *\n * @externs\n */\n\nvar process = {};\n\n// these references must never be renamed since the JS deps might use them\n// since shadow.js defines them :advanced might think it would be safe to\n// rename them\nprocess.browser;\nprocess.env;\nprocess.env.NODE_ENV;\nprocess.argv;\n\n// this is in cljs.core\nprocess.hrtime;\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/cljs/externs/process.js"],"^O",["^H",["^13"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$boot$static","^>","module$shadow$boot$static.js","^?",["^@","shadow/boot/static.js"],"^A","shadow/boot/static.js","^B","^C","^D",[],"^E","var SHADOW_ENV = $CLJS.SHADOW_ENV = (function() {\n    var env = {};\n\n    var loadedFiles = {};\n\n    env.setLoaded = function(name) {\n        loadedFiles[name] = true;\n    };\n\n    env.load = function(opts, paths) {\n        paths.forEach(function(name) {\n            env.setLoaded(name);\n        });\n    };\n\n    env.isLoaded = function(name) {\n        // this is only used by live-reload checking if it should reload a file\n        // since all files will always be loaded we don't really need to track this?\n        return true;\n        // return loadedFiles[name] || false;\n    }\n\n    return env;\n})();\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/boot/static.js"],"^O",["^H",["^14"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$cljs$externs$npm","^>","module$shadow$cljs$externs$npm.js","^?",["^@","shadow/cljs/externs/npm.js"],"^A","shadow/cljs/externs/npm.js","^B","^C","^D",[],"^E","/**\n * @const\n */\nvar $CLJS;\n\n/**\n * @const\n */\nvar module = {};\nmodule.exports;\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/cljs/externs/npm.js"],"^O",["^H",["^15"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$boot$worker","^>","module$shadow$boot$worker.js","^?",["^@","shadow/boot/worker.js"],"^A","shadow/boot/worker.js","^B","^C","^D",[],"^E","var SHADOW_ENV = (function () {\n  var loadedFiles = {};\n\n  var env = {};\n\n  var scriptBase = self.location.href;\n  scriptBase = scriptBase.substring(0, scriptBase.lastIndexOf(\"/\"));\n  env.scriptBase = scriptBase + \"/cljs-runtime/\";\n\n  env.load = function (opts, paths) {\n    paths.forEach(function (path) {\n      if (!loadedFiles[path]) {\n        loadedFiles[path] = true;\n        var uri = 'cljs-runtime/' + path;\n        importScripts(uri);\n      }\n    });\n  }\n\n  env.isLoaded = function (path) {\n    return loadedFiles[path] || false; // false is better than undefined\n  }\n\n  env.setLoaded = function(path) {\n    loadedFiles[path] = true;\n  }\n\n  env.evalLoad = function(path, sourceMap, code) {\n    loadedFiles[path] = true;\n    code += (\"\\n//# sourceURL=\" + scriptBase + path);\n    if (sourceMap) {\n      code += (\"\\n//# sourceMappingURL=\" + scriptBase + path + \".map\");\n    }\n    try {\n      goog.globalEval(code);\n    } catch (e) {\n        console.warn(\"failed to load\", path, e);\n    }\n }\n\n  return env;\n}).call(this);","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/boot/worker.js"],"^O",["^H",["^16"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^>","shadow.js.js","^?",["^@","shadow/js.js"],"^A","shadow/js.js","^B","^W","^E","goog.provide(\"shadow.js\");\n\n/**\n * @dict\n */\nshadow.js.files = {};\n\n/**\n * @dict\n */\nshadow.js.nativeRequires = {};\n\n/**\n * @define {string}\n * all occurences should be removed by NodeEnvInline but for safety we keep it arround\n */\nshadow.js.NODE_ENV = goog.define(\"shadow.js.NODE_ENV\", \"development\");\n\nshadow.js.requireStack = [];\n\nshadow.js.add_native_require = function(name, obj) {\n  shadow.js.nativeRequires[name] = obj;\n};\n\n/**\n * @return {ShadowJS}\n */\nshadow.js.jsRequire = function(name, opts) {\n  var nativeObj = shadow.js.nativeRequires[name];\n  if (nativeObj !== undefined) {\n    return nativeObj;\n  }\n\n  try {\n    if (goog.DEBUG) {\n      if (name instanceof String && name.indexOf(\"/\") != -1) {\n        console.warn(\n          \"Tried to dynamically require '\" +\n            name +\n            \"' from '\" +\n            shadow.js.requireStack[shadow.js.requireStack.length - 1] +\n            \"'. This is not supported and may cause issues.\"\n        );\n      }\n    }\n\n    shadow.js.requireStack.push(name);\n\n    var module = shadow.js.files[name];\n    var moduleFn = shadow$provide[name];\n\n    // module must be created before calling moduleFn due to circular deps\n    if (module === undefined) {\n      if (moduleFn === undefined) {\n        throw (\"Module not provided: \" + name);\n      }\n      module = {};\n      module[\"exports\"] = {};\n      shadow.js.files[name] = module;\n    }\n\n    if (moduleFn) {\n      delete shadow$provide[name];\n\n      try {\n        moduleFn.call(\n          module,\n          goog.global,\n          shadow.js.jsRequire,\n          module,\n          module[\"exports\"]\n        );\n      } catch (e) {\n        console.warn(\"shadow-cljs - failed to load\", name);\n        throw e;\n      }\n\n      if (opts) {\n        var globals = opts[\"globals\"];\n        if (globals) {\n          for (var i = 0; i < globals.length; i++) {\n            window[globals[i]] = module[\"exports\"];\n          }\n        }\n      }\n    }\n  } finally {\n    shadow.js.requireStack.pop();\n  }\n\n  return module[\"exports\"];\n};\n\n// work around issues where libraries try to manipulate require at runtime\n//   codemirror/addon/runmode/runmode.node.js\n// will attempt to replace all\n//   codemirror/lib/codemirror.js\n// requires with itself. in webpack this actually reconfigures require at runtime\n// but does not prevent webpack from including the original codemirror.js in the bundle\n// output. just nothing ever accesses assuming runmode.node.js is loaded first\n// in shadow-cljs this is handled via :package-overrides in the build config\n// which actually prevents including the unwanted file and properly redirects\n// making the runtime calls do nothing instead\nshadow.js.jsRequire.cache = {};\nshadow.js.jsRequire.resolve = function(name) { return name };\n\n/**\n * @dict\n */\nshadow.js.modules = {};\n\nshadow.js.require = function(name, opts) {\n  return shadow.js.jsRequire(name, opts);\n  /*\n  var mod = shadow.js.modules[name];\n\n  if (typeof(mod) == 'undefined') {\n    var exports = shadow.js.jsRequire(name, opts);\n\n    if (exports && exports[\"__esModule\"]) {\n        mod = exports;\n    } else {\n        mod = {\"default\":exports};\n    }\n\n    shadow.js.modules[name] = mod;\n  }\n\n  return mod;\n  */\n};\n","^F",1605061761213,"^G",["^H",["^Y"]],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",["shadow.js"],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/js.js"],"^O",["^H",["~$shadow.js"]],"^P",true,"^Q",["^Y"]],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$build$js$semver","^>","module$shadow$build$js$semver.js","^?",["^@","shadow/build/js/semver.js"],"^A","shadow/build/js/semver.js","^B","^C","^D",[],"^E","// https://raw.githubusercontent.com/npm/node-semver/7be83d15dcff73f6df11b82507e0b9980e183bc2/semver.js\n\nvar exports = SemVer;\n\ndebug = function() {};\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nexports.SEMVER_SPEC_VERSION = '2.0.0';\n\nvar MAX_LENGTH = 256;\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;\n\n// The actual regexps go on exports.re\nvar re = exports.re = [];\nvar src = exports.src = [];\nvar R = 0;\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\nvar NUMERICIDENTIFIER = R++;\nsrc[NUMERICIDENTIFIER] = '0|[1-9]\\\\d*';\nvar NUMERICIDENTIFIERLOOSE = R++;\nsrc[NUMERICIDENTIFIERLOOSE] = '[0-9]+';\n\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\nvar NONNUMERICIDENTIFIER = R++;\nsrc[NONNUMERICIDENTIFIER] = '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*';\n\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\nvar MAINVERSION = R++;\nsrc[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[NUMERICIDENTIFIER] + ')';\n\nvar MAINVERSIONLOOSE = R++;\nsrc[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')';\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\nvar PRERELEASEIDENTIFIER = R++;\nsrc[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +\n                            '|' + src[NONNUMERICIDENTIFIER] + ')';\n\nvar PRERELEASEIDENTIFIERLOOSE = R++;\nsrc[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +\n                                 '|' + src[NONNUMERICIDENTIFIER] + ')';\n\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\nvar PRERELEASE = R++;\nsrc[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +\n                  '(?:\\\\.' + src[PRERELEASEIDENTIFIER] + ')*))';\n\nvar PRERELEASELOOSE = R++;\nsrc[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +\n                       '(?:\\\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\nvar BUILDIDENTIFIER = R++;\nsrc[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\nvar BUILD = R++;\nsrc[BUILD] = '(?:\\\\+(' + src[BUILDIDENTIFIER] +\n             '(?:\\\\.' + src[BUILDIDENTIFIER] + ')*))';\n\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\nvar FULL = R++;\nvar FULLPLAIN = 'v?' + src[MAINVERSION] +\n                src[PRERELEASE] + '?' +\n                src[BUILD] + '?';\n\nsrc[FULL] = '^' + FULLPLAIN + '$';\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\nvar LOOSEPLAIN = '[v=\\\\s]*' + src[MAINVERSIONLOOSE] +\n                 src[PRERELEASELOOSE] + '?' +\n                 src[BUILD] + '?';\n\nvar LOOSE = R++;\nsrc[LOOSE] = '^' + LOOSEPLAIN + '$';\n\nvar GTLT = R++;\nsrc[GTLT] = '((?:<|>)?=?)';\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\nvar XRANGEIDENTIFIERLOOSE = R++;\nsrc[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\\\*';\nvar XRANGEIDENTIFIER = R++;\nsrc[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\\\*';\n\nvar XRANGEPLAIN = R++;\nsrc[XRANGEPLAIN] = '[v=\\\\s]*(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:' + src[PRERELEASE] + ')?' +\n                   src[BUILD] + '?' +\n                   ')?)?';\n\nvar XRANGEPLAINLOOSE = R++;\nsrc[XRANGEPLAINLOOSE] = '[v=\\\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:' + src[PRERELEASELOOSE] + ')?' +\n                        src[BUILD] + '?' +\n                        ')?)?';\n\nvar XRANGE = R++;\nsrc[XRANGE] = '^' + src[GTLT] + '\\\\s*' + src[XRANGEPLAIN] + '$';\nvar XRANGELOOSE = R++;\nsrc[XRANGELOOSE] = '^' + src[GTLT] + '\\\\s*' + src[XRANGEPLAINLOOSE] + '$';\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\nvar LONETILDE = R++;\nsrc[LONETILDE] = '(?:~>?)';\n\nvar TILDETRIM = R++;\nsrc[TILDETRIM] = '(\\\\s*)' + src[LONETILDE] + '\\\\s+';\nre[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');\nvar tildeTrimReplace = '$1~';\n\nvar TILDE = R++;\nsrc[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';\nvar TILDELOOSE = R++;\nsrc[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\nvar LONECARET = R++;\nsrc[LONECARET] = '(?:\\\\^)';\n\nvar CARETTRIM = R++;\nsrc[CARETTRIM] = '(\\\\s*)' + src[LONECARET] + '\\\\s+';\nre[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');\nvar caretTrimReplace = '$1^';\n\nvar CARET = R++;\nsrc[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';\nvar CARETLOOSE = R++;\nsrc[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\nvar COMPARATORLOOSE = R++;\nsrc[COMPARATORLOOSE] = '^' + src[GTLT] + '\\\\s*(' + LOOSEPLAIN + ')$|^$';\nvar COMPARATOR = R++;\nsrc[COMPARATOR] = '^' + src[GTLT] + '\\\\s*(' + FULLPLAIN + ')$|^$';\n\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\nvar COMPARATORTRIM = R++;\nsrc[COMPARATORTRIM] = '(\\\\s*)' + src[GTLT] +\n                      '\\\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';\n\n// this one has to use the /g flag\nre[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');\nvar comparatorTrimReplace = '$1$2$3';\n\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\nvar HYPHENRANGE = R++;\nsrc[HYPHENRANGE] = '^\\\\s*(' + src[XRANGEPLAIN] + ')' +\n                   '\\\\s+-\\\\s+' +\n                   '(' + src[XRANGEPLAIN] + ')' +\n                   '\\\\s*$';\n\nvar HYPHENRANGELOOSE = R++;\nsrc[HYPHENRANGELOOSE] = '^\\\\s*(' + src[XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s+-\\\\s+' +\n                        '(' + src[XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s*$';\n\n// Star ranges basically just allow anything at all.\nvar STAR = R++;\nsrc[STAR] = '(<|>)?=?\\\\s*\\\\*';\n\n// Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\nfor (var i = 0; i < R; i++) {\n  debug(i, src[i]);\n  if (!re[i])\n    re[i] = new RegExp(src[i]);\n}\n\nexports.parse = parse;\nfunction parse(version, loose) {\n  if (version instanceof SemVer)\n    return version;\n\n  if (typeof version !== 'string')\n    return null;\n\n  if (version.length > MAX_LENGTH)\n    return null;\n\n  var r = loose ? re[LOOSE] : re[FULL];\n  if (!r.test(version))\n    return null;\n\n  try {\n    return new SemVer(version, loose);\n  } catch (er) {\n    return null;\n  }\n}\n\nexports.valid = valid;\nfunction valid(version, loose) {\n  var v = parse(version, loose);\n  return v ? v.version : null;\n}\n\n\nexports.clean = clean;\nfunction clean(version, loose) {\n  var s = parse(version.trim().replace(/^[=v]+/, ''), loose);\n  return s ? s.version : null;\n}\n\nexports.SemVer = SemVer;\n\nfunction SemVer(version, loose) {\n  if (version instanceof SemVer) {\n    if (version.loose === loose)\n      return version;\n    else\n      version = version.version;\n  } else if (typeof version !== 'string') {\n    throw new TypeError('Invalid Version: ' + version);\n  }\n\n  if (version.length > MAX_LENGTH)\n    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')\n\n  if (!(this instanceof SemVer))\n    return new SemVer(version, loose);\n\n  debug('SemVer', version, loose);\n  this.loose = loose;\n  var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);\n\n  if (!m)\n    throw new TypeError('Invalid Version: ' + version);\n\n  this.raw = version;\n\n  // these are actually numbers\n  this.major = +m[1];\n  this.minor = +m[2];\n  this.patch = +m[3];\n\n  if (this.major > MAX_SAFE_INTEGER || this.major < 0)\n    throw new TypeError('Invalid major version')\n\n  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)\n    throw new TypeError('Invalid minor version')\n\n  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)\n    throw new TypeError('Invalid patch version')\n\n  // numberify any prerelease numeric ids\n  if (!m[4])\n    this.prerelease = [];\n  else\n    this.prerelease = m[4].split('.').map(function(id) {\n      if (/^[0-9]+$/.test(id)) {\n        var num = +id;\n        if (num >= 0 && num < MAX_SAFE_INTEGER)\n          return num;\n      }\n      return id;\n    });\n\n  this.build = m[5] ? m[5].split('.') : [];\n  this.format();\n}\n\nSemVer.prototype.format = function() {\n  this.version = this.major + '.' + this.minor + '.' + this.patch;\n  if (this.prerelease.length)\n    this.version += '-' + this.prerelease.join('.');\n  return this.version;\n};\n\nSemVer.prototype.toString = function() {\n  return this.version;\n};\n\nSemVer.prototype.compare = function(other) {\n  debug('SemVer.compare', this.version, this.loose, other);\n  if (!(other instanceof SemVer))\n    other = new SemVer(other, this.loose);\n\n  return this.compareMain(other) || this.comparePre(other);\n};\n\nSemVer.prototype.compareMain = function(other) {\n  if (!(other instanceof SemVer))\n    other = new SemVer(other, this.loose);\n\n  return compareIdentifiers(this.major, other.major) ||\n         compareIdentifiers(this.minor, other.minor) ||\n         compareIdentifiers(this.patch, other.patch);\n};\n\nSemVer.prototype.comparePre = function(other) {\n  if (!(other instanceof SemVer))\n    other = new SemVer(other, this.loose);\n\n  // NOT having a prerelease is > having one\n  if (this.prerelease.length && !other.prerelease.length)\n    return -1;\n  else if (!this.prerelease.length && other.prerelease.length)\n    return 1;\n  else if (!this.prerelease.length && !other.prerelease.length)\n    return 0;\n\n  var i = 0;\n  do {\n    var a = this.prerelease[i];\n    var b = other.prerelease[i];\n    debug('prerelease compare', i, a, b);\n    if (a === undefined && b === undefined)\n      return 0;\n    else if (b === undefined)\n      return 1;\n    else if (a === undefined)\n      return -1;\n    else if (a === b)\n      continue;\n    else\n      return compareIdentifiers(a, b);\n  } while (++i);\n};\n\n// preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\nSemVer.prototype.inc = function(release, identifier) {\n  switch (release) {\n    case 'premajor':\n      this.prerelease.length = 0;\n      this.patch = 0;\n      this.minor = 0;\n      this.major++;\n      this.inc('pre', identifier);\n      break;\n    case 'preminor':\n      this.prerelease.length = 0;\n      this.patch = 0;\n      this.minor++;\n      this.inc('pre', identifier);\n      break;\n    case 'prepatch':\n      // If this is already a prerelease, it will bump to the next version\n      // drop any prereleases that might already exist, since they are not\n      // relevant at this point.\n      this.prerelease.length = 0;\n      this.inc('patch', identifier);\n      this.inc('pre', identifier);\n      break;\n    // If the input is a non-prerelease version, this acts the same as\n    // prepatch.\n    case 'prerelease':\n      if (this.prerelease.length === 0)\n        this.inc('patch', identifier);\n      this.inc('pre', identifier);\n      break;\n\n    case 'major':\n      // If this is a pre-major version, bump up to the same major version.\n      // Otherwise increment major.\n      // 1.0.0-5 bumps to 1.0.0\n      // 1.1.0 bumps to 2.0.0\n      if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0)\n        this.major++;\n      this.minor = 0;\n      this.patch = 0;\n      this.prerelease = [];\n      break;\n    case 'minor':\n      // If this is a pre-minor version, bump up to the same minor version.\n      // Otherwise increment minor.\n      // 1.2.0-5 bumps to 1.2.0\n      // 1.2.1 bumps to 1.3.0\n      if (this.patch !== 0 || this.prerelease.length === 0)\n        this.minor++;\n      this.patch = 0;\n      this.prerelease = [];\n      break;\n    case 'patch':\n      // If this is not a pre-release version, it will increment the patch.\n      // If it is a pre-release it will bump up to the same patch version.\n      // 1.2.0-5 patches to 1.2.0\n      // 1.2.0 patches to 1.2.1\n      if (this.prerelease.length === 0)\n        this.patch++;\n      this.prerelease = [];\n      break;\n    // This probably shouldn't be used publicly.\n    // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n    case 'pre':\n      if (this.prerelease.length === 0)\n        this.prerelease = [0];\n      else {\n        var i = this.prerelease.length;\n        while (--i >= 0) {\n          if (typeof this.prerelease[i] === 'number') {\n            this.prerelease[i]++;\n            i = -2;\n          }\n        }\n        if (i === -1) // didn't increment anything\n          this.prerelease.push(0);\n      }\n      if (identifier) {\n        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n        if (this.prerelease[0] === identifier) {\n          if (isNaN(this.prerelease[1]))\n            this.prerelease = [identifier, 0];\n        } else\n          this.prerelease = [identifier, 0];\n      }\n      break;\n\n    default:\n      throw new Error('invalid increment argument: ' + release);\n  }\n  this.format();\n  this.raw = this.version;\n  return this;\n};\n\nexports.inc = inc;\nfunction inc(version, release, loose, identifier) {\n  if (typeof(loose) === 'string') {\n    identifier = loose;\n    loose = undefined;\n  }\n\n  try {\n    return new SemVer(version, loose).inc(release, identifier).version;\n  } catch (er) {\n    return null;\n  }\n}\n\nexports.diff = diff;\nfunction diff(version1, version2) {\n  if (eq(version1, version2)) {\n    return null;\n  } else {\n    var v1 = parse(version1);\n    var v2 = parse(version2);\n    if (v1.prerelease.length || v2.prerelease.length) {\n      for (var key in v1) {\n        if (key === 'major' || key === 'minor' || key === 'patch') {\n          if (v1[key] !== v2[key]) {\n            return 'pre'+key;\n          }\n        }\n      }\n      return 'prerelease';\n    }\n    for (var key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return key;\n        }\n      }\n    }\n  }\n}\n\nexports.compareIdentifiers = compareIdentifiers;\n\nvar numeric = /^[0-9]+$/;\nfunction compareIdentifiers(a, b) {\n  var anum = numeric.test(a);\n  var bnum = numeric.test(b);\n\n  if (anum && bnum) {\n    a = +a;\n    b = +b;\n  }\n\n  return (anum && !bnum) ? -1 :\n         (bnum && !anum) ? 1 :\n         a < b ? -1 :\n         a > b ? 1 :\n         0;\n}\n\nexports.rcompareIdentifiers = rcompareIdentifiers;\nfunction rcompareIdentifiers(a, b) {\n  return compareIdentifiers(b, a);\n}\n\nexports.major = major;\nfunction major(a, loose) {\n  return new SemVer(a, loose).major;\n}\n\nexports.minor = minor;\nfunction minor(a, loose) {\n  return new SemVer(a, loose).minor;\n}\n\nexports.patch = patch;\nfunction patch(a, loose) {\n  return new SemVer(a, loose).patch;\n}\n\nexports.compare = compare;\nfunction compare(a, b, loose) {\n  return new SemVer(a, loose).compare(new SemVer(b, loose));\n}\n\nexports.compareLoose = compareLoose;\nfunction compareLoose(a, b) {\n  return compare(a, b, true);\n}\n\nexports.rcompare = rcompare;\nfunction rcompare(a, b, loose) {\n  return compare(b, a, loose);\n}\n\nexports.sort = sort;\nfunction sort(list, loose) {\n  return list.sort(function(a, b) {\n    return exports.compare(a, b, loose);\n  });\n}\n\nexports.rsort = rsort;\nfunction rsort(list, loose) {\n  return list.sort(function(a, b) {\n    return exports.rcompare(a, b, loose);\n  });\n}\n\nexports.gt = gt;\nfunction gt(a, b, loose) {\n  return compare(a, b, loose) > 0;\n}\n\nexports.lt = lt;\nfunction lt(a, b, loose) {\n  return compare(a, b, loose) < 0;\n}\n\nexports.eq = eq;\nfunction eq(a, b, loose) {\n  return compare(a, b, loose) === 0;\n}\n\nexports.neq = neq;\nfunction neq(a, b, loose) {\n  return compare(a, b, loose) !== 0;\n}\n\nexports.gte = gte;\nfunction gte(a, b, loose) {\n  return compare(a, b, loose) >= 0;\n}\n\nexports.lte = lte;\nfunction lte(a, b, loose) {\n  return compare(a, b, loose) <= 0;\n}\n\nexports.cmp = cmp;\nfunction cmp(a, op, b, loose) {\n  var ret;\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') a = a.version;\n      if (typeof b === 'object') b = b.version;\n      ret = a === b;\n      break;\n    case '!==':\n      if (typeof a === 'object') a = a.version;\n      if (typeof b === 'object') b = b.version;\n      ret = a !== b;\n      break;\n    case '': case '=': case '==': ret = eq(a, b, loose); break;\n    case '!=': ret = neq(a, b, loose); break;\n    case '>': ret = gt(a, b, loose); break;\n    case '>=': ret = gte(a, b, loose); break;\n    case '<': ret = lt(a, b, loose); break;\n    case '<=': ret = lte(a, b, loose); break;\n    default: throw new TypeError('Invalid operator: ' + op);\n  }\n  return ret;\n}\n\nexports.Comparator = Comparator;\nfunction Comparator(comp, loose) {\n  if (comp instanceof Comparator) {\n    if (comp.loose === loose)\n      return comp;\n    else\n      comp = comp.value;\n  }\n\n  if (!(this instanceof Comparator))\n    return new Comparator(comp, loose);\n\n  debug('comparator', comp, loose);\n  this.loose = loose;\n  this.parse(comp);\n\n  if (this.semver === ANY)\n    this.value = '';\n  else\n    this.value = this.operator + this.semver.version;\n\n  debug('comp', this);\n}\n\nvar ANY = {};\nComparator.prototype.parse = function(comp) {\n  var r = this.loose ? re[COMPARATORLOOSE] : re[COMPARATOR];\n  var m = comp.match(r);\n\n  if (!m)\n    throw new TypeError('Invalid comparator: ' + comp);\n\n  this.operator = m[1];\n  if (this.operator === '=')\n    this.operator = '';\n\n  // if it literally is just '>' or '' then allow anything.\n  if (!m[2])\n    this.semver = ANY;\n  else\n    this.semver = new SemVer(m[2], this.loose);\n};\n\nComparator.prototype.toString = function() {\n  return this.value;\n};\n\nComparator.prototype.test = function(version) {\n  debug('Comparator.test', version, this.loose);\n\n  if (this.semver === ANY)\n    return true;\n\n  if (typeof version === 'string')\n    version = new SemVer(version, this.loose);\n\n  return cmp(version, this.operator, this.semver, this.loose);\n};\n\nComparator.prototype.intersects = function(comp, loose) {\n  if (!(comp instanceof Comparator)) {\n    throw new TypeError('a Comparator is required');\n  }\n\n  var rangeTmp;\n\n  if (this.operator === '') {\n    rangeTmp = new Range(comp.value, loose);\n    return satisfies(this.value, rangeTmp, loose);\n  } else if (comp.operator === '') {\n    rangeTmp = new Range(this.value, loose);\n    return satisfies(comp.semver, rangeTmp, loose);\n  }\n\n  var sameDirectionIncreasing =\n    (this.operator === '>=' || this.operator === '>') &&\n    (comp.operator === '>=' || comp.operator === '>');\n  var sameDirectionDecreasing =\n    (this.operator === '<=' || this.operator === '<') &&\n    (comp.operator === '<=' || comp.operator === '<');\n  var sameSemVer = this.semver.version === comp.semver.version;\n  var differentDirectionsInclusive =\n    (this.operator === '>=' || this.operator === '<=') &&\n    (comp.operator === '>=' || comp.operator === '<=');\n  var oppositeDirectionsLessThan =\n    cmp(this.semver, '<', comp.semver, loose) &&\n    ((this.operator === '>=' || this.operator === '>') &&\n    (comp.operator === '<=' || comp.operator === '<'));\n  var oppositeDirectionsGreaterThan =\n    cmp(this.semver, '>', comp.semver, loose) &&\n    ((this.operator === '<=' || this.operator === '<') &&\n    (comp.operator === '>=' || comp.operator === '>'));\n\n  return sameDirectionIncreasing || sameDirectionDecreasing ||\n    (sameSemVer && differentDirectionsInclusive) ||\n    oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;\n};\n\n\nexports.Range = Range;\nfunction Range(range, loose) {\n  if (range instanceof Range) {\n    if (range.loose === loose) {\n      return range;\n    } else {\n      return new Range(range.raw, loose);\n    }\n  }\n\n  if (range instanceof Comparator) {\n    return new Range(range.value, loose);\n  }\n\n  if (!(this instanceof Range))\n    return new Range(range, loose);\n\n  this.loose = loose;\n\n  // First, split based on boolean or ||\n  this.raw = range;\n  this.set = range.split(/\\s*\\|\\|\\s*/).map(function(range) {\n    return this.parseRange(range.trim());\n  }, this).filter(function(c) {\n    // throw out any that are not relevant for whatever reason\n    return c.length;\n  });\n\n  if (!this.set.length) {\n    throw new TypeError('Invalid SemVer Range: ' + range);\n  }\n\n  this.format();\n}\n\nRange.prototype.format = function() {\n  this.range = this.set.map(function(comps) {\n    return comps.join(' ').trim();\n  }).join('||').trim();\n  return this.range;\n};\n\nRange.prototype.toString = function() {\n  return this.range;\n};\n\nRange.prototype.parseRange = function(range) {\n  var loose = this.loose;\n  range = range.trim();\n  debug('range', range, loose);\n  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE];\n  range = range.replace(hr, hyphenReplace);\n  debug('hyphen replace', range);\n  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace);\n  debug('comparator trim', range, re[COMPARATORTRIM]);\n\n  // `~ 1.2.3` => `~1.2.3`\n  range = range.replace(re[TILDETRIM], tildeTrimReplace);\n\n  // `^ 1.2.3` => `^1.2.3`\n  range = range.replace(re[CARETTRIM], caretTrimReplace);\n\n  // normalize spaces\n  range = range.split(/\\s+/).join(' ');\n\n  // At this point, the range is completely trimmed and\n  // ready to be split into comparators.\n\n  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR];\n  var set = range.split(' ').map(function(comp) {\n    return parseComparator(comp, loose);\n  }).join(' ').split(/\\s+/);\n  if (this.loose) {\n    // in loose mode, throw out any that are not valid comparators\n    set = set.filter(function(comp) {\n      return !!comp.match(compRe);\n    });\n  }\n  set = set.map(function(comp) {\n    return new Comparator(comp, loose);\n  });\n\n  return set;\n};\n\nRange.prototype.intersects = function(range, loose) {\n  if (!(range instanceof Range)) {\n    throw new TypeError('a Range is required');\n  }\n\n  return this.set.some(function(thisComparators) {\n    return thisComparators.every(function(thisComparator) {\n      return range.set.some(function(rangeComparators) {\n        return rangeComparators.every(function(rangeComparator) {\n          return thisComparator.intersects(rangeComparator, loose);\n        });\n      });\n    });\n  });\n};\n\n// Mostly just for testing and legacy API reasons\nexports.toComparators = toComparators;\nfunction toComparators(range, loose) {\n  return new Range(range, loose).set.map(function(comp) {\n    return comp.map(function(c) {\n      return c.value;\n    }).join(' ').trim().split(' ');\n  });\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nfunction parseComparator(comp, loose) {\n  debug('comp', comp);\n  comp = replaceCarets(comp, loose);\n  debug('caret', comp);\n  comp = replaceTildes(comp, loose);\n  debug('tildes', comp);\n  comp = replaceXRanges(comp, loose);\n  debug('xrange', comp);\n  comp = replaceStars(comp, loose);\n  debug('stars', comp);\n  return comp;\n}\n\nfunction isX(id) {\n  return !id || id.toLowerCase() === 'x' || id === '*';\n}\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\nfunction replaceTildes(comp, loose) {\n  return comp.trim().split(/\\s+/).map(function(comp) {\n    return replaceTilde(comp, loose);\n  }).join(' ');\n}\n\nfunction replaceTilde(comp, loose) {\n  var r = loose ? re[TILDELOOSE] : re[TILDE];\n  return comp.replace(r, function(_, M, m, p, pr) {\n    debug('tilde', comp, _, M, m, p, pr);\n    var ret;\n\n    if (isX(M))\n      ret = '';\n    else if (isX(m))\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    else if (isX(p))\n      // ~1.2 == >=1.2.0 <1.3.0\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n    else if (pr) {\n      debug('replaceTilde pr', pr);\n      if (pr.charAt(0) !== '-')\n        pr = '-' + pr;\n      ret = '>=' + M + '.' + m + '.' + p + pr +\n            ' <' + M + '.' + (+m + 1) + '.0';\n    } else\n      // ~1.2.3 == >=1.2.3 <1.3.0\n      ret = '>=' + M + '.' + m + '.' + p +\n            ' <' + M + '.' + (+m + 1) + '.0';\n\n    debug('tilde return', ret);\n    return ret;\n  });\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\nfunction replaceCarets(comp, loose) {\n  return comp.trim().split(/\\s+/).map(function(comp) {\n    return replaceCaret(comp, loose);\n  }).join(' ');\n}\n\nfunction replaceCaret(comp, loose) {\n  debug('caret', comp, loose);\n  var r = loose ? re[CARETLOOSE] : re[CARET];\n  return comp.replace(r, function(_, M, m, p, pr) {\n    debug('caret', comp, _, M, m, p, pr);\n    var ret;\n\n    if (isX(M))\n      ret = '';\n    else if (isX(m))\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    else if (isX(p)) {\n      if (M === '0')\n        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n      else\n        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';\n    } else if (pr) {\n      debug('replaceCaret pr', pr);\n      if (pr.charAt(0) !== '-')\n        pr = '-' + pr;\n      if (M === '0') {\n        if (m === '0')\n          ret = '>=' + M + '.' + m + '.' + p + pr +\n                ' <' + M + '.' + m + '.' + (+p + 1);\n        else\n          ret = '>=' + M + '.' + m + '.' + p + pr +\n                ' <' + M + '.' + (+m + 1) + '.0';\n      } else\n        ret = '>=' + M + '.' + m + '.' + p + pr +\n              ' <' + (+M + 1) + '.0.0';\n    } else {\n      debug('no pr');\n      if (M === '0') {\n        if (m === '0')\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + m + '.' + (+p + 1);\n        else\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + (+m + 1) + '.0';\n      } else\n        ret = '>=' + M + '.' + m + '.' + p +\n              ' <' + (+M + 1) + '.0.0';\n    }\n\n    debug('caret return', ret);\n    return ret;\n  });\n}\n\nfunction replaceXRanges(comp, loose) {\n  debug('replaceXRanges', comp, loose);\n  return comp.split(/\\s+/).map(function(comp) {\n    return replaceXRange(comp, loose);\n  }).join(' ');\n}\n\nfunction replaceXRange(comp, loose) {\n  comp = comp.trim();\n  var r = loose ? re[XRANGELOOSE] : re[XRANGE];\n  return comp.replace(r, function(ret, gtlt, M, m, p, pr) {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr);\n    var xM = isX(M);\n    var xm = xM || isX(m);\n    var xp = xm || isX(p);\n    var anyX = xp;\n\n    if (gtlt === '=' && anyX)\n      gtlt = '';\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0';\n      } else {\n        // nothing is forbidden\n        ret = '*';\n      }\n    } else if (gtlt && anyX) {\n      // replace X with 0\n      if (xm)\n        m = 0;\n      if (xp)\n        p = 0;\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        // >1.2.3 => >= 1.2.4\n        gtlt = '>=';\n        if (xm) {\n          M = +M + 1;\n          m = 0;\n          p = 0;\n        } else if (xp) {\n          m = +m + 1;\n          p = 0;\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<';\n        if (xm)\n          M = +M + 1;\n        else\n          m = +m + 1;\n      }\n\n      ret = gtlt + M + '.' + m + '.' + p;\n    } else if (xm) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';\n    } else if (xp) {\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';\n    }\n\n    debug('xRange return', ret);\n\n    return ret;\n  });\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nfunction replaceStars(comp, loose) {\n  debug('replaceStars', comp, loose);\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[STAR], '');\n}\n\n// This function is passed to string.replace(re[HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\nfunction hyphenReplace($0,\n                       from, fM, fm, fp, fpr, fb,\n                       to, tM, tm, tp, tpr, tb) {\n\n  if (isX(fM))\n    from = '';\n  else if (isX(fm))\n    from = '>=' + fM + '.0.0';\n  else if (isX(fp))\n    from = '>=' + fM + '.' + fm + '.0';\n  else\n    from = '>=' + from;\n\n  if (isX(tM))\n    to = '';\n  else if (isX(tm))\n    to = '<' + (+tM + 1) + '.0.0';\n  else if (isX(tp))\n    to = '<' + tM + '.' + (+tm + 1) + '.0';\n  else if (tpr)\n    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;\n  else\n    to = '<=' + to;\n\n  return (from + ' ' + to).trim();\n}\n\n\n// if ANY of the sets match ALL of its comparators, then pass\nRange.prototype.test = function(version) {\n  if (!version)\n    return false;\n\n  if (typeof version === 'string')\n    version = new SemVer(version, this.loose);\n\n  for (var i = 0; i < this.set.length; i++) {\n    if (testSet(this.set[i], version))\n      return true;\n  }\n  return false;\n};\n\nfunction testSet(set, version) {\n  for (var i = 0; i < set.length; i++) {\n    if (!set[i].test(version))\n      return false;\n  }\n\n  if (version.prerelease.length) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (var i = 0; i < set.length; i++) {\n      debug(set[i].semver);\n      if (set[i].semver === ANY)\n        continue;\n\n      if (set[i].semver.prerelease.length > 0) {\n        var allowed = set[i].semver;\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch)\n          return true;\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false;\n  }\n\n  return true;\n}\n\nexports.satisfies = satisfies;\nfunction satisfies(version, range, loose) {\n  try {\n    range = new Range(range, loose);\n  } catch (er) {\n    return false;\n  }\n  return range.test(version);\n}\n\nexports.maxSatisfying = maxSatisfying;\nfunction maxSatisfying(versions, range, loose) {\n  var max = null;\n  var maxSV = null;\n  try {\n    var rangeObj = new Range(range, loose);\n  } catch (er) {\n    return null;\n  }\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) { // satisfies(v, range, loose)\n      if (!max || maxSV.compare(v) === -1) { // compare(max, v, true)\n        max = v;\n        maxSV = new SemVer(max, loose);\n      }\n    }\n  })\n  return max;\n}\n\nexports.minSatisfying = minSatisfying;\nfunction minSatisfying(versions, range, loose) {\n  var min = null;\n  var minSV = null;\n  try {\n    var rangeObj = new Range(range, loose);\n  } catch (er) {\n    return null;\n  }\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) { // satisfies(v, range, loose)\n      if (!min || minSV.compare(v) === 1) { // compare(min, v, true)\n        min = v;\n        minSV = new SemVer(min, loose);\n      }\n    }\n  })\n  return min;\n}\n\nexports.validRange = validRange;\nfunction validRange(range, loose) {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, loose).range || '*';\n  } catch (er) {\n    return null;\n  }\n}\n\n// Determine if version is less than all the versions possible in the range\nexports.ltr = ltr;\nfunction ltr(version, range, loose) {\n  return outside(version, range, '<', loose);\n}\n\n// Determine if version is greater than all the versions possible in the range.\nexports.gtr = gtr;\nfunction gtr(version, range, loose) {\n  return outside(version, range, '>', loose);\n}\n\nexports.outside = outside;\nfunction outside(version, range, hilo, loose) {\n  version = new SemVer(version, loose);\n  range = new Range(range, loose);\n\n  var gtfn, ltefn, ltfn, comp, ecomp;\n  switch (hilo) {\n    case '>':\n      gtfn = gt;\n      ltefn = lte;\n      ltfn = lt;\n      comp = '>';\n      ecomp = '>=';\n      break;\n    case '<':\n      gtfn = lt;\n      ltefn = gte;\n      ltfn = gt;\n      comp = '<';\n      ecomp = '<=';\n      break;\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"');\n  }\n\n  // If it satisifes the range it is not outside\n  if (satisfies(version, range, loose)) {\n    return false;\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i];\n\n    var high = null;\n    var low = null;\n\n    comparators.forEach(function(comparator) {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator;\n      low = low || comparator;\n      if (gtfn(comparator.semver, high.semver, loose)) {\n        high = comparator;\n      } else if (ltfn(comparator.semver, low.semver, loose)) {\n        low = comparator;\n      }\n    });\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false;\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false;\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexports.prerelease = prerelease;\nfunction prerelease(version, loose) {\n  var parsed = parse(version, loose);\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null;\n}\n\nexports.intersects = intersects;\nfunction intersects(r1, r2, loose) {\n  r1 = new Range(r1, loose)\n  r2 = new Range(r2, loose)\n  return r1.intersects(r2)\n}\n\nfunction shadowIntersects(r1, r2) {\n  if (validRange(r1) && validRange(r2)) {\n    return intersects(r1, r2, true);\n  } else {\n    return r1 == r2;\n  }\n}\n","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/build/js/semver.js"],"^O",["^H",["^18"]],"^K",false,"^P",true,"^Q",[],"^L",false],["^ ","^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^>","shadow.js.babel.js","^?",["^@","shadow/js/babel.js"],"^A","shadow/js/babel.js","^B","^W","^E","goog.provide(\"shadow.js.babel\");\n\n/**\n * @dict\n */\nshadow.js.babel = {};\n\nshadow.js.babel[\"interopRequireDefault\"] = function (obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n};\n\nshadow.js.babel[\"interopRequireWildcard\"] = function (obj) {\n  if (obj && obj.__esModule) {\n    return obj;\n  } else {\n    var newObj = {};\n\n    if (obj != null) {\n      for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];\n      }\n    }\n\n    newObj[\"default\"] = obj;\n    return newObj;\n  }\n};\n\ngoog.exportSymbol(\"shadow.js.babel\", shadow.js.babel);","^F",1605061761213,"^G",["^H",["^Y"]],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",["shadow.js.babel"],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/js/babel.js"],"^O",["^H",["~$shadow.js.babel"]],"^P",true,"^Q",["^Y"]],["^ ","^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^>","shadow.cljs_helpers.js","^?",["^@","shadow/cljs_helpers.js"],"^A","shadow/cljs_helpers.js","^B","^W","^E","goog.provide(\"shadow.cljs_helpers\");\ngoog.require(\"goog.object\");\n\nshadow.cljs_helpers.find_protocol_impl = function(protocol, target) {\n  // protocol impls for string,array,object,function,null and lastly default via \"_\"\n  return goog.object.get(protocol, goog.typeOf(target)) || goog.object.get(protocol, \"_\");\n}\n\n// these are called by the emitted CLJS code\n// unused versions will be removed by DCE\n\nshadow.cljs_helpers.maybe_ifn0 = function (target) {\n  return target.cljs$core$IFn$_invoke$arity$0 ? target.cljs$core$IFn$_invoke$arity$0() : target.call(null);\n}\n\nshadow.cljs_helpers.maybe_ifn1 = function (target,a1) {\n  return target.cljs$core$IFn$_invoke$arity$1 ? target.cljs$core$IFn$_invoke$arity$1(a1) : target.call(null,a1);\n}\n\nshadow.cljs_helpers.maybe_ifn2 = function (target,a1,a2) {\n  return target.cljs$core$IFn$_invoke$arity$2 ? target.cljs$core$IFn$_invoke$arity$2(a1,a2) : target.call(null,a1,a2);\n}\n\nshadow.cljs_helpers.maybe_ifn3 = function (target,a1,a2,a3) {\n  return target.cljs$core$IFn$_invoke$arity$3 ? target.cljs$core$IFn$_invoke$arity$3(a1,a2,a3) : target.call(null,a1,a2,a3);\n}\n\nshadow.cljs_helpers.maybe_ifn4 = function (target,a1,a2,a3,a4) {\n  return target.cljs$core$IFn$_invoke$arity$4 ? target.cljs$core$IFn$_invoke$arity$4(a1,a2,a3,a4) : target.call(null,a1,a2,a3,a4);\n}\n\nshadow.cljs_helpers.maybe_ifn5 = function (target,a1,a2,a3,a4,a5) {\n  return target.cljs$core$IFn$_invoke$arity$5 ? target.cljs$core$IFn$_invoke$arity$5(a1,a2,a3,a4,a5) : target.call(null,a1,a2,a3,a4,a5);\n}\n\nshadow.cljs_helpers.maybe_ifn6 = function (target,a1,a2,a3,a4,a5,a6) {\n  return target.cljs$core$IFn$_invoke$arity$6 ? target.cljs$core$IFn$_invoke$arity$6(a1,a2,a3,a4,a5,a6) : target.call(null,a1,a2,a3,a4,a5,a6);\n}\n\nshadow.cljs_helpers.maybe_ifn7 = function (target,a1,a2,a3,a4,a5,a6,a7) {\n  return target.cljs$core$IFn$_invoke$arity$7 ? target.cljs$core$IFn$_invoke$arity$7(a1,a2,a3,a4,a5,a6,a7) : target.call(null,a1,a2,a3,a4,a5,a6,a7);\n}\n\nshadow.cljs_helpers.maybe_ifn8 = function (target,a1,a2,a3,a4,a5,a6,a7,a8) {\n  return target.cljs$core$IFn$_invoke$arity$8 ? target.cljs$core$IFn$_invoke$arity$8(a1,a2,a3,a4,a5,a6,a7,a8) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8);\n}\n\nshadow.cljs_helpers.maybe_ifn9 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9) {\n  return target.cljs$core$IFn$_invoke$arity$9 ? target.cljs$core$IFn$_invoke$arity$9(a1,a2,a3,a4,a5,a6,a7,a8,a9) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9);\n}\n\nshadow.cljs_helpers.maybe_ifn10 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) {\n  return target.cljs$core$IFn$_invoke$arity$10 ? target.cljs$core$IFn$_invoke$arity$10(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);\n}\n\nshadow.cljs_helpers.maybe_ifn11 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) {\n  return target.cljs$core$IFn$_invoke$arity$11 ? target.cljs$core$IFn$_invoke$arity$11(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11);\n}\n\nshadow.cljs_helpers.maybe_ifn12 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) {\n  return target.cljs$core$IFn$_invoke$arity$12 ? target.cljs$core$IFn$_invoke$arity$12(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);\n}\n\nshadow.cljs_helpers.maybe_ifn13 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13) {\n  return target.cljs$core$IFn$_invoke$arity$13 ? target.cljs$core$IFn$_invoke$arity$13(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13);\n}\n\nshadow.cljs_helpers.maybe_ifn14 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14) {\n  return target.cljs$core$IFn$_invoke$arity$14 ? target.cljs$core$IFn$_invoke$arity$14(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14);\n}\n\nshadow.cljs_helpers.maybe_ifn15 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) {\n  return target.cljs$core$IFn$_invoke$arity$15 ? target.cljs$core$IFn$_invoke$arity$15(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);\n}\n\nshadow.cljs_helpers.maybe_ifn16 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16) {\n  return target.cljs$core$IFn$_invoke$arity$16 ? target.cljs$core$IFn$_invoke$arity$16(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16);\n}\n\nshadow.cljs_helpers.maybe_ifn17 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17) {\n  return target.cljs$core$IFn$_invoke$arity$17 ? target.cljs$core$IFn$_invoke$arity$17(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17);\n}\n\nshadow.cljs_helpers.maybe_ifn18 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18) {\n  return target.cljs$core$IFn$_invoke$arity$18 ? target.cljs$core$IFn$_invoke$arity$18(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18);\n}\n\nshadow.cljs_helpers.maybe_ifn19 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19) {\n  return target.cljs$core$IFn$_invoke$arity$19 ? target.cljs$core$IFn$_invoke$arity$19(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19);\n}\n\nshadow.cljs_helpers.maybe_ifn20 = function (target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20) {\n  return target.cljs$core$IFn$_invoke$arity$20 ? target.cljs$core$IFn$_invoke$arity$20(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20) : target.call(null,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20);\n}\n\n// :fn-invoke-direct support\n\nshadow.cljs_helpers.maybe_ifn0_direct = function(target) {\n  return target.cljs$core$IFn$_invoke$arity$0 ? target.cljs$core$IFn$_invoke$arity$0() : target();\n}\n\nshadow.cljs_helpers.maybe_ifn1_direct = function(target,a1) {\n  return target.cljs$core$IFn$_invoke$arity$1 ? target.cljs$core$IFn$_invoke$arity$1(a1) : target(a1);\n}\n\nshadow.cljs_helpers.maybe_ifn2_direct = function(target,a1,a2) {\n  return target.cljs$core$IFn$_invoke$arity$2 ? target.cljs$core$IFn$_invoke$arity$2(a1,a2) : target(a1,a2);\n}\n\nshadow.cljs_helpers.maybe_ifn3_direct = function(target,a1,a2,a3) {\n  return target.cljs$core$IFn$_invoke$arity$3 ? target.cljs$core$IFn$_invoke$arity$3(a1,a2,a3) : target(a1,a2,a3);\n}\n\nshadow.cljs_helpers.maybe_ifn4_direct = function(target,a1,a2,a3,a4) {\n  return target.cljs$core$IFn$_invoke$arity$4 ? target.cljs$core$IFn$_invoke$arity$4(a1,a2,a3,a4) : target(a1,a2,a3,a4);\n}\n\nshadow.cljs_helpers.maybe_ifn5_direct = function(target,a1,a2,a3,a4,a5) {\n  return target.cljs$core$IFn$_invoke$arity$5 ? target.cljs$core$IFn$_invoke$arity$5(a1,a2,a3,a4,a5) : target(a1,a2,a3,a4,a5);\n}\n\nshadow.cljs_helpers.maybe_ifn6_direct = function(target,a1,a2,a3,a4,a5,a6) {\n  return target.cljs$core$IFn$_invoke$arity$6 ? target.cljs$core$IFn$_invoke$arity$6(a1,a2,a3,a4,a5,a6) : target(a1,a2,a3,a4,a5,a6);\n}\n\nshadow.cljs_helpers.maybe_ifn7_direct = function(target,a1,a2,a3,a4,a5,a6,a7) {\n  return target.cljs$core$IFn$_invoke$arity$7 ? target.cljs$core$IFn$_invoke$arity$7(a1,a2,a3,a4,a5,a6,a7) : target(a1,a2,a3,a4,a5,a6,a7);\n}\n\nshadow.cljs_helpers.maybe_ifn8_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8) {\n  return target.cljs$core$IFn$_invoke$arity$8 ? target.cljs$core$IFn$_invoke$arity$8(a1,a2,a3,a4,a5,a6,a7,a8) : target(a1,a2,a3,a4,a5,a6,a7,a8);\n}\n\nshadow.cljs_helpers.maybe_ifn9_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9) {\n  return target.cljs$core$IFn$_invoke$arity$9 ? target.cljs$core$IFn$_invoke$arity$9(a1,a2,a3,a4,a5,a6,a7,a8,a9) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9);\n}\n\nshadow.cljs_helpers.maybe_ifn10_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) {\n  return target.cljs$core$IFn$_invoke$arity$10 ? target.cljs$core$IFn$_invoke$arity$10(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);\n}\n\nshadow.cljs_helpers.maybe_ifn11_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) {\n  return target.cljs$core$IFn$_invoke$arity$11 ? target.cljs$core$IFn$_invoke$arity$11(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11);\n}\n\nshadow.cljs_helpers.maybe_ifn12_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) {\n  return target.cljs$core$IFn$_invoke$arity$12 ? target.cljs$core$IFn$_invoke$arity$12(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);\n}\n\nshadow.cljs_helpers.maybe_ifn13_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13) {\n  return target.cljs$core$IFn$_invoke$arity$13 ? target.cljs$core$IFn$_invoke$arity$13(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13);\n}\n\nshadow.cljs_helpers.maybe_ifn14_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14) {\n  return target.cljs$core$IFn$_invoke$arity$14 ? target.cljs$core$IFn$_invoke$arity$14(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14);\n}\n\nshadow.cljs_helpers.maybe_ifn15_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) {\n  return target.cljs$core$IFn$_invoke$arity$15 ? target.cljs$core$IFn$_invoke$arity$15(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15);\n}\n\nshadow.cljs_helpers.maybe_ifn16_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16) {\n  return target.cljs$core$IFn$_invoke$arity$16 ? target.cljs$core$IFn$_invoke$arity$16(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16);\n}\n\nshadow.cljs_helpers.maybe_ifn17_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17) {\n  return target.cljs$core$IFn$_invoke$arity$17 ? target.cljs$core$IFn$_invoke$arity$17(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17);\n}\n\nshadow.cljs_helpers.maybe_ifn18_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18) {\n  return target.cljs$core$IFn$_invoke$arity$18 ? target.cljs$core$IFn$_invoke$arity$18(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18);\n}\n\nshadow.cljs_helpers.maybe_ifn19_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19) {\n  return target.cljs$core$IFn$_invoke$arity$19 ? target.cljs$core$IFn$_invoke$arity$19(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19);\n}\n\nshadow.cljs_helpers.maybe_ifn20_direct = function(target,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20) {\n  return target.cljs$core$IFn$_invoke$arity$20 ? target.cljs$core$IFn$_invoke$arity$20(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20) : target(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20);\n}\n\n\n\n\n\n\n\n\n","^F",1605061761213,"^G",["^H",["^Y","^Z"]],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",["shadow.cljs_helpers"],"^:","es3","^;",null,"^D",[],"^I",["goog.object"],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/cljs_helpers.js"],"^O",["^H",["~$shadow.cljs-helpers","~$shadow.cljs_helpers"]],"^P",true,"^Q",["^Y","^Z"]],["^ ","^3",[],"^4",true,"^5",false,"^6",["a8b89050e877436ecc7f58bd6d199cd8d399a9b5"],"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^<","~$module$shadow$cljs$externs$node","^>","module$shadow$cljs$externs$node.js","^?",["^@","shadow/cljs/externs/node.js"],"^A","shadow/cljs/externs/node.js","^B","^C","^D",[],"^E","/**\n * these things are in cljs.core only they are only relevant to self-hosted\n * hopefully they will be moved out in the future\n *\n * @externs\n */\n\nError.prototype.number;\nError.prototype.columnNumber;\n\n/**\n * @const\n */\nvar global;\n\n/** @const {string} */\nvar __filename;\n\n/** @const {string} */\nvar __dirname;\n\n/**\n * @param {string} name\n * @return {?}\n */\nfunction require(name) {}\n\n\n/**\n * @dict\n */\nvar shadow$provide = {};\n\n/**\n * @dict\n */\nvar shadow$modules = {};\n\n\nvar shadow$umd$export = {};\n\n\n/**\n * @param {string} name\n * @const\n */\nvar Java = {};\nJava.type = function(name) {};\n\n/**\n * leaflet.js will always create a window.L global\n * this can lead to very hard to debug errors in :advanced builds\n * https://github.com/Leaflet/Leaflet/pull/2943\n *\n * just reserving it always doesn't harm builds that don't use it\n * @const\n */\nvar L = {};","^F",1605061761213,"^G",["^H",[]],"^I",[],"^J",["^ ","^3",[],"^5",false,"^7",[],"^8",[],"^9",[],"^:","es3","^;",null,"^D",[],"^I",[],"^K",false,"^L",false],"^M",["^N","jar:file:/Users/tombowden/.m2/repository/thheller/shadow-cljs/2.11.7/shadow-cljs-2.11.7-aot.jar!/shadow/cljs/externs/node.js"],"^O",["^H",["^1<"]],"^K",false,"^P",true,"^Q",[],"^L",false]],"~:data-readers",null,"~:shadow.build.classpath/CACHE-TIMESTAMP",1605061761000]