["^ ","~:foreign-libs",[],"~:externs",[],"~:resources",[["^ ","~:cache-key",[1569048066000],"~:output-name","com.cognitect.transit.eq.js","~:resource-id",["~:shadow.build.classpath/resource","com/cognitect/transit/eq.js"],"~:resource-name","com/cognitect/transit/eq.js","~:type","~:goog","~:source","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.eq\");\ngoog.require(\"com.cognitect.transit.util\");\n\ngoog.scope(function() {\n\nvar eq   = com.cognitect.transit.eq,\n    util = com.cognitect.transit.util;\n\n/**\n * @const\n * @type {string}\n */\neq.hashCodeProperty = \"transit$hashCode$\";\n\n/**\n * @type {number}\n */\neq.hashCodeCounter = 1;\n\neq.equals = function (x, y) {\n    if(x == null) {\n        return y == null;\n    } else if(x === y) {\n        return true;\n    } else if(typeof x === \"object\") {\n        if(util.isArray(x)) {\n            if(util.isArray(y)) {\n                if(x.length === y.length) {\n                    for(var i = 0; i < x.length; i++) {\n                        if(!eq.equals(x[i], y[i])) {\n                            return false;\n                        }\n                    }\n                    return true;\n                } else {\n                    return false;\n                }\n            } else {\n                return false;\n            }\n        } else if(x.com$cognitect$transit$equals) {\n            return x.com$cognitect$transit$equals(y);\n        } else if((y != null) && (typeof y === \"object\")) {\n            if(y.com$cognitect$transit$equals) {\n                return y.com$cognitect$transit$equals(x);\n            } else {\n                var xklen = 0,\n                    yklen = util.objectKeys(y).length;\n                for(var p in x) {\n                    if(!x.hasOwnProperty(p)) continue;\n                    xklen++;\n                    if(!y.hasOwnProperty(p)) {\n                        return false;\n                    } else {\n                        if(!eq.equals(x[p], y[p])) {\n                            return false;\n                        }\n                    }\n                }\n                return xklen === yklen;\n            }\n        } else {\n            return false;\n        }\n    } else {\n        return false\n    }\n};\n\neq.hashCombine = function(seed, hash) {\n    return seed ^ (hash + 0x9e3779b9 + (seed << 6) + (seed >> 2));\n};\n\neq.stringCodeCache     = {};\neq.stringCodeCacheSize = 0;\n\n/**\n * @const\n * @type {number}\n */\neq.STR_CACHE_MAX       = 256;\n\neq.hashString = function(str) {\n    // a la goog.string.HashCode\n    // http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1206\n    var cached = eq.stringCodeCache[str];\n    if(cached != null) {\n        return cached;\n    }\n    var code = 0;\n    for (var i = 0; i < str.length; ++i) {\n        code = 31 * code + str.charCodeAt(i);\n        code %= 0x100000000;\n    }\n    eq.stringCodeCacheSize++;\n    if(eq.stringCodeCacheSize >= eq.STR_CACHE_MAX) {\n        eq.stringCodeCache = {};\n        eq.stringCodeCacheSize = 1;\n    }\n    eq.stringCodeCache[str] = code;\n    return code;\n};\n\neq.hashMapLike = function(m) {\n    var code = 0;\n    // ES6 Map-like case\n    if(m.forEach != null) {\n        m.forEach(function(val, key, m) {\n            code = (code + (eq.hashCode(key) ^ eq.hashCode(val))) % 4503599627370496;\n        });\n    } else {\n        // JS Object case\n        var keys = util.objectKeys(m);\n        for(var i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            var val = m[key];\n            code = (code + (eq.hashCode(key) ^ eq.hashCode(val))) % 4503599627370496;\n        }\n    }\n    return code;\n};\n\neq.hashArrayLike = function(arr) {\n    var code = 0;\n    if(util.isArray(arr)) {\n        for(var i = 0; i < arr.length; i++) {\n            code = eq.hashCombine(code, eq.hashCode(arr[i]));\n        }\n    } else if(arr.forEach) {\n        arr.forEach(function(x, i) {\n            code = eq.hashCombine(code, eq.hashCode(x));\n        });\n    }\n    return code;\n};\n\neq.hashCode = function(x) {\n    if(x == null) {\n        return 0;\n    } else {\n        switch(typeof x) {\n        case 'number':\n            return x;\n            break;\n        case 'boolean':\n            return x === true ? 1 : 0;\n            break;\n        case 'string':\n            return eq.hashString(x);\n            break;\n        case 'function':\n            var code = x[eq.hashCodeProperty];\n            if(code) {\n                return code;\n            } else {\n                code = eq.hashCodeCounter;\n                if(typeof Object.defineProperty != \"undefined\") {\n                    Object.defineProperty(x, eq.hashCodeProperty, {\n                        value: code,\n                        enumerable: false\n                    });\n                } else {\n                    x[eq.hashCodeProperty] = code;\n                }\n                eq.hashCodeCounter++;    \n                return code;\n            }\n            break;\n        default:\n            if(x instanceof Date) {\n                return x.valueOf();\n            } else if(util.isArray(x)) {\n                return eq.hashArrayLike(x);\n            } if(x.com$cognitect$transit$hashCode) {\n                return x.com$cognitect$transit$hashCode();\n            } else {\n                return eq.hashMapLike(x);\n            }\n            break;\n        }\n    }\n}\n\neq.extendToEQ = function(obj, opts) {\n    obj.com$cognitect$transit$hashCode = opts[\"hashCode\"];\n    obj.com$cognitect$transit$equals = opts[\"equals\"];\n    return obj;\n}\n\n});\n","~:last-modified",1569048066000,"~:requires",["~#set",["~$com.cognitect.transit.util","~$goog"]],"~:pom-info",["^ ","~:group-id","~$com.cognitect","~:artifact-id","~$transit-js","~:version","0.8.846","~:name","transit-js","~:description","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","~:url","http://github.com/cognitect/transit-js","~:id","~$com.cognitect/transit-js","~:coordinate",["^J","0.8.846"]],"^H",["~#url","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/eq.js"],"~:provides",["^=",["~$com.cognitect.transit.eq"]],"~:from-jar",true,"~:deps",["^?","^>"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.delimiters.js","^5",["^6","com/cognitect/transit/delimiters.js"],"^7","com/cognitect/transit/delimiters.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.delimiters\");\n\ngoog.scope(function() {\n\nvar delimiters = com.cognitect.transit.delimiters;\n    \n/**\n * @const\n * @type {string}\n */\ndelimiters.ESC     = \"~\";\n\n/**\n * @const\n * @type {string}\n */\ndelimiters.TAG     = \"#\";\n\n/**\n * @const\n * @type {string}\n */\ndelimiters.SUB     = \"^\";\n\n/**\n * @const\n * @type {string}\n */\ndelimiters.RES     = \"`\";\n\n/**\n * @const\n * @type {string}\n */\ndelimiters.ESC_TAG = \"~#\";\n\n});\n","^;",1569048066000,"^<",["^=",["^?"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/delimiters.js"],"^M",["^=",["~$com.cognitect.transit.delimiters"]],"^O",true,"^P",["^?"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.handlers.js","^5",["^6","com/cognitect/transit/handlers.js"],"^7","com/cognitect/transit/handlers.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.handlers\");\ngoog.require(\"com.cognitect.transit.util\");\ngoog.require(\"com.cognitect.transit.types\");\ngoog.require(\"goog.math.Long\");\n\ngoog.scope(function () {\n\n    var handlers = com.cognitect.transit.handlers,\n        util     = com.cognitect.transit.util,\n        types    = com.cognitect.transit.types,\n        Long     = goog.math.Long;\n\n    handlers.ctorGuid = 0;\n\n    /**\n     * @const\n     * @type {string}\n     */\n    handlers.ctorGuidProperty = \"transit$guid$\" + util.randomUUID();\n\n    handlers.typeTag = function (ctor) {\n        if (ctor == null) {\n            return \"null\";\n        } else if (ctor === String) {\n            return \"string\";\n        } else if (ctor === Boolean) {\n            return \"boolean\";\n        } else if (ctor === Number) {\n            return \"number\";\n        } else if (ctor === Array) {\n            return \"array\";\n        } else if (ctor === Object) {\n            return \"map\";\n        } else {\n            var tag = ctor[handlers.ctorGuidProperty];\n            if (tag == null) {\n                if (typeof Object.defineProperty != \"undefined\") {\n                    tag = ++handlers.ctorGuid;\n                    Object.defineProperty(ctor, handlers.ctorGuidProperty, {\n                        value: tag,\n                        enumerable: false\n                    });\n                } else {\n                    ctor[handlers.ctorGuidProperty] = tag = ++handlers.ctorGuid;\n                }\n            }\n            return tag;\n        }\n    };\n\n    handlers.constructor = function (x) {\n        if (x == null) {\n            return null;\n        } else {\n            return x.constructor;\n        }\n    };\n\n    handlers.padZeros = function (n, m) {\n        var s = n.toString();\n        for (var i = s.length; i < m; i++) {\n            s = \"0\" + s;\n        }\n        return s;\n    };\n\n    handlers.stringableKeys = function (m) {\n        var stringable = false,\n            ks = util.objectKeys(m);\n\n        for (var i = 0; i < ks.length; i++) {\n        }\n\n        return true;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.NilHandler = function Transit$NilHandler() {\n    };\n    handlers.NilHandler.prototype.tag = function (v) {\n        return \"_\";\n    };\n    handlers.NilHandler.prototype.rep = function (v) {\n        return null;\n    };\n    handlers.NilHandler.prototype.stringRep = function (v) {\n        return \"null\";\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.StringHandler = function Transit$StringHandler() {\n    };\n    handlers.StringHandler.prototype.tag = function (v) {\n        return \"s\";\n    };\n    handlers.StringHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.StringHandler.prototype.stringRep = function (v) {\n        return v;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.NumberHandler = function Transit$NumberHandler() {\n    };\n    handlers.NumberHandler.prototype.tag = function (v) {\n        return \"i\";\n    };\n    handlers.NumberHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.NumberHandler.prototype.stringRep = function (v) {\n        return v.toString();\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.IntegerHandler = function Transit$IntegerHandler() {\n    };\n    handlers.IntegerHandler.prototype.tag = function (v) {\n        return \"i\";\n    };\n    handlers.IntegerHandler.prototype.rep = function (v) {\n        return v.toString();\n    };\n    handlers.IntegerHandler.prototype.stringRep = function (v) {\n        return v.toString();\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.BooleanHandler = function Transit$BooleanHandler() {\n    };\n    handlers.BooleanHandler.prototype.tag = function (v) {\n        return \"?\";\n    };\n    handlers.BooleanHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.BooleanHandler.prototype.stringRep = function (v) {\n        return v.toString();\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.ArrayHandler = function Transit$ArrayHandler() {\n    };\n    handlers.ArrayHandler.prototype.tag = function (v) {\n        return \"array\";\n    };\n    handlers.ArrayHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.ArrayHandler.prototype.stringRep = function (v) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.MapHandler = function Transit$MapHandler() {\n    };\n    handlers.MapHandler.prototype.tag = function (v) {\n        return \"map\";\n    };\n    handlers.MapHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.MapHandler.prototype.stringRep = function (v) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.VerboseDateHandler = function Transit$VerboseDateHandler() {\n    };\n    handlers.VerboseDateHandler.prototype.tag = function (v) {\n        return \"t\";\n    };\n    handlers.VerboseDateHandler.prototype.rep = function (v) {\n        return v.getUTCFullYear() + \"-\" + handlers.padZeros(v.getUTCMonth() + 1, 2) + \"-\" +\n            handlers.padZeros(v.getUTCDate(), 2) + \"T\" + handlers.padZeros(v.getUTCHours(), 2) + \":\" +\n            handlers.padZeros(v.getUTCMinutes(), 2) + \":\" + handlers.padZeros(v.getUTCSeconds(), 2) + \".\" +\n            handlers.padZeros(v.getUTCMilliseconds(), 3) + \"Z\";\n    };\n    handlers.VerboseDateHandler.prototype.stringRep = function (v, h) {\n        return h.rep(v);\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.DateHandler = function Transit$DateHandler() {\n    };\n    handlers.DateHandler.prototype.tag = function (v) {\n        return \"m\";\n    };\n    handlers.DateHandler.prototype.rep = function (v) {\n        return v.valueOf();\n    };\n    handlers.DateHandler.prototype.stringRep = function (v) {\n        return v.valueOf().toString();\n    };\n    handlers.DateHandler.prototype.getVerboseHandler = function (v) {\n        return new handlers.VerboseDateHandler();\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.UUIDHandler = function Transit$UUIDHandler() {\n    };\n    handlers.UUIDHandler.prototype.tag = function (v) {\n        return \"u\";\n    };\n    handlers.UUIDHandler.prototype.rep = function (v) {\n        return v.toString();\n    };\n    handlers.UUIDHandler.prototype.stringRep = function (v) {\n        return v.toString();\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.KeywordHandler = function Transit$KeywordHandler() {\n    };\n    handlers.KeywordHandler.prototype.tag = function (v) {\n        return \":\";\n    };\n    handlers.KeywordHandler.prototype.rep = function (v) {\n        return v._name;\n    }; // NOTE: should be fqn\n    handlers.KeywordHandler.prototype.stringRep = function (v, h) {\n        return h.rep(v);\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.SymbolHandler = function Transit$SymbolHandler() {\n    };\n    handlers.SymbolHandler.prototype.tag = function (v) {\n        return \"$\";\n    };\n    handlers.SymbolHandler.prototype.rep = function (v) {\n        return v._name;\n    }; // NOTE: should be str\n    handlers.SymbolHandler.prototype.stringRep = function (v, h) {\n        return h.rep(v);\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.TaggedHandler = function Transit$TaggedHandler() {\n    };\n    handlers.TaggedHandler.prototype.tag = function (v) {\n        return v.tag;\n    };\n    handlers.TaggedHandler.prototype.rep = function (v) {\n        return v.rep;\n    };\n    handlers.TaggedHandler.prototype.stringRep = function (v, h) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.TransitSetHandler = function Transit$TransitSetHandler() {\n    };\n    handlers.TransitSetHandler.prototype.tag = function (v) {\n        return \"set\";\n    };\n    handlers.TransitSetHandler.prototype.rep = function (v) {\n        var arr = [];\n        v.forEach(function (key, set) {\n            arr.push(key);\n        });\n        return types.taggedValue(\"array\", arr);\n    };\n    handlers.TransitSetHandler.prototype.stringRep = function (v, h) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.TransitArrayMapHandler = function Transit$ArrayMapHandler() {\n    };\n    handlers.TransitArrayMapHandler.prototype.tag = function (v) {\n        return \"map\";\n    };\n    handlers.TransitArrayMapHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.TransitArrayMapHandler.prototype.stringRep = function (v, h) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.TransitMapHandler = function Transit$MapHandler() {\n    };\n    handlers.TransitMapHandler.prototype.tag = function (v) {\n        return \"map\";\n    };\n    handlers.TransitMapHandler.prototype.rep = function (v) {\n        return v;\n    };\n    handlers.TransitMapHandler.prototype.stringRep = function (v, h) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.BufferHandler = function Transit$BufferHandler() {\n    };\n    handlers.BufferHandler.prototype.tag = function (v) {\n        return \"b\";\n    };\n    handlers.BufferHandler.prototype.rep = function (v) {\n        return v.toString(\"base64\");\n    };\n    handlers.BufferHandler.prototype.stringRep = function (v, h) {\n        return null;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.Uint8ArrayHandler = function Transit$Uint8ArrayHandler() {\n    };\n    handlers.Uint8ArrayHandler.prototype.tag = function (v) {\n        return \"b\";\n    };\n    handlers.Uint8ArrayHandler.prototype.rep = function (v) {\n        return util.Uint8ToBase64(v);\n    };\n    handlers.Uint8ArrayHandler.prototype.stringRep = function (v, h) {\n        return null;\n    };\n\n    handlers.defaultHandlers = function (hs) {\n        hs.set(null, new handlers.NilHandler());\n        hs.set(String, new handlers.StringHandler());\n        hs.set(Number, new handlers.NumberHandler());\n        hs.set(Long, new handlers.IntegerHandler());\n        hs.set(Boolean, new handlers.BooleanHandler());\n        hs.set(Array, new handlers.ArrayHandler());\n        hs.set(Object, new handlers.MapHandler());\n        hs.set(Date, new handlers.DateHandler());\n        hs.set(types.UUID, new handlers.UUIDHandler());\n        hs.set(types.Keyword, new handlers.KeywordHandler());\n        hs.set(types.Symbol, new handlers.SymbolHandler());\n        hs.set(types.TaggedValue, new handlers.TaggedHandler());\n        hs.set(types.TransitSet, new handlers.TransitSetHandler());\n        hs.set(types.TransitArrayMap, new handlers.TransitArrayMapHandler());\n        hs.set(types.TransitMap, new handlers.TransitMapHandler());\n\n        if (typeof Buffer != \"undefined\") {\n            hs.set(Buffer, new handlers.BufferHandler());\n        }\n\n        if (typeof Uint8Array != \"undefined\") {\n            hs.set(Uint8Array, new handlers.Uint8ArrayHandler());\n        }\n\n        return hs;\n    };\n\n    /**\n     * @constructor\n     */\n    handlers.Handlers = function Transit$Handlers() {\n        this.handlers = {};\n        handlers.defaultHandlers(this);\n    };\n\n    handlers.Handlers.prototype.get = function (ctor) {\n        var h = null;\n        if (typeof ctor === \"string\") {\n            h = this.handlers[ctor];\n        } else {\n            h = this.handlers[handlers.typeTag(ctor)];\n        }\n        if (h != null) {\n            return h;\n        } else {\n            return this.handlers[\"default\"];\n        }\n    };\n    handlers.Handlers.prototype[\"get\"] = handlers.Handlers.prototype.get;\n\n    handlers.validTag = function (tag) {\n        switch (tag) {\n            case \"null\":\n            case \"string\":\n            case \"boolean\":\n            case \"number\":\n            case \"array\":\n            case \"map\":\n                return false;\n                break;\n        }\n        return true;\n    };\n\n    handlers.Handlers.prototype.set = function (ctor, handler) {\n        if (typeof ctor === \"string\" && handlers.validTag(ctor)) {\n            this.handlers[ctor] = handler;\n        } else {\n            this.handlers[handlers.typeTag(ctor)] = handler;\n        }\n    };\n\n});    \n","^;",1569048066000,"^<",["^=",["^>","^?","~$com.cognitect.transit.types","~$goog.math.Long"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/handlers.js"],"^M",["^=",["~$com.cognitect.transit.handlers"]],"^O",true,"^P",["^?","^>","^R","^S"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.js","^5",["^6","com/cognitect/transit.js"],"^7","com/cognitect/transit.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n\"use strict\";\n\ngoog.provide(\"com.cognitect.transit\");\ngoog.require(\"com.cognitect.transit.util\");\ngoog.require(\"com.cognitect.transit.impl.reader\");\ngoog.require(\"com.cognitect.transit.impl.writer\");\ngoog.require(\"com.cognitect.transit.types\");\ngoog.require(\"com.cognitect.transit.eq\");\ngoog.require(\"com.cognitect.transit.impl.decoder\");\ngoog.require(\"com.cognitect.transit.caching\");\n\n/** @define {boolean} */\nvar TRANSIT_DEV = true;\n\n/** @define {boolean} */\nvar TRANSIT_NODE_TARGET = false;\n\n/** @define {boolean} */\nvar TRANSIT_BROWSER_TARGET = false;\n\n/** @define {boolean} */\nvar TRANSIT_BROWSER_AMD_TARGET = false;\n\ngoog.scope(function() {\n\n    /**\n     * @class transit\n     */\n    var transit = com.cognitect.transit;\n\n    var util    = com.cognitect.transit.util,\n        reader  = com.cognitect.transit.impl.reader,\n        writer  = com.cognitect.transit.impl.writer,\n        decoder = com.cognitect.transit.impl.decoder,\n        types   = com.cognitect.transit.types,\n        eq      = com.cognitect.transit.eq,\n        caching = com.cognitect.transit.caching;\n\n    /**\n     * @typedef {Map|com.cognitect.transit.types.TransitArrayMap|com.cognitect.transit.types.TransitMap}\n     */\n    transit.MapLike;\n\n    /**\n     * @typedef {Set|com.cognitect.transit.types.TransitSet}\n     */\n    transit.SetLike;\n\n    /**\n     * Create a transit reader instance.\n     * @method transit.reader\n     * @param {string=} type\n     *     type of reader to construct.  Default to \"json\". For verbose mode\n     *     supply \"json-verbose\".\n     * @param {Object=} opts\n     *     reader options. A JavaScript object to customize the writer Valid\n     *     entries include \"defaultHandler\", and \"handler\". \"defaultHandler\"\n     *     should be JavaScript function taking two arguments, the first is the\n     *     tag, the second the value. \"handlers\" should be an object of tags to\n     *     handle. The values are functions that will receive the value of matched\n     *     tag. \"preferBuffers\" may be supplied to customize binary\n     *     decoding. If available binary data will read as Node.js Buffers,\n     *     If Buffer is not available or \"prefersBuffers\" is set to false\n     *     data will be read as Uint8Array. If neither Buffer nor Uint8Array is\n     *     available - defaults to tagged value that simply wraps the\n     *     base64 encoded string.\n     * @return {com.cognitect.transit.impl.reader.Reader} A transit reader.\n     * @example\n     *     var r = transit.reader(\"json\", {\n     *         handlers: {\n     *            \"point\": function(v) { return new Point(v[0], v[1]); }\n     *         }\n     *     });\n     */\n    transit.reader = function(type, opts) {\n        if(type === \"json\" || type === \"json-verbose\" || type == null) {\n            type = \"json\";\n            var unmarshaller = new reader.JSONUnmarshaller(opts);\n            return new reader.Reader(unmarshaller, opts);\n        } else {\n            throw new Error(\"Cannot create reader of type \" + type);\n        }\n    };\n\n    /**\n     * Create a transit writer instance.\n     * @method transit.writer\n     * @param {string=} type\n     *     type of writer to construct. Defaults to \"json\". For verbose mode\n     *     supply \"json-verbose\".\n     * @param {Object=} opts\n     *     writer options. A JavaScript object to customize the writer.\n     *     \"handlers\" options, a transit.map of JavaScript constructor and\n     *     transit writer handler instance entries. \"handlerForForeign\" option,\n     *     for dealing with values from other JavaScript contexts. This function\n     *     will be passed the unmatchable value and the installed handlers. The\n     *     function should return the correct handler. Note if this function is\n     *     provided, special handling for Objects will also be\n     *     auto-installed to catch plain Objects from the foreign context.\n     * @return {com.cognitect.transit.impl.writer.Writer} A transit writer.\n     * @example\n     *     var r = transit.writer(\"json\", {\n     *         handlers: transit.map([\n     *            Point, PointHandler\n     *         ])\n     *     });\n     */\n    transit.writer = function(type, opts) {\n        if(type === \"json\" || type === \"json-verbose\" || type == null) {\n            if(type === \"json-verbose\") {\n                if(opts == null) opts = {};\n                opts[\"verbose\"] = true;\n            }\n            var marshaller = new writer.JSONMarshaller(opts);\n            return new writer.Writer(marshaller, opts);\n        } else {\n            var err = new Error(\"Type must be \\\"json\\\"\");\n            err.data = {type: type};\n            throw err;\n        }\n    };\n\n    /**\n     * Create a transit writer handler.\n     * @method transit.makeWriteHandler\n     * @param {Object} obj\n     *    An object containing 3 functions, tag, rep and stringRep. \"tag\" should\n     *    return a string representing the tag to be written on the wire. \"rep\"\n     *    should return the representation on the wire. \"stringRep\" is should\n     *    return the string representation of the value. Optional\n     *    \"getVerboseHandler\" should return a handler for writing verbose output.\n     * @return {Object} A transit write handler.\n     * @example\n     *     var PointHandler = transit.makeWriteHandler({\n     *          tag: function(p) { return \"point\"; },\n     *          rep: function(p) { return [p.x, p.y]; },\n     *          stringRep: function(p) { return null; }\n     *     });\n     */\n    transit.makeWriteHandler = function(obj) {\n        /** @constructor */\n        var Handler = function(){};\n        Handler.prototype.tag = obj[\"tag\"];\n        Handler.prototype.rep = obj[\"rep\"];\n        Handler.prototype.stringRep = obj[\"stringRep\"];\n        Handler.prototype.getVerboseHandler = obj[\"getVerboseHandler\"];\n        return new Handler();\n    };\n\n    transit.makeBuilder = function(obj) {\n        /** @constructor */\n        var Builder = function(){};\n        Builder.prototype.init = obj[\"init\"];\n        Builder.prototype.add = obj[\"add\"];\n        Builder.prototype.finalize = obj[\"finalize\"];\n        Builder.prototype.fromArray = obj[\"fromArray\"];\n        return new Builder();\n    };\n\n    /**\n     * Create a transit date.\n     * @method transit.date\n     * @param {number|string} x\n     *     A number or string representing milliseconds since epoch.\n     * @return {Date} A JavaScript Date.\n     */\n    transit.date = types.date;\n\n    /**\n     * Create an integer. If given a transit integer or a JavaScript\n     *     number will simply return that value. Given a string will\n     *     return a JavaScript number if the string represents an integer\n     *     value in the 53bit range and a transit integer otherwise.\n     * @method transit.integer\n     * @param {number|string} s\n     *     A value representing an integer.\n     * @return {number|goog.math.Long} A JavaScript number or transit integer.\n     */\n    transit.integer = types.intValue;\n\n    /**\n     * Test if an object is a transit integer. Will return true if argument\n     * is a 64 bit integer or a JavaScript number that has an interpretation as\n     * an integer value, i.e. parseFloat(n) === parseInt(n)\n     * @method transit.isInteger\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if the value is a transit integer, false otherwise.\n     */\n    transit.isInteger = types.isInteger;\n\n    /**\n     * Create transit UUID from a string\n     * @method transit.uuid\n     * @param {string} s\n     *     A string.\n     * @return {com.cognitect.transit.types.UUID} A transit UUID.\n     */\n    transit.uuid = types.uuid;\n\n    /**\n     * Test if an object is a transit UUID.\n     * @method transit.isUUID\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if the vlaue is a transit UUID instance, false otherwise.\n     */\n    transit.isUUID = types.isUUID;\n\n    /**\n     * Create a transit big integer.\n     * @method transit.bigInt\n     * @param {string} s\n     *     A string representing an arbitrary size integer value.\n     * @return {com.cognitect.transit.types.TaggedValue} A transit big integer.\n     */\n    transit.bigInt =  types.bigInteger;\n\n    /**\n     * Test if an object is a transit big integer.\n     * @method transit.isBigInt\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit big integer, false otherwise.\n     */\n    transit.isBigInt = types.isBigInteger;\n\n    /**\n     * Create a transit big decimal.\n     * @method transit.bigDec\n     * @param {string} s\n     *     A string representing an arbitrary precisions decimal value.\n     * @return {com.cognitect.transit.types.TaggedValue} A transit big decimal.\n     */\n    transit.bigDec =  types.bigDecimalValue;\n\n    /**\n     * Test if an object is a transit big decimal.\n     * @method transit.isBigDec\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit big decimal, false otherwise.\n     */\n    transit.isBigDec = types.isBigDecimal;\n\n    /**\n     * Create transit keyword.\n     * @method transit.keyword\n     * @param {string} name A string.\n     * @return {com.cognitect.transit.types.Keyword} A transit keyword.\n     * @example\n     *     transit.keyword(\"foo\");\n     */\n    transit.keyword = types.keyword;\n\n    /**\n     * Test if an object is a transit keyword.\n     * @method transit.isKeyword\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit keyword, false otherwise.\n     */\n    transit.isKeyword = types.isKeyword;\n\n    /**\n     * Create a transit symbol.\n     * @method transit.symbol\n     * @param {string} name\n     *     A string.\n     * @return {com.cognitect.transit.types.Symbol} A transit symbol instance.\n     * @example\n     *     transit.symbol(\"foo\");\n     */\n    transit.symbol = types.symbol;\n\n    /**\n     * Test if an object is a transit symbol\n     * @method transit.isSymbol\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit symbol, false otherwise.\n     */\n    transit.isSymbol = types.isSymbol;\n\n    /**\n     * Create transit binary blob.\n     * @method transit.binary\n     * @param {string} s\n     *     A base64 encoded string.\n     * @param {*=} decoder\n     *     A Transit compliant decoder\n     * @return {com.cognitect.transit.types.TaggedValue|Uint8Array} A transit binary blob instance.\n     */\n    transit.binary = types.binary;\n\n    /**\n     * Test if an object is a transit binary blob.\n     * @method transit.isBinary\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {Boolean} true if x is a binary value, false otheriwse.\n     */\n    transit.isBinary = types.isBinary;\n\n    /**\n     * Create a transit URI.\n     * @method transit.uri\n     * @param {string} s\n     *     A string representing a valid URI.\n     * @return {com.cognitect.transit.types.TaggedValue} A transit URI.\n     */\n    transit.uri = types.uri;\n\n    /**\n     * Test if an object is a transit URI.\n     * @method transit.isURI\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {Boolean} true if x is a transit symbol, false otherwise.\n     */\n    transit.isURI = types.isURI;\n\n    /**\n     * Create a transit hash map. Transit maps satisfy the current version\n     *     of the ECMAScript 6 Map specification.\n     * @method transit.map\n     * @param {Array=} xs\n     *     A JavaScript array of alternating key value pairs.\n     * @return {com.cognitect.transit.MapLike} A transit map.\n     * @example\n     *     transit.map([new Date(), \"foo\", [1,2], 3]);\n     */\n    transit.map = types.map;\n\n    /**\n     * Test if an object is a transit map.\n     * @method transit.isMap\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit map, false otherwise.\n     */\n    transit.isMap = types.isMap;\n\n    /**\n     * Create a transit set. Transit sets satisfy the current version of the\n     *     of the ECMAScript 6 Set specification.\n     * @method transit.set\n     * @param {Array=} xs\n     *     A JavaScript array of values.\n     * @return {com.cognitect.transit.SetLike} A transit set.\n     * @example\n     *     transit.set([\"foo\", [1,2], 3, {bar: \"baz\"}]);\n     */\n    transit.set = types.set;\n\n    /**\n     * Test if an object is a transit set.\n     * @method transit.isSet\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit set, false otherwise.\n     */\n    transit.isSet = types.isSet;\n\n    /**\n     * Create a transit list.\n     * @method transit.list\n     * @param {Array} xs\n     *     A JavaScript array.\n     * @return {com.cognitect.transit.types.TaggedValue} A transit list.\n     */\n    transit.list = types.list;\n\n    /**\n     * Test if an object is a transit list.\n     * @method transit.isList\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit list, false otherwise.\n     */\n    transit.isList = types.isList;\n\n    /**\n     * Create a transit quoted value.\n     * @method transit.quoted\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {com.cognitect.transit.types.TaggedValue} A transit quoted value.\n     */\n    transit.quoted = types.quoted;\n\n    /**\n     * Test if an object is a transit quoted value.\n     * @method transit.isQuoted\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit value, false otherwise.\n     */\n    transit.isQuoted = types.isQuoted;\n\n    /**\n     * Create a transit tagged value.\n     * @method transit.tagged\n     * @param {string} tag A tag.\n     * @param {*} value\n     *     A JavaScrpt array, object, or string.\n     * @return {com.cognitect.transit.types.TaggedValue} A transit tagged value.\n     * @example\n     *     transit.tagged(\"point\", new Point(1,2));\n     */\n    transit.tagged = types.taggedValue;\n\n    /**\n     * Test if an object is a transit tagged value.\n     * @method transit.isTaggedValue\n     * @param {*} x\n     *     Any JavaScript value.\n     * @return {boolean} true if x is a transit value, false otherwise.\n     */\n    transit.isTaggedValue =  types.isTaggedValue;\n\n    /**\n     * Create a transit link.\n     * @method transit.link\n     * @param {com.cognitect.transit.MapLike} m\n     *     A transit map which must contain at a minimum the following keys:\n     *     href, rel. It may optionally include name, render, and prompt. href\n     *     must be a transit.uri, all other values are strings, and render must\n     *     be either \"image\" or \"link\".\n     * @return {Object} A transit link.\n     */\n    transit.link = types.link;\n\n    /**\n     * Test if an object is a transit link.\n     * @method transit.isLink\n     * @param {*} x\n     *     Any JavaScript object.\n     * @return {boolean} true if x is a transit link, false otherwise.\n     */\n    transit.isLink = types.isLink;\n\n    /**\n     * Compute the hashCode for any JavaScript object that has been\n     *    extend to transit's equality and hashing protocol. JavaScript\n     *    primitives and transit value are already extended to this protocol.\n     *    Custom types may be extended to the protocol via transit.extenToEQ.\n     * @method transit.hash\n     * @param {*} x\n     *    Any JavaScript object that has been extended to transit's equality\n     *    and hashing protocol.\n     * @return {number} Returns JavaScript number - semantically a 32bit integer.\n     */\n    transit.hash = eq.hashCode;\n\n    /**\n     * Compute the hashCode for JavaScript map-like types - either a JavaScript\n     *    object or a JavaScript object that implements ES6 Map forEach.\n     * @method transit.hashMapLike\n     * @param {Object|com.cognitect.transit.MapLike} x\n     *    A plain JavaScript Object or Object that implements ES6 Map forEach.\n     * @return {number} Returns JavaScript number - semantically a 32bit integer.\n     */\n    transit.hashMapLike = eq.hashMapLike;\n\n    /**\n     * Compute the hashCode for JavaScript array-like types - either a JavaScript\n     *    array or a JavaScript object that implements Array forEach.\n     * @method transit.hashArrayLike\n     * @param {Object} x\n     *    A JavaScript Array or Object that implements Array forEach.\n     * @return {number} Returns JavaScript number - semantically a 32bit integer.\n     */\n    transit.hashArrayLike = eq.hashArrayLike;\n\n    /**\n     * Test whether two JavaScript objects represent equal values. The\n     *    objects to be tested should be extended to transit's equality\n     *    and hasing protocol. JavaScript natives and transit value have\n     *    already been extended to the protocol, including objects and\n     *    arrays.  Also transit maps and JavaScript objects may be\n     *    compared for equality. Custom types may be extended via\n     *    transit.extendToEQ.\n     * @param {*} x\n     *     A JavaScript object\n     * @param {*} y\n     *     A JavaScript object\n     * @return {Boolean} true if the x and y are equal, false otherwise.\n     */\n    transit.equals = eq.equals;\n\n    /**\n     * Extend an object to hashing and equality required by\n     *     transit maps and sets. Only required for custom\n     *     types, JavaScript primitive types and transit\n     *     types are handled.\n     * @method transit.extendToEQ\n     * @param {*} x\n     *     A JavaScript object, will be mutated.\n     * @param {{hashCode: function(), equals: function(*,*):boolean}}\n     *     A JavaScript object supplying `hashCode` and `equals`\n     *     implementations\n     * @return {*} x\n     * @example\n     *     transit.extendToEq(Point.protototype, {\n     *         hashCode: function() {\n     *             var bits = (this.x | 0) ^ ((this.y | 0) * 31);\n     *             return bits ^ (bits >>> 32);\n     *         },\n     *         equals: function(other) {\n     *             return this.x == other.x && this.y == other.y;\n     *         }\n     *     });\n     */\n    transit.extendToEQ = eq.extendToEQ;\n\n    /**\n     * Convert a transit map instance into a JavaScript Object.\n     * Throws if the map has keys which have no string representation.\n     * @method transit.mapToObject\n     * @param {com.cognitect.transit.MapLike} m\n     *     a transit map\n     * @return {Object} a JavaScript Object\n     */\n    transit.mapToObject = function(m) {\n        var ret = {};\n        m.forEach(function(v, k) {\n            if(typeof k !== \"string\") {\n                throw Error(\"Cannot convert map with non-string keys\");\n            } else {\n                ret[k] = v;\n            }\n        });\n        return ret;\n    };\n\n    /**\n     * Convert a POJO into a transit map.\n     * @method transit.objectToMap\n     * @param {Object} obj\n     *     a JavaScript Object\n     * @return {com.cognitect.transit.MapLike} a transit map\n     */\n    transit.objectToMap = function(obj) {\n        var ret = transit.map();\n        for(var p in obj) {\n            if(obj.hasOwnProperty(p)) {\n                ret.set(p, obj[p]);\n            }\n        }\n        return ret;\n    };\n\n    /**\n     * Construct a Transit JSON decoder.\n     * @method transit.decoder\n     * @param {Object} opts\n     *     options to the decoder. Can include map of\n     *     handlers.\n     * @return {com.cognitect.transit.impl.decoder.Decoder} a Transit JSON decoder\n     * @example\n     *     var decoder = transit.decoder();\n     *     var x = decoder.decode(json, transit.readCache());\n     */\n    transit.decoder = decoder.decoder;\n\n    /**\n     * Construct a Transit read cache\n     * @method transit.readCache\n     * @return {com.cognitect.transit.caching.ReadCache} a Transit read cache\n     */\n    transit.readCache = caching.readCache;\n\n    /**\n     * Construct a Transit write cache\n     * @method transit.writeCache\n     * @return {com.cognitect.transit.caching.WriteCache} a Transit write cache\n     */\n    transit.writeCache = caching.writeCache;\n\n    transit.UUIDfromString = types.UUIDfromString;\n    transit.randomUUID = util.randomUUID;\n    transit.stringableKeys = writer.stringableKeys;\n\n    if(TRANSIT_BROWSER_TARGET) {\n        goog.exportSymbol(\"transit.reader\",         transit.reader);\n        goog.exportSymbol(\"transit.writer\",         transit.writer);\n        goog.exportSymbol(\"transit.makeBuilder\",    transit.makeBuilder);\n        goog.exportSymbol(\"transit.makeWriteHandler\", transit.makeWriteHandler);\n        goog.exportSymbol(\"transit.date\",           types.date);\n        goog.exportSymbol(\"transit.integer\",        types.intValue);\n        goog.exportSymbol(\"transit.isInteger\",      types.isInteger);\n        goog.exportSymbol(\"transit.uuid\",           types.uuid);\n        goog.exportSymbol(\"transit.isUUID\",         types.isUUID);\n        goog.exportSymbol(\"transit.bigInt\",         types.bigInteger);\n        goog.exportSymbol(\"transit.isBigInt\",       types.isBigInteger);\n        goog.exportSymbol(\"transit.bigDec\",         types.bigDecimalValue);\n        goog.exportSymbol(\"transit.isBigDec\",       types.isBigDecimal);\n        goog.exportSymbol(\"transit.keyword\",        types.keyword);\n        goog.exportSymbol(\"transit.isKeyword\",      types.isKeyword);\n        goog.exportSymbol(\"transit.symbol\",         types.symbol);\n        goog.exportSymbol(\"transit.isSymbol\",       types.isSymbol);\n        goog.exportSymbol(\"transit.binary\",         types.binary);\n        goog.exportSymbol(\"transit.isBinary\",       types.isBinary);\n        goog.exportSymbol(\"transit.uri\",            types.uri);\n        goog.exportSymbol(\"transit.isURI\",          types.isURI);\n        goog.exportSymbol(\"transit.map\",            types.map);\n        goog.exportSymbol(\"transit.isMap\",          types.isMap);\n        goog.exportSymbol(\"transit.set\",            types.set);\n        goog.exportSymbol(\"transit.isSet\",          types.isSet);\n        goog.exportSymbol(\"transit.list\",           types.list);\n        goog.exportSymbol(\"transit.isList\",         types.isList);\n        goog.exportSymbol(\"transit.quoted\",         types.quoted);\n        goog.exportSymbol(\"transit.isQuoted\",       types.isQuoted);\n        goog.exportSymbol(\"transit.tagged\",         types.taggedValue);\n        goog.exportSymbol(\"transit.isTaggedValue\",  types.isTaggedValue);\n        goog.exportSymbol(\"transit.link\",           types.link);\n        goog.exportSymbol(\"transit.isLink\",         types.isLink);\n        goog.exportSymbol(\"transit.hash\",           eq.hashCode);\n        goog.exportSymbol(\"transit.hashMapLike\",    eq.hashMapLike);\n        goog.exportSymbol(\"transit.hashArrayLike\",  eq.hashArrayLike);\n        goog.exportSymbol(\"transit.equals\",         eq.equals);\n        goog.exportSymbol(\"transit.extendToEQ\",     eq.extendToEQ);\n        goog.exportSymbol(\"transit.mapToObject\",    transit.mapToObject);\n        goog.exportSymbol(\"transit.objectToMap\",    transit.objectToMap);\n        goog.exportSymbol(\"transit.decoder\",        decoder.decoder);\n        goog.exportSymbol(\"transit.UUIDfromString\", types.UUIDfromString);\n        goog.exportSymbol(\"transit.randomUUID\",     util.randomUUID);\n        goog.exportSymbol(\"transit.stringableKeys\", writer.stringableKeys);\n        goog.exportSymbol(\"transit.readCache\",      caching.readCache);\n        goog.exportSymbol(\"transit.writeCache\",     caching.writeCache);\n    }\n\n    if(TRANSIT_NODE_TARGET) {\n        module.exports = {\n            reader:         transit.reader,\n            writer:         transit.writer,\n            makeBuilder:    transit.makeBuilder,\n            makeWriteHandler: transit.makeWriteHandler,\n            date:           types.date,\n            integer:        types.intValue,\n            isInteger:      types.isInteger,\n            uuid:           types.uuid,\n            isUUID:         types.isUUID,\n            bigInt:         types.bigInteger,\n            isBigInt:       types.isBigInteger,\n            bigDec:         types.bigDecimalValue,\n            isBigDec:       types.isBigDecimal,\n            keyword:        types.keyword,\n            isKeyword:      types.isKeyword,\n            symbol:         types.symbol,\n            isSymbol:       types.isSymbol,\n            binary:         types.binary,\n            isBinary:       types.isBinary,\n            uri:            types.uri,\n            isURI:          types.isURI,\n            map:            types.map,\n            isMap:          types.isMap,\n            set:            types.set,\n            isSet:          types.isSet,\n            list:           types.list,\n            isList:         types.isList,\n            quoted:         types.quoted,\n            isQuoted:       types.isQuoted,\n            tagged:         types.taggedValue,\n            isTaggedValue:  types.isTaggedValue,\n            link:           types.link,\n            isLink:         types.isLink,\n            hash:           eq.hashCode,\n            hashArrayLike:  eq.hashArrayLike,\n            hashMapLike:    eq.hashMapLike,\n            equals:         eq.equals,\n            extendToEQ:     eq.extendToEQ,\n            mapToObject:    transit.mapToObject,\n            objectToMap:    transit.objectToMap,\n            decoder:        decoder.decoder,\n            UUIDfromString: types.UUIDfromString,\n            randomUUID:     util.randomUUID,\n            stringableKeys: writer.stringableKeys,\n            readCache:      caching.readCache,\n            writeCache:     caching.writeCache\n        };\n    }\n});\n","^;",1569048066000,"^<",["^=",["^>","~$com.cognitect.transit.impl.reader","^N","^?","^R","~$com.cognitect.transit.impl.decoder","~$com.cognitect.transit.caching","~$com.cognitect.transit.impl.writer"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit.js"],"^M",["^=",["~$com.cognitect.transit"]],"^O",true,"^P",["^?","^>","^U","^X","^R","^N","^V","^W"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.util.js","^5",["^6","com/cognitect/transit/util.js"],"^7","com/cognitect/transit/util.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.util\");\ngoog.require(\"goog.object\");\n\ngoog.scope(function () {\n\n    var util    = com.cognitect.transit.util,\n        gobject = goog.object;\n\n    if (typeof Object.keys != \"undefined\") {\n        util.objectKeys = function (obj) {\n            return Object.keys(obj);\n        };\n    } else {\n        util.objectKeys = function (obj) {\n            return gobject.getKeys(obj);\n        };\n    }\n\n    if (typeof Array.isArray != \"undefined\") {\n        util.isArray = function (obj) {\n            return Array.isArray(obj);\n        };\n    } else {\n        util.isArray = function (obj) {\n            return goog.typeOf(obj) === \"array\";\n        };\n    }\n\n    /**\n     * @const\n     * @type {string}\n     */\n    util.chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\n\n    util.randInt = function (ub) {\n        return Math.round(Math.random() * ub);\n    };\n\n    util.randHex = function () {\n        return util.randInt(15).toString(16);\n    };\n\n    util.randomUUID = function () {\n        var rhex = (0x8 | (0x3 & util.randInt(14))).toString(16),\n            ret  = util.randHex() + util.randHex() + util.randHex() + util.randHex() +\n                   util.randHex() + util.randHex() + util.randHex() + util.randHex() + \"-\" +\n                   util.randHex() + util.randHex() + util.randHex() + util.randHex() + \"-\" +\n                              \"4\" + util.randHex() + util.randHex() + util.randHex() + \"-\" +\n                             rhex + util.randHex() + util.randHex() + util.randHex() + \"-\" +\n                   util.randHex() + util.randHex() + util.randHex() + util.randHex() +\n                   util.randHex() + util.randHex() + util.randHex() + util.randHex() +\n                   util.randHex() + util.randHex() + util.randHex() + util.randHex();\n        return ret;\n    };\n\n// https://github.com/davidchambers/Base64.js\n\n    util.btoa = function (input) {\n        if (typeof btoa != \"undefined\") {\n            return btoa(input);\n        } else {\n            var str = String(input);\n            for (\n                var block, charCode, idx = 0, map = util.chars, output = '';\n                str.charAt(idx | 0) || (map = '=', idx % 1);\n                output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n            ) {\n                charCode = str.charCodeAt(idx += 3 / 4);\n                if (charCode > 0xFF) {\n                    throw new Error(\"'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.\");\n                }\n                block = block << 8 | charCode;\n            }\n            return output;\n        }\n    };\n\n    /**\n     * @suppress {uselessCode}\n     */\n    util.atob = function (input) {\n        if (typeof atob != \"undefined\") {\n            return atob(input);\n        } else {\n            var str = String(input).replace(/=+$/, '');\n            if (str.length % 4 == 1) {\n                throw new Error(\"'atob' failed: The string to be decoded is not correctly encoded.\");\n            }\n            for (\n                var bc = 0, bs, buffer, idx = 0, output = '';\n                buffer = str.charAt(idx++);\n                ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n                bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n            ) {\n                buffer = util.chars.indexOf(buffer);\n            }\n            return output;\n        }\n    };\n\n    util.Uint8ToBase64 = function (u8Arr) {\n        var CHUNK_SIZE = 0x8000,\n            index      = 0,\n            length     = u8Arr.length,\n            result     = '',\n            slice      = null;\n\n        while (index < length) {\n            slice = u8Arr.subarray(index, Math.min(index + CHUNK_SIZE, length));\n            result += String.fromCharCode.apply(null, slice);\n            index += CHUNK_SIZE;\n        }\n\n        return util.btoa(result);\n    };\n\n    util.Base64ToUint8 = function (base64) {\n        var binary_string = util.atob(base64),\n            len           = binary_string.length,\n            bytes         = new Uint8Array(len);\n\n        for (var i = 0; i < len; i++) {\n            var ascii = binary_string.charCodeAt(i);\n            bytes[i] = ascii;\n        }\n\n        return bytes;\n    };\n\n});\n","^;",1569048066000,"^<",["^=",["^?","~$goog.object"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/util.js"],"^M",["^=",["^>"]],"^O",true,"^P",["^?","^Z"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.impl.writer.js","^5",["^6","com/cognitect/transit/impl/writer.js"],"^7","com/cognitect/transit/impl/writer.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.impl.writer\");\ngoog.require(\"com.cognitect.transit.util\");\ngoog.require(\"com.cognitect.transit.caching\");\ngoog.require(\"com.cognitect.transit.handlers\");\ngoog.require(\"com.cognitect.transit.types\");\ngoog.require(\"com.cognitect.transit.delimiters\");\ngoog.require(\"goog.math.Long\");\n\ngoog.scope(function () {\n\n    var writer   = com.cognitect.transit.impl.writer,\n        util     = com.cognitect.transit.util,\n        caching  = com.cognitect.transit.caching,\n        handlers = com.cognitect.transit.handlers,\n        types    = com.cognitect.transit.types,\n        d        = com.cognitect.transit.delimiters,\n        Long     = goog.math.Long;\n\n    writer.escape = function (string) {\n        if (string.length > 0) {\n            var c = string.charAt(0);\n            if (c === d.ESC || c === d.SUB || c === d.RES) {\n                return d.ESC + string;\n            } else {\n                return string;\n            }\n        } else {\n            return string;\n        }\n    };\n\n    /**\n     * @constructor\n     */\n    writer.JSONMarshaller = function Transit$JSONMarshaller(opts) {\n        this.opts = opts || {};\n        this.preferStrings = this.opts[\"preferStrings\"] != null ? this.opts[\"preferStrings\"] : true;\n\n        this.objectBuilder = this.opts[\"objectBuilder\"] || null;\n\n        this.handlers = new handlers.Handlers();\n\n        var optsHandlers = this.opts[\"handlers\"];\n        if (optsHandlers) {\n            if (util.isArray(optsHandlers) || !optsHandlers.forEach) {\n                throw new Error(\"transit writer \\\"handlers\\\" option must be a map\");\n            }\n            var self = this;\n            optsHandlers.forEach(function (v, k) {\n                if (k !== undefined) {\n                    self.handlers.set(k, v);\n                } else {\n                    throw new Error(\"Cannot create handler for JavaScript undefined\");\n                }\n            });\n        }\n\n        // Multiple JS context helper\n        this.handlerForForeign = this.opts[\"handlerForForeign\"];\n\n        this.unpack = this.opts[\"unpack\"] || function (x) {\n                if (types.isArrayMap(x) && x.backingMap === null) {\n                    return x._entries;\n                } else {\n                    return false;\n                }\n            };\n\n        this.verbose = (this.opts && this.opts[\"verbose\"]) || false;\n    };\n\n    writer.JSONMarshaller.prototype.handler = function (obj) {\n        var h = this.handlers.get(handlers.constructor(obj));\n\n        if (h != null) {\n            return h;\n        } else {\n            var tag = obj && obj[\"transitTag\"];\n            if (tag) {\n                return this.handlers.get(tag)\n            } else {\n                return null;\n            }\n        }\n    };\n\n    writer.JSONMarshaller.prototype.registerHandler = function (ctor, handler) {\n        this.handlers.set(ctor, handler);\n    };\n\n    writer.JSONMarshaller.prototype.emitNil = function (asMapKey, cache) {\n        if (asMapKey) {\n            return this.emitString(d.ESC, \"_\", \"\", asMapKey, cache);\n        } else {\n            return null;\n        }\n    };\n\n    writer.JSONMarshaller.prototype.emitString = function (prefix, tag, s, asMapKey, cache) {\n        var string = prefix + tag + s;\n        if (cache) {\n            return cache.write(string, asMapKey);\n        } else {\n            return string;\n        }\n    };\n\n    writer.JSONMarshaller.prototype.emitBoolean = function (b, asMapKey, cache) {\n        if (asMapKey) {\n            var s = b.toString();\n            return this.emitString(d.ESC, \"?\", s[0], asMapKey, cache);\n        } else {\n            return b;\n        }\n    };\n\n    writer.JSONMarshaller.prototype.emitInteger = function (i, asMapKey, cache) {\n        if (i === Infinity) {\n            return this.emitString(d.ESC, \"z\", \"INF\", asMapKey, cache);\n        } else if (i === -Infinity) {\n            return this.emitString(d.ESC, \"z\", \"-INF\", asMapKey, cache);\n        } else if (isNaN(i)) {\n            return this.emitString(d.ESC, \"z\", \"NaN\", asMapKey, cache);\n        } else if (asMapKey || (typeof i === \"string\") || (i instanceof Long)) {\n            return this.emitString(d.ESC, \"i\", i.toString(), asMapKey, cache);\n        } else {\n            return i;\n        }\n    };\n\n    writer.JSONMarshaller.prototype.emitDouble = function (d, asMapKey, cache) {\n        if (asMapKey) {\n            return this.emitString(d.ESC, \"d\", d, asMapKey, cache);\n        } else {\n            return d;\n        }\n    };\n\n    writer.JSONMarshaller.prototype.emitBinary = function (b, asMapKey, cache) {\n        return this.emitString(d.ESC, \"b\", b, asMapKey, cache);\n    };\n\n    writer.JSONMarshaller.prototype.emitQuoted = function (em, obj, cache) {\n        if (em.verbose) {\n            var ret = {},\n                k = this.emitString(d.ESC_TAG, \"'\", \"\", true, cache);\n            ret[k] = writer.marshal(this, obj, false, cache);\n            return ret;\n        } else {\n            return [this.emitString(d.ESC_TAG, \"'\", \"\", true, cache), writer.marshal(this, obj, false, cache)];\n        }\n    };\n\n    writer.emitObjects = function (em, iterable, cache) {\n        var ret = [];\n        if (util.isArray(iterable)) {\n            for (var i = 0; i < iterable.length; i++) {\n                ret.push(writer.marshal(em, iterable[i], false, cache));\n            }\n        } else {\n            iterable.forEach(function (v, i) {\n                ret.push(writer.marshal(em, v, false, cache));\n            });\n        }\n        return ret;\n    };\n\n    writer.emitArray = function (em, iterable, skip, cache) {\n        return writer.emitObjects(em, iterable, cache);\n    };\n\n    writer.isStringableKey = function (em, k) {\n        if (typeof k !== \"string\") {\n            var h = em.handler(k);\n            return h && h.tag(k).length === 1;\n        } else {\n            return true;\n        }\n    };\n\n    /**\n     * Returns true if map-like obj parameter has only stringable keys -\n     * strings, symbols or keywords. If false, obj is a cmap value.\n     * @param em\n     * @param obj\n     * @returns {boolean}\n     */\n    writer.stringableKeys = function (em, obj) {\n        var arr = em.unpack(obj),\n            stringableKeys = true;\n\n        if (arr) {\n            for (var i = 0; i < arr.length; i += 2) {\n                stringableKeys = writer.isStringableKey(em, arr[i]);\n                if (!stringableKeys) {\n                    break;\n                }\n            }\n            return stringableKeys;\n        } else if (obj.keys) {\n            var iter = obj.keys(),\n                step = null;\n\n            if (iter.next) {\n                step = iter.next();\n                while (!step.done) {\n                    stringableKeys = writer.isStringableKey(em, step.value);\n                    if (!stringableKeys) {\n                        break;\n                    }\n                    step = iter.next();\n                }\n                return stringableKeys;\n            }\n        }\n\n        if (obj.forEach) {\n            obj.forEach(function (v, k) {\n                stringableKeys = stringableKeys && writer.isStringableKey(em, k);\n            });\n            return stringableKeys;\n        } else {\n            throw new Error(\"Cannot walk keys of object type \" + handlers.constructor(obj).name);\n        }\n    };\n\n    /**\n     * Returns true if x is an Object instance from a different JavaScript\n     * context.\n     * @param x\n     * @returns {boolean}\n     */\n    writer.isForeignObject = function (x) {\n        if (x.constructor[\"transit$isObject\"]) {\n            return true;\n        }\n\n        var ret = x.constructor.toString();\n\n        ret = ret.substr('function '.length);\n        ret = ret.substr(0, ret.indexOf('('));\n        isObject = ret == \"Object\";\n\n        if (typeof Object.defineProperty != \"undefined\") {\n            Object.defineProperty(x.constructor, \"transit$isObject\", {\n                value: isObject,\n                enumerable: false\n            });\n        } else {\n            x.constructor[\"transit$isObject\"] = isObject;\n        }\n\n        return isObject;\n    };\n\n    writer.emitMap = function (em, obj, skip, cache) {\n        var arr = null, rep = null, tag = null, ks = null, i = 0;\n\n        if ((obj.constructor === Object) ||\n            (obj.forEach != null) ||\n            (em.handlerForForeign && writer.isForeignObject(obj))) {\n            if (em.verbose) {\n                if (obj.forEach != null) {\n                    if (writer.stringableKeys(em, obj)) {\n                        var ret = {};\n                        obj.forEach(function (v, k) {\n                            ret[writer.marshal(em, k, true, false)] = writer.marshal(em, v, false, cache);\n                        });\n                        return ret;\n                    } else {\n                        arr = em.unpack(obj);\n                        rep = [];\n                        tag = em.emitString(d.ESC_TAG, \"cmap\", \"\", true, cache);\n                        if (arr) {\n                            for (; i < arr.length; i += 2) {\n                                rep.push(writer.marshal(em, arr[i], false, false));\n                                rep.push(writer.marshal(em, arr[i + 1], false, cache));\n                            }\n                        } else {\n                            obj.forEach(function (v, k) {\n                                rep.push(writer.marshal(em, k, false, false));\n                                rep.push(writer.marshal(em, v, false, cache));\n                            });\n                        }\n                        ret = {};\n                        ret[tag] = rep;\n                        return ret;\n                    }\n                } else {\n                    ks = util.objectKeys(obj);\n                    ret = {};\n                    for (; i < ks.length; i++) {\n                        ret[writer.marshal(em, ks[i], true, false)] = writer.marshal(em, obj[ks[i]], false, cache);\n                    }\n                    return ret;\n                }\n            } else {\n                if (obj.forEach != null) {\n                    if (writer.stringableKeys(em, obj)) {\n                        arr = em.unpack(obj);\n                        ret = [\"^ \"];\n                        if (arr) {\n                            for (; i < arr.length; i += 2) {\n                                ret.push(writer.marshal(em, arr[i], true, cache));\n                                ret.push(writer.marshal(em, arr[i + 1], false, cache));\n                            }\n                        } else {\n                            obj.forEach(function (v, k) {\n                                ret.push(writer.marshal(em, k, true, cache));\n                                ret.push(writer.marshal(em, v, false, cache));\n                            });\n                        }\n                        return ret;\n                    } else {\n                        arr = em.unpack(obj);\n                        rep = [];\n                        tag = em.emitString(d.ESC_TAG, \"cmap\", \"\", true, cache);\n                        if (arr) {\n                            for (; i < arr.length; i += 2) {\n                                rep.push(writer.marshal(em, arr[i], false, cache));\n                                rep.push(writer.marshal(em, arr[i + 1], false, cache));\n                            }\n                        } else {\n                            obj.forEach(function (v, k) {\n                                rep.push(writer.marshal(em, k, false, cache));\n                                rep.push(writer.marshal(em, v, false, cache));\n                            });\n                        }\n                        return [tag, rep];\n                    }\n                } else {\n                    ret = [\"^ \"];\n                    ks = util.objectKeys(obj);\n                    for (; i < ks.length; i++) {\n                        ret.push(writer.marshal(em, ks[i], true, cache));\n                        ret.push(writer.marshal(em, obj[ks[i]], false, cache));\n                    }\n                    return ret;\n                }\n            }\n        } else if (em.objectBuilder != null) {\n            return em.objectBuilder(obj, function (k) {\n                    return writer.marshal(em, k, true, cache);\n                },\n                function (v) {\n                    return writer.marshal(em, v, false, cache);\n                });\n        } else {\n            var name = handlers.constructor(obj).name,\n                err = new Error(\"Cannot write \" + name);\n            err.data = {obj: obj, type: name};\n            throw err;\n        }\n    };\n\n    writer.emitTaggedMap = function (em, tag, rep, skip, cache) {\n        if (em.verbose) {\n            var ret = {};\n            ret[em.emitString(d.ESC_TAG, tag, \"\", true, cache)] = writer.marshal(em, rep, false, cache);\n            return ret;\n        } else {\n            return [em.emitString(d.ESC_TAG, tag, \"\", true, cache), writer.marshal(em, rep, false, cache)];\n        }\n    };\n\n    writer.emitEncoded = function (em, h, tag, rep, obj, asMapKey, cache) {\n        if (tag.length === 1) {\n            if (typeof rep === \"string\") {\n                return em.emitString(d.ESC, tag, rep, asMapKey, cache);\n            } else if (asMapKey || em.preferStrings) {\n                var vh = em.verbose && h.getVerboseHandler();\n                if (vh) {\n                    tag = vh.tag(obj);\n                    rep = vh.stringRep(obj, vh);\n                } else {\n                    rep = h.stringRep(obj, h);\n                }\n                if (rep !== null) {\n                    return em.emitString(d.ESC, tag, rep, asMapKey, cache);\n                } else {\n                    var err = new Error(\"Tag \\\"\" + tag + \"\\\" cannot be encoded as string\");\n                    err.data = {tag: tag, rep: rep, obj: obj};\n                    throw err;\n                }\n            } else {\n                return writer.emitTaggedMap(em, tag, rep, asMapKey, cache);\n            }\n        } else {\n            return writer.emitTaggedMap(em, tag, rep, asMapKey, cache);\n        }\n    };\n\n    writer.marshal = function (em, obj, asMapKey, cache) {\n        var h = em.handler(obj) || (em.handlerForForeign ? em.handlerForForeign(obj, em.handlers) : null),\n            tag = h ? h.tag(obj) : null,\n            rep = h ? h.rep(obj) : null;\n\n        if (h != null && tag != null) {\n            switch (tag) {\n                case \"_\":\n                    return em.emitNil(asMapKey, cache);\n                    break;\n                case \"s\":\n                    return em.emitString(\"\", \"\", writer.escape(rep), asMapKey, cache);\n                    break;\n                case \"?\":\n                    return em.emitBoolean(rep, asMapKey, cache);\n                    break;\n                case \"i\":\n                    return em.emitInteger(rep, asMapKey, cache);\n                    break;\n                case \"d\":\n                    return em.emitDouble(rep, asMapKey, cache);\n                    break;\n                case \"b\":\n                    return em.emitBinary(rep, asMapKey, cache);\n                    break;\n                case \"'\":\n                    return em.emitQuoted(em, rep, cache);\n                    break;\n                case \"array\":\n                    return writer.emitArray(em, rep, asMapKey, cache);\n                    break;\n                case \"map\":\n                    return writer.emitMap(em, rep, asMapKey, cache);\n                    break;\n                default:\n                    return writer.emitEncoded(em, h, tag, rep, obj, asMapKey, cache);\n                    break;\n            }\n        } else {\n            var name = handlers.constructor(obj).name,\n                err = new Error(\"Cannot write \" + name);\n            err.data = {obj: obj, type: name};\n            throw err;\n        }\n    };\n\n    writer.maybeQuoted = function (em, obj) {\n        var h = em.handler(obj) || (em.handlerForForeign ? em.handlerForForeign(obj, em.handlers) : null);\n\n        if (h != null) {\n            if (h.tag(obj).length === 1) {\n                return types.quoted(obj);\n            } else {\n                return obj;\n            }\n        } else {\n            var name = handlers.constructor(obj).name,\n                err = new Error(\"Cannot write \" + name);\n            err.data = {obj: obj, type: name};\n            throw err;\n        }\n    };\n\n    writer.marshalTop = function (em, obj, asMapKey, cache) {\n        return JSON.stringify(writer.marshal(em, writer.maybeQuoted(em, obj), asMapKey, cache));\n    };\n\n    /**\n     * @constructor\n     */\n    writer.Writer = function Transit$Writer(marshaller, options) {\n        this._marshaller = marshaller;\n        this.options = options || {};\n        if (this.options[\"cache\"] === false) {\n            this.cache = null;\n        } else {\n            this.cache = this.options[\"cache\"] ? this.options[\"cache\"] : new caching.WriteCache();\n        }\n    };\n\n    writer.Writer.prototype.marshaller = function () {\n        return this._marshaller;\n    };\n    writer.Writer.prototype[\"marshaller\"] = writer.Writer.prototype.marshaller;\n\n    writer.Writer.prototype.write = function (obj, opts) {\n        var ret = null,\n            ropts = opts || {},\n            asMapKey = ropts[\"asMapKey\"] || false,\n            cache = this._marshaller.verbose ? false : this.cache;\n\n        if (ropts[\"marshalTop\"] === false) {\n            ret = writer.marshal(this._marshaller, obj, asMapKey, cache)\n        } else {\n            ret = writer.marshalTop(this._marshaller, obj, asMapKey, cache)\n        }\n        if (this.cache != null) {\n            this.cache.clear();\n        }\n        return ret;\n    };\n    writer.Writer.prototype[\"write\"] = writer.Writer.prototype.write;\n\n    writer.Writer.prototype.register = function (type, handler) {\n        this._marshaller.registerHandler(type, handler);\n    };\n    writer.Writer.prototype[\"register\"] = writer.Writer.prototype.register;\n\n});\n","^;",1569048066000,"^<",["^=",["^>","^?","^R","^Q","^T","^W","^S"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/impl/writer.js"],"^M",["^=",["^X"]],"^O",true,"^P",["^?","^>","^W","^T","^R","^Q","^S"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.impl.reader.js","^5",["^6","com/cognitect/transit/impl/reader.js"],"^7","com/cognitect/transit/impl/reader.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.impl.reader\");\ngoog.require(\"com.cognitect.transit.impl.decoder\");\ngoog.require(\"com.cognitect.transit.caching\");\n\ngoog.scope(function () {\n\n    var reader  = com.cognitect.transit.impl.reader,\n        decoder = com.cognitect.transit.impl.decoder,\n        caching = com.cognitect.transit.caching;\n\n    /**\n     * A JSON unmarshaller\n     * @constructor\n     */\n    reader.JSONUnmarshaller = function Transit$JSONUnmarshaller(opts) {\n        this.decoder = new decoder.Decoder(opts);\n    };\n\n    /**\n     * @param {string} str a JSON string\n     * @param {caching.ReadCache} cache a read cache\n     * @returns {*}\n     */\n    reader.JSONUnmarshaller.prototype.unmarshal = function (str, cache) {\n        return this.decoder.decode(JSON.parse(str), cache);\n    };\n\n    /**\n     * A transit reader\n     * @constructor\n     * @param {reader.JSONUnmarshaller} unmarshaller\n     * @param {Object=} options\n     */\n    reader.Reader = function Transit$Reader(unmarshaller, options) {\n        this.unmarshaller = unmarshaller;\n        this.options = options || {};\n        this.cache = this.options[\"cache\"] ? this.options[\"cache\"] : new caching.ReadCache();\n    };\n\n    /**\n     * @param {string} str a string to be read\n     * @returns {*}\n     */\n    reader.Reader.prototype.read = function (str) {\n        var ret = this.unmarshaller.unmarshal(str, this.cache)\n        this.cache.clear();\n        return ret;\n    };\n    reader.Reader.prototype[\"read\"] = reader.Reader.prototype.read;\n\n});\n","^;",1569048066000,"^<",["^=",["^?","^V","^W"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/impl/reader.js"],"^M",["^=",["^U"]],"^O",true,"^P",["^?","^V","^W"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit_amd.js","^5",["^6","com/cognitect/transit_amd.js"],"^7","com/cognitect/transit_amd.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n\"use strict\";\n\ngoog.provide(\"com.cognitect.transit.amd\");\ngoog.require(\"com.cognitect.transit\");\n\nif(TRANSIT_BROWSER_AMD_TARGET) {\n    define(\"transit\", [], function() {\n        return com.cognitect.transit;\n    });\n}\n","^;",1569048066000,"^<",["^=",["^?","^Y"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit_amd.js"],"^M",["^=",["~$com.cognitect.transit.amd"]],"^O",true,"^P",["^?","^Y"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.caching.js","^5",["^6","com/cognitect/transit/caching.js"],"^7","com/cognitect/transit/caching.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.caching\");\ngoog.require(\"com.cognitect.transit.delimiters\");\n\ngoog.scope(function() {\n\nvar caching = com.cognitect.transit.caching,\n    d       = com.cognitect.transit.delimiters;\n\n/**\n * @const\n * @type {number}\n */\ncaching.MIN_SIZE_CACHEABLE = 3;\n\n/**\n * @const\n * @type {number}\n */\ncaching.BASE_CHAR_IDX = 48;\n\n/**\n * @const\n * @type {number}\n */\ncaching.CACHE_CODE_DIGITS = 44;\n\n/**\n * @const\n * @type {number}\n */\ncaching.MAX_CACHE_ENTRIES = caching.CACHE_CODE_DIGITS*caching.CACHE_CODE_DIGITS;\n\n/**\n * @const\n * @type {number}\n */\ncaching.MAX_CACHE_SIZE = 4096;\n\ncaching.isCacheable = function(string, asMapKey) {\n    if(string.length > caching.MIN_SIZE_CACHEABLE) {\n        if(asMapKey) {\n            return true;\n        } else {\n            var c0 = string.charAt(0),\n                c1 = string.charAt(1);\n            if(c0 === d.ESC) {\n                return c1 === \":\" || c1 === \"$\" || c1 === \"#\";\n            } else {\n                return false;\n            }\n        }\n    } else {\n        return false;\n    }\n};\n\n// =============================================================================\n// WriteCache\n\ncaching.idxToCode = function(idx) {\n    var hi  = Math.floor(idx / caching.CACHE_CODE_DIGITS),\n        lo  = idx % caching.CACHE_CODE_DIGITS,\n        loc = String.fromCharCode(lo + caching.BASE_CHAR_IDX)\n    if(hi === 0) {\n        return d.SUB + loc;\n    } else {\n        return d.SUB + String.fromCharCode(hi + caching.BASE_CHAR_IDX) + loc;\n    }\n};\n\n/**\n * @constructor\n */\ncaching.WriteCache = function() {\n    this.idx = 0;\n    this.gen = 0;\n    this.cacheSize = 0;\n    this.cache = {};\n};\n\ncaching.WriteCache.prototype.write = function(string, asMapKey) {\n    if(caching.isCacheable(string, asMapKey)) {\n        if(this.cacheSize === caching.MAX_CACHE_SIZE) {\n            this.clear();\n            this.gen = 0;\n            this.cache = {};\n        } else if(this.idx === caching.MAX_CACHE_ENTRIES) {\n            this.clear();\n        }\n        var entry = this.cache[string];\n        if(entry == null) {\n            this.cache[string] = [caching.idxToCode(this.idx), this.gen];\n            this.idx++;\n            return string;\n        } else if(entry[1] != this.gen) {\n            entry[1] = this.gen;\n            entry[0] = caching.idxToCode(this.idx);\n            this.idx++;\n            return string;\n        } else {\n            return entry[0];\n        }\n    } else {\n        return string;\n    }\n};\n\ncaching.WriteCache.prototype.clear = function Transit$WriteCache() {\n    this.idx = 0;\n    this.gen++;\n};\n\ncaching.writeCache = function() {\n    return new caching.WriteCache();\n};\n\n// =============================================================================\n// ReadCache\n\ncaching.isCacheCode = function(string) {\n    return (string.charAt(0) === d.SUB) && (string.charAt(1) !== \" \");\n};\n\ncaching.codeToIdx = function(code) {\n    if(code.length === 2) {\n        return code.charCodeAt(1) - caching.BASE_CHAR_IDX;        \n    } else {\n        var hi = (code.charCodeAt(1) - caching.BASE_CHAR_IDX) * caching.CACHE_CODE_DIGITS,\n            lo = (code.charCodeAt(2) - caching.BASE_CHAR_IDX);\n        return hi + lo; \n    }\n};\n\n/**\n * @constructor\n */\ncaching.ReadCache = function Transit$ReadCache() {\n    this.idx = 0;\n    this.cache = [];\n};\n\ncaching.ReadCache.prototype.write = function(obj, asMapKey) {\n    if(this.idx == caching.MAX_CACHE_ENTRIES) {\n        this.idx = 0;\n    }\n    this.cache[this.idx] = obj;\n    this.idx++;\n    return obj;\n};\n\ncaching.ReadCache.prototype.read = function(string, asMapKey) {\n    return this.cache[caching.codeToIdx(string)];\n};\n\ncaching.ReadCache.prototype.clear = function() {\n    this.idx = 0;\n};\n\ncaching.readCache = function() {\n    return new caching.ReadCache();\n};\n\n});    \n","^;",1569048066000,"^<",["^=",["^?","^Q"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/caching.js"],"^M",["^=",["^W"]],"^O",true,"^P",["^?","^Q"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.types.js","^5",["^6","com/cognitect/transit/types.js"],"^7","com/cognitect/transit/types.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.types\");\ngoog.require(\"com.cognitect.transit.util\");\ngoog.require(\"com.cognitect.transit.eq\");\ngoog.require(\"goog.math.Long\");\n\ngoog.scope(function() {\n\n    var types = com.cognitect.transit.types,\n        util  = com.cognitect.transit.util,\n        eq    = com.cognitect.transit.eq,\n        Long  = goog.math.Long;\n\n    if(typeof Symbol != \"undefined\") {\n        types.ITERATOR = Symbol.iterator;\n    } else {\n        types.ITERATOR = \"@@iterator\";\n    }\n\n    /**\n     * @constructor\n     */\n    types.TaggedValue = function Transit$TaggedValue(tag, rep) {\n        this.tag = tag;\n        this.rep = rep;\n        this.hashCode = -1;\n    };\n\n    types.TaggedValue.prototype.toString = function() {\n        return \"[TaggedValue: \" + this.tag + \", \" + this.rep + \"]\";\n    };\n\n    types.TaggedValue.prototype.equiv = function(other) {\n        return eq.equals(this, other);\n    };\n    types.TaggedValue.prototype[\"equiv\"] = types.TaggedValue.prototype.equiv;\n\n    types.TaggedValue.prototype.com$cognitect$transit$equals = function(other) {\n        if(other instanceof types.TaggedValue) {\n            return (this.tag === other.tag) && eq.equals(this.rep, other.rep);\n        } else {\n            return false;\n        }\n    };\n\n    types.TaggedValue.prototype.com$cognitect$transit$hashCode = function() {\n        if(this.hashCode === -1) {\n            this.hashCode = eq.hashCombine(eq.hashCode(this.tag), eq.hashCode(this.rep));\n        }\n        return this.hashCode;\n    };\n\n    types.taggedValue = function(tag, rep) {\n        return new types.TaggedValue(tag, rep);\n    };\n\n    types.isTaggedValue = function(x) {\n        return x instanceof types.TaggedValue;\n    };\n\n    types.nullValue = function() {\n        return null;\n    };\n\n    types.boolValue = function(s) {\n        return s === \"t\";\n    };\n\n    types.MAX_INT = Long.fromString(\"9007199254740991\");\n    types.MIN_INT = Long.fromString(\"-9007199254740991\");\n\n    types.intValue = function(s) {\n        if(typeof s === \"number\") {\n            return s;\n        } else if(s instanceof Long) {\n            return s;\n        } else {\n            var n = Long.fromString(s, 10);\n            if(n.greaterThan(types.MAX_INT) ||\n                n.lessThan(types.MIN_INT)) {\n                return n;\n            } else {\n                return n.toNumber();\n            }\n        }\n    };\n\n    Long.prototype.equiv = function(other) {\n        return eq.equals(this, other);\n    };\n    Long.prototype[\"equiv\"] = Long.prototype.equiv;\n\n    Long.prototype.com$cognitect$transit$equals = function(other) {\n        return (other instanceof Long) && this.equals(other);\n    };\n\n    Long.prototype.com$cognitect$transit$hashCode = function() {\n        return this.toInt();\n    };\n\n    types.isInteger = function(x) {\n        if(x instanceof Long) {\n            return true;\n        } else {\n            return (typeof x === \"number\") && !isNaN(x) && !(x === Infinity) && (parseFloat(x) === parseInt(x, 10));\n        }\n    };\n\n    types.floatValue = function(s) {\n        return parseFloat(s);\n    };\n\n    types.bigInteger = function(s) {\n        return types.taggedValue(\"n\", s);\n    };\n\n    types.isBigInteger = function(x) {\n        return (x instanceof types.TaggedValue) && (x.tag === \"n\");\n    };\n\n    types.bigDecimalValue = function(s) {\n        return types.taggedValue(\"f\", s);\n    };\n\n    types.isBigDecimal = function(x) {\n        return (x instanceof types.TaggedValue) && (x.tag === \"f\");\n    };\n\n    types.charValue = function(s) {\n        return s;\n    };\n\n    /**\n     * @constructor\n     */\n    types.Keyword = function Transit$Keyword(name) {\n        this._name = name;\n        this.hashCode = -1;\n    };\n\n    types.Keyword.prototype.toString = function() {\n        return \":\"+this._name;\n    };\n\n    types.Keyword.prototype[\"namespace\"] = function() {\n        var idx = this._name.indexOf(\"/\");\n        if(idx != -1) {\n            return this._name.substring(0, idx);\n        } else {\n            return null;\n        }\n    };\n\n    types.Keyword.prototype[\"name\"] = function() {\n        var idx = this._name.indexOf(\"/\");\n        if(idx != -1) {\n            return this._name.substring(idx+1, this._name.length);\n        } else {\n            return this._name;\n        }\n    };\n\n    types.Keyword.prototype.equiv = function(other) {\n        return eq.equals(this, other);\n    };\n    types.Keyword.prototype[\"equiv\"] = types.Keyword.prototype.equiv;\n\n    types.Keyword.prototype.com$cognitect$transit$equals = function(other) {\n        return (other instanceof types.Keyword) && this._name == other._name;\n    };\n\n    types.Keyword.prototype.com$cognitect$transit$hashCode = function() {\n        if(this.hashCode === -1) {\n            this.hashCode = eq.hashCode(this._name);\n        }\n        return this.hashCode;\n    };\n\n    types.keyword = function(s) {\n        return new types.Keyword(s);\n    };\n\n    types.isKeyword = function(x) {\n        return x instanceof types.Keyword;\n    };\n\n    /**\n     * @constructor\n     */\n    types.Symbol = function Transit$Symbol(name) {\n        this._name = name;\n        this.hashCode = -1;\n    };\n\n    types.Symbol.prototype[\"namespace\"] = function() {\n        var idx = this._name.indexOf(\"/\");\n        if(idx != -1) {\n            return this._name.substring(0, idx);\n        } else {\n            return null;\n        }\n    };\n\n    types.Symbol.prototype[\"name\"] = function() {\n        var idx = this._name.indexOf(\"/\");\n        if(idx != -1) {\n            return this._name.substring(idx+1, this._name.length);\n        } else {\n            return this._name;\n        }\n    };\n\n    types.Symbol.prototype.toString = function() {\n        return this._name;\n    };\n\n    types.Symbol.prototype.equiv = function(other) {\n        return eq.equals(this, other);\n    };\n    types.Symbol.prototype[\"equiv\"] = types.Symbol.prototype.equiv;\n\n    types.Symbol.prototype.com$cognitect$transit$equals = function(other) {\n        return (other instanceof types.Symbol) && this._name == other._name;\n    };\n\n    types.Symbol.prototype.com$cognitect$transit$hashCode = function() {\n        if(this.hashCode === -1) {\n            this.hashCode = eq.hashCode(this._name);\n        }\n        return this.hashCode;\n    };\n\n    types.symbol = function(s) {\n        return new types.Symbol(s);\n    };\n\n    types.isSymbol = function(x) {\n        return x instanceof types.Symbol;\n    };\n\n    types.hexFor = function(aLong, sidx, eidx) {\n        var ret   = \"\",\n            eidx  = eidx || (sidx+1);\n\n        for(var i=sidx, shift=(7-i)*8, mask=Long.fromInt(0xff).shiftLeft(shift); i < eidx; i++, shift-=8, mask=mask.shiftRightUnsigned(8)) {\n            var s = aLong.and(mask).shiftRightUnsigned(shift).toString(16);\n            if(s.length == 1) {\n                s = \"0\" + s;\n            }\n            ret += s;\n        }\n\n        return ret;\n    };\n\n    /**\n     * @constructor\n     */\n    types.UUID = function Transit$UUID(high, low) {\n        this.high = high;\n        this.low = low;\n        this.hashCode = -1;\n    };\n\n    types.UUID.prototype.getLeastSignificantBits = function() {\n        return this.low;\n    };\n\n    types.UUID.prototype.getMostSignificantBits = function() {\n        return this.high;\n    };\n\n    types.UUID.prototype.toString = function() {\n        var s    = \"\",\n            hi64 = this.high,\n            lo64 = this.low;\n\n        s += types.hexFor(hi64, 0, 4) + \"-\";\n        s += types.hexFor(hi64, 4, 6) + \"-\";\n        s += types.hexFor(hi64, 6, 8) + \"-\";\n        s += types.hexFor(lo64, 0, 2) + \"-\";\n        s += types.hexFor(lo64, 2, 8);\n\n        return s;\n    };\n\n    types.UUID.prototype.equiv = function(other) {\n        return eq.equals(this, other);\n    };\n    types.UUID.prototype[\"equiv\"] = types.UUID.prototype.equiv;\n\n    types.UUID.prototype.com$cognitect$transit$equals = function(other) {\n        return (other instanceof types.UUID) && this.high.equals(other.high) && this.low.equals(other.low);\n    };\n\n    types.UUID.prototype.com$cognitect$transit$hashCode = function() {\n        if(this.hashCode === -1) {\n            // TODO: follow http://hg.openjdk.java.net/jdk6/jdk6/jdk/file/2d585507a41b/src/share/classes/java/util/UUID.java\n            this.hashCode = eq.hashCode(this.toString());\n        }\n        return this.hashCode;\n    };\n\n    types.UUIDfromString = function uuidFromString(s) {\n        var s    = s.replace(/-/g, \"\"),\n            hi64 = null,\n            lo64 = null,\n            hi32 = 0,\n            lo32 = 0,\n            off  = 24,\n            i    = 0;\n\n        for(hi32=0, i=0, off= 24; i < 8; i+=2, off-=8) {\n            hi32 |= (parseInt(s.substring(i,i+2),16) << off);\n        }\n\n        for(lo32=0, i=8, off=24; i < 16; i+=2, off-=8) {\n            lo32 |= (parseInt(s.substring(i,i+2),16) << off);\n        }\n\n        hi64 = Long.fromBits(lo32, hi32);\n\n        for(hi32=0, i=16, off=24; i < 24; i+=2, off-=8) {\n            hi32 |= (parseInt(s.substring(i,i+2),16) << off);\n        }\n\n        for(lo32=0, i=24, off=24; i < 32; i+=2, off-=8) {\n            lo32 |= (parseInt(s.substring(i,i+2),16) << off);\n        }\n\n        lo64 = Long.fromBits(lo32, hi32);\n\n        return new types.UUID(hi64, lo64);\n    };\n\n    types.uuid = function(s) {\n        return types.UUIDfromString(s);\n    };\n\n    types.isUUID = function(x) {\n        return x instanceof types.UUID;\n    };\n\n    types.date = function(s) {\n        s = typeof s === \"number\" ? s : parseInt(s, 10);\n        return new Date(s);\n    };\n\n    types.verboseDate = function(s) {\n        return new Date(s);\n    };\n\n    Date.prototype.com$cognitect$transit$equals = function(other) {\n        if(other instanceof Date) {\n            return this.valueOf() === other.valueOf();\n        } else {\n            return false;\n        }\n    };\n\n    Date.prototype.com$cognitect$transit$hashCode = function() {\n        return this.valueOf();\n    };\n\n    /**\n     * @param {string} str\n     * @param {*=} decoder\n     * @returns {com.cognitect.transit.types.TaggedValue|Uint8Array}\n     */\n    types.binary = function(str, decoder) {\n        if((!decoder || (decoder.preferBuffers !== false)) && (typeof Buffer != \"undefined\")) {\n            return new Buffer(str, \"base64\");\n        } else if(typeof Uint8Array != \"undefined\") {\n            return util.Base64ToUint8(str);\n        } else {\n            return types.taggedValue(\"b\", str);\n        }\n    };\n\n    types.isBinary = function(x) {\n        if((typeof Buffer != \"undefined\") && (x instanceof Buffer)) {\n            return true;\n        } else if((typeof Uint8Array != \"undefined\") && (x instanceof Uint8Array)) {\n            return true;\n        } else {\n            return (x instanceof types.TaggedValue) && (x.tag === \"b\");\n        }\n    };\n\n    types.uri = function(s) {\n        return types.taggedValue(\"r\", s);\n    };\n\n    types.isURI = function(x) {\n        return (x instanceof types.TaggedValue) && (x.tag === \"r\");\n    };\n\n    /**\n     * @const\n     * @type {number}\n     */\n    types.KEYS = 0;\n\n    /**\n     * @const\n     * @type {number}\n     */\n    types.VALUES = 1;\n\n    /**\n     * @const\n     * @type {number}\n     */\n    types.ENTRIES = 2;\n\n    /**\n     * @constructor\n     */\n    types.TransitArrayMapIterator = function Transit$ArrayMapIterator(entries, type) {\n        this.entries = entries;\n        this.type = type || types.KEYS;\n        this.idx = 0;\n    };\n\n    types.TransitArrayMapIterator.prototype.next = function() {\n        if(this.idx < this.entries.length) {\n\n            var value = null;\n\n            if(this.type === types.KEYS) {\n                value = this.entries[this.idx];\n            } else if(this.type === types.VALUES) {\n                value = this.entries[this.idx+1];\n            } else {\n                value = [this.entries[this.idx], this.entries[this.idx+1]];\n            }\n\n            var ret = {\n                \"value\": value,\n                \"done\": false\n            };\n\n            this.idx+=2;\n\n            return ret;\n        } else {\n            return {\"value\": null, \"done\": true}\n        }\n    };\n    types.TransitArrayMapIterator.prototype[\"next\"] = types.TransitArrayMapIterator.prototype.next;\n\n    types.TransitArrayMapIterator.prototype[types.ITERATOR] = function() {\n        return this;\n    };\n\n    /**\n     * @constructor\n     */\n    types.TransitMapIterator = function Transit$MapIterator(map, type) {\n        this.map = map;\n        this.type = type || types.KEYS;\n        this.keys = this.map.getKeys();\n        this.idx = 0;\n        /** @type {?Object} */\n        this.bucket = null;\n        this.bucketIdx = 0;\n    };\n\n    types.TransitMapIterator.prototype.next = function() {\n        if(this.idx < this.map.size) {\n            if((this.bucket == null) || !(this.bucketIdx < this.bucket.length)) {\n                this.bucket = this.map.map[this.keys[this.idx]];\n                this.bucketIdx = 0;\n            }\n\n            var value = null;\n            if(this.type === types.KEYS) {\n                value = this.bucket[this.bucketIdx];\n            } else if(this.type === types.VALUES) {\n                value = this.bucket[this.bucketIdx+1];\n            } else {\n                value = [this.bucket[this.bucketIdx], this.bucket[this.bucketIdx+1]];\n            }\n\n            var ret = {\n                \"value\": value,\n                \"done\": false\n            };\n\n            this.idx++;\n            this.bucketIdx+=2;\n\n            return ret;\n        } else {\n            return {\"value\": null, \"done\": true};\n        }\n    };\n    types.TransitMapIterator.prototype[\"next\"] = types.TransitMapIterator.prototype.next;\n\n    types.TransitMapIterator.prototype[types.ITERATOR] = function() {\n        return this;\n    };\n\n    types.mapEquals = function(me, you) {\n        if ((me instanceof types.TransitMap) && types.isMap(you)) {\n            if(me.size !== you.size) return false;\n            for (var code in me.map) {\n                var bucket = me.map[code];\n                for (var j = 0; j < bucket.length; j+=2) {\n                    if (!eq.equals(bucket[j+1], you.get(bucket[j]))) {\n                        return false;\n                    }\n                }\n            }\n            return true;\n        } else if((me instanceof types.TransitArrayMap) && types.isMap(you)) {\n            if(me.size !== you.size) return false;\n            var entries = me._entries;\n            for (var j = 0; j < entries.length; j+=2) {\n                if (!eq.equals(entries[j+1], you.get(entries[j]))) {\n                    return false;\n                }\n            }\n            return true;\n        } else if(you != null && (typeof you === \"object\")) {\n            var ks    = util.objectKeys(you),\n                kslen = ks.length;\n            if(me.size === kslen) {\n                for(var i = 0 ; i < kslen; i++) {\n                    var k = ks[i];\n                    if(!me.has(k) || !eq.equals(you[k], me.get(k))) {\n                        return false;\n                    }\n                }\n                return true;\n            } else {\n                return false;\n            }\n        } else {\n            return false;\n        }\n    };\n\n    /**\n     * @const\n     * @type {number}\n     */\n    types.SMALL_ARRAY_MAP_THRESHOLD = 8;\n\n    /**\n     * @const\n     * @type {number}\n     */\n    types.ARRAY_MAP_THRESHOLD = 32;\n\n    /**\n     * @const\n     * @type {number}\n     */\n    types.ARRAY_MAP_ACCESS_THRESHOLD = 32;\n\n    types.print = function(x) {\n        if(x == null) {\n            return \"null\";\n        } if(goog.isArray(x)) {\n            return \"[\" + x.toString() + \"]\";\n        } else if(goog.isString(x)) {\n            return \"\\\"\" + x + \"\\\"\";\n        } else {\n            return x.toString();\n        }\n    };\n\n    types.printMap = function(map) {\n        var idx = 0,\n            str = \"TransitMap {\";\n        map.forEach(function(v, k) {\n            str += types.print(k) + \" => \" + types.print(v);\n            if(idx < map.size-1) {\n                str += \", \";\n            }\n            idx++;\n        });\n        return str + \"}\";\n    };\n\n    types.printSet = function(set) {\n        var idx  = 0,\n            str  = \"TransitSet {\";\n        set.forEach(function(v) {\n            str += types.print(v);\n            if(idx < set.size-1) {\n                str += \", \";\n            }\n            idx++;\n        });\n        return str + \"}\";\n    };\n\n    /**\n     * @constructor\n     * @param {Array} entries\n     */\n    types.TransitArrayMap = function Transit$ArrayMap(entries) {\n        this._entries = entries;\n        this.backingMap = null;\n        this.hashCode = -1;\n        this.size = entries.length / 2;\n        this.accesses = 0;\n    };\n\n    types.TransitArrayMap.prototype.toString = function() {\n        return types.printMap(this);\n    };\n\n    types.TransitArrayMap.prototype[\"inspect\"] = function() {\n        return this.toString();\n    };\n\n    types.TransitArrayMap.prototype.convert = function() {\n        if(this.backingMap) {\n            throw Error(\"Invalid operation, already converted\");\n        }\n        if(this.size < types.SMALL_ARRAY_MAP_THRESHOLD) return false;\n        this.accesses++;\n        if(this.accesses > types.ARRAY_MAP_ACCESS_THRESHOLD) {\n            this.backingMap = types.map(this._entries, false, true);\n            this._entries = [];\n            return true;\n        } else {\n            return false;\n        }\n    };\n\n    types.TransitArrayMap.prototype.clear = function() {\n        this.hashCode = -1;\n        if(this.backingMap) {\n            this.backingMap.clear();\n            this.size = 0;\n        } else {\n            this._entries = [];\n            this.size = 0;\n        }\n    };\n    types.TransitArrayMap.prototype[\"clear\"] = types.TransitArrayMap.prototype.clear;\n\n    types.TransitArrayMap.prototype.keys = function() {\n        if(this.backingMap) {\n            return this.backingMap.keys();\n        } else {\n            return new types.TransitArrayMapIterator(this._entries, types.KEYS);\n        }\n    };\n    types.TransitArrayMap.prototype[\"keys\"] = types.TransitArrayMap.prototype.keys;\n\n    types.TransitArrayMap.prototype.keySet = function() {\n        if(this.backingMap) {\n            return this.backingMap.keySet();\n        } else {\n            var ret = [];\n            for(var i = 0, j = 0; j < this._entries.length; i++, j+=2) {\n                ret[i] = this._entries[j];\n            }\n            return ret;\n        }\n    };\n    types.TransitArrayMap.prototype[\"keySet\"] = types.TransitArrayMap.prototype.keySet;\n\n    types.TransitArrayMap.prototype.entries = function() {\n        if(this.backingMap) {\n            return this.backingMap.entries();\n        } else {\n            return new types.TransitArrayMapIterator(this._entries, types.ENTRIES);\n        }\n    };\n    types.TransitArrayMap.prototype[\"entries\"] = types.TransitArrayMap.prototype.entries;\n\n    types.TransitArrayMap.prototype.values = function() {\n        if(this.backingMap) {\n            return this.backingMap.values();\n        } else {\n            return new types.TransitArrayMapIterator(this._entries, types.VALUES);\n        }\n    };\n    types.TransitArrayMap.prototype[\"values\"] = types.TransitArrayMap.prototype.values;\n\n    /**\n     * @param {function(*,*)} f\n     */\n    types.TransitArrayMap.prototype.forEach = function(f) {\n        if(this.backingMap) {\n            this.backingMap.forEach(f);\n        } else {\n            for(var i = 0; i < this._entries.length; i+=2) {\n                f(this._entries[i+1], this._entries[i]);\n            }\n        }\n    };\n    types.TransitArrayMap.prototype[\"forEach\"] = types.TransitArrayMap.prototype.forEach;\n\n    /**\n     * @param {*} k\n     * @param {*=} notFound\n     * @returns {*}\n     */\n    types.TransitArrayMap.prototype.get = function(k, notFound) {\n        if(this.backingMap) {\n            return this.backingMap.get(k);\n        } else {\n            if(this.convert()) {\n                return this.get(k);\n            } else {\n                for(var i = 0; i < this._entries.length; i+=2) {\n                    if(eq.equals(this._entries[i], k)) {\n                        return this._entries[i+1];\n                    }\n                }\n                return notFound;\n            }\n        }\n    };\n    types.TransitArrayMap.prototype[\"get\"] = types.TransitArrayMap.prototype.get;\n\n    types.TransitArrayMap.prototype.has = function(k) {\n        if(this.backingMap) {\n            return this.backingMap.has(k);\n        } else {\n            if(this.convert()) {\n                return this.has(k);\n            } else {\n                for(var i = 0; i < this._entries.length; i+=2) {\n                    if(eq.equals(this._entries[i], k)) {\n                        return true;\n                    }\n                }\n                return false;\n            }\n        }\n    };\n    types.TransitArrayMap.prototype[\"has\"] = types.TransitArrayMap.prototype.has;\n\n    types.TransitArrayMap.prototype.set = function(k, v) {\n        this.hashCode = -1;\n        if(this.backingMap) {\n            this.backingMap.set(k, v);\n            this.size = this.backingMap.size;\n        } else {\n            for(var i = 0; i < this._entries.length; i+=2) {\n                if(eq.equals(this._entries[i], k)) {\n                    this._entries[i+1] = v;\n                    return;\n                }\n            }\n\n            this._entries.push(k);\n            this._entries.push(v);\n            this.size++;\n\n            if(this.size > types.ARRAY_MAP_THRESHOLD) {\n                this.backingMap = types.map(this._entries, false, true);\n                this._entries = null;\n            }\n        }\n    };\n    types.TransitArrayMap.prototype[\"set\"] = types.TransitArrayMap.prototype.set;\n\n    types.TransitArrayMap.prototype[\"delete\"] = function(k) {\n        this.hashCode = -1;\n        if(this.backingMap) {\n            var ret = this.backingMap[\"delete\"](k);\n            this.size = this.backingMap.size;\n            return ret;\n        } else {\n            for(var i = 0; i < this._entries.length; i+=2) {\n                if(eq.equals(this._entries[i], k)) {\n                    var ret = this._entries[i+1];\n                    this._entries.splice(i, 2);\n                    this.size--;\n                    return ret;\n                }\n            }\n        }\n    };\n\n    types.TransitArrayMap.prototype.clone = function() {\n        var clone = types.map();\n\n        this.forEach(function(v, k) {\n            clone.set(k, v);\n        });\n\n        return clone;\n    };\n    types.TransitArrayMap.prototype[\"clone\"] = types.TransitArrayMap.prototype.clone;\n\n    types.TransitArrayMap.prototype[types.ITERATOR] = function() {\n        return this.entries();\n    };\n\n    types.TransitArrayMap.prototype.com$cognitect$transit$hashCode = function() {\n        if(this.backingMap) {\n            return this.backingMap.com$cognitect$transit$hashCode();\n        } else {\n            if(this.hashCode === -1) {\n                this.hashCode = eq.hashMapLike(this);\n            }\n            return this.hashCode;\n        }\n    };\n\n    types.TransitArrayMap.prototype.com$cognitect$transit$equals = function(other) {\n        if(this.backingMap) {\n            return types.mapEquals(this.backingMap, other);\n        } else {\n            return types.mapEquals(this, other);\n        }\n    };\n\n    /**\n     * TransitMap\n     *   A hash map. Support arbitrarily complex keys. Lookup is based on the value of the\n     *   the key not identity. Otherwise the API follows the ES6 map interface:\n     *   http://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\n     * @constructor\n     * @param {null|Array=} keys\n     * @param {null|Object=} map\n     * @param {null|number=} size\n     */\n    types.TransitMap = function Transit$Map(keys, map, size) {\n        this.map = map || {};\n        this._keys = keys || [];\n        this.size = size || 0;\n        this.hashCode = -1;\n    };\n\n    types.TransitMap.prototype.toString = function() {\n        return types.printMap(this);\n    };\n\n    types.TransitMap.prototype[\"inspect\"] = function() {\n        return this.toString();\n    };\n\n    types.TransitMap.prototype.clear = function() {\n        this.hashCode = -1;\n        this.map = {};\n        this._keys = [];\n        this.size = 0;\n    };\n    types.TransitMap.prototype[\"clear\"] = types.TransitMap.prototype.clear;\n\n    types.TransitMap.prototype.getKeys = function() {\n        if(this._keys != null) {\n            return this._keys;\n        } else {\n            return util.objectKeys(this.map);\n        }\n    };\n\n    types.TransitMap.prototype[\"delete\"] = function(k) {\n        this.hashCode = -1;\n        this._keys = null;\n        var code   = eq.hashCode(k),\n            bucket = this.map[code];\n\n        for(var i = 0; i < bucket.length; i+=2) {\n            if(eq.equals(k, bucket[i])) {\n                var ret = bucket[i+1];\n                bucket.splice(i,2);\n                if(bucket.length === 0) {\n                    delete this.map[code];\n                }\n                this.size--;\n                return ret;\n            }\n        }\n    };\n\n    types.TransitMap.prototype.entries = function() {\n        return new types.TransitMapIterator(this, types.ENTRIES);\n    };\n    types.TransitMap.prototype[\"entries\"] = types.TransitMap.prototype.entries;\n\n    types.TransitMap.prototype.forEach = function(callback) {\n        var ks = this.getKeys();\n        for(var i = 0; i < ks.length; i++) {\n            var bucket = this.map[ks[i]];\n            for(var j = 0; j < bucket.length; j+=2) {\n                callback(bucket[j+1], bucket[j], this);\n            }\n        }\n    };\n    types.TransitMap.prototype[\"forEach\"] = types.TransitMap.prototype.forEach;\n\n    types.TransitMap.prototype.get = function(k, notFound) {\n        var code   = eq.hashCode(k),\n            bucket = this.map[code];\n        if(bucket != null) {\n            for(var i = 0; i < bucket.length; i+=2) {\n                if(eq.equals(k,bucket[i])) {\n                    return bucket[i+1];\n                }\n            }\n        } else {\n            return notFound;\n        }\n    };\n    types.TransitMap.prototype[\"get\"] = types.TransitMap.prototype.get;\n\n    types.TransitMap.prototype.has = function(k) {\n        var code   = eq.hashCode(k),\n            bucket = this.map[code];\n        if(bucket != null) {\n            for(var i = 0; i < bucket.length; i+=2) {\n                if(eq.equals(k, bucket[i])) {\n                    return true;\n                }\n            }\n            return false;\n        } else {\n            return false;\n        }\n    };\n    types.TransitMap.prototype[\"has\"] = types.TransitMap.prototype.has;\n\n    types.TransitMap.prototype.keys = function() {\n        return new types.TransitMapIterator(this, types.KEYS);\n    };\n    types.TransitMap.prototype[\"keys\"] = types.TransitMap.prototype.keys;\n\n    types.TransitMap.prototype.keySet = function() {\n        var keys = this.getKeys(),\n            ret  = [];\n\n        for(var i = 0; i < keys.length; i++) {\n            var bucket = this.map[keys[i]];\n            for(var j = 0; j < bucket.length; j+=2) {\n                ret.push(bucket[j]);\n            }\n        }\n\n        return ret;\n    };\n    types.TransitMap.prototype[\"keySet\"] = types.TransitMap.prototype.keySet;\n\n    types.TransitMap.prototype.set = function(k, v) {\n        this.hashCode = -1;\n        var code = eq.hashCode(k),\n            bucket = this.map[code];\n        if(bucket == null) {\n            if(this._keys) {\n                this._keys.push(code);\n            }\n            this.map[code] = [k, v];\n            this.size++;\n        } else {\n            var newEntry = true;\n            for(var i = 0; i < bucket.length; i+=2) {\n                if(eq.equals(v, bucket[i])) {\n                    newEntry = false;\n                    bucket[i] = v;\n                    break;\n                }\n            }\n            if(newEntry) {\n                bucket.push(k);\n                bucket.push(v);\n                this.size++;\n            }\n        }\n    };\n    types.TransitMap.prototype[\"set\"] = types.TransitMap.prototype.set;\n\n    types.TransitMap.prototype.values = function() {\n        return new types.TransitMapIterator(this, types.VALUES);\n    };\n    types.TransitMap.prototype[\"values\"] = types.TransitMap.prototype.values;\n\n    types.TransitMap.prototype.clone = function() {\n        var clone = types.map();\n\n        this.forEach(function(v, k) {\n           clone.set(k, v);\n        });\n\n        return clone;\n    };\n    types.TransitMap.prototype[\"clone\"] = types.TransitMap.prototype.clone;\n\n    types.TransitMap.prototype[types.ITERATOR] = function() {\n        return this.entries();\n    };\n\n    types.TransitMap.prototype.com$cognitect$transit$hashCode = function() {\n        if(this.hashCode === -1) {\n            this.hashCode = eq.hashMapLike(this);\n        }\n        return this.hashCode;\n    };\n\n    types.TransitMap.prototype.com$cognitect$transit$equals = function(other) {\n        return types.mapEquals(this, other);\n    };\n\n    /**\n     * @param {Array=} arr\n     * @param {boolean=} checkDups\n     * @param {boolean=} hashMap\n     * @returns {com.cognitect.transit.MapLike}\n     */\n    types.map = function(arr, checkDups, hashMap) {\n        arr = arr || [];\n        checkDups = (checkDups === false) ? checkDups : true;\n        hashMap = (hashMap === true) ? hashMap : false;\n\n        if(!hashMap && (arr.length <= (types.ARRAY_MAP_THRESHOLD*2))) {\n            if(checkDups) {\n                var t = arr;\n                arr = [];\n                for(var i = 0; i < t.length; i+=2) {\n                    var seen = false;\n                    for(var j = 0; j < arr.length; j+=2) {\n                        if(eq.equals(arr[j], t[i])) {\n                            arr[j+1] = t[i+1];\n                            seen = true;\n                            break;\n                        }\n                    }\n                    if(!seen) {\n                        arr.push(t[i]);\n                        arr.push(t[i+1]);\n                    }\n                }\n            }\n            return new types.TransitArrayMap(arr);\n        } else {\n            var map  = {},\n                keys = [],\n                size = 0;\n            for(var i = 0; i < arr.length; i+=2) {\n                var code = eq.hashCode(arr[i]),\n                    bucket = map[code];\n                if(bucket == null) {\n                    keys.push(code);\n                    map[code] = [arr[i], arr[i+1]];\n                    size++;\n                } else {\n                    var newEntry = true;\n                    for(var j = 0; j < bucket.length; j+= 2) {\n                        if(eq.equals(bucket[j], arr[i])) {\n                            bucket[j+1] = arr[i+1];\n                            newEntry = false;\n                            break;\n                        }\n                    }\n                    if(newEntry) {\n                        bucket.push(arr[i]);\n                        bucket.push(arr[i+1]);\n                        size++;\n                    }\n                }\n            }\n            return new types.TransitMap(keys, map, size);\n        }\n    };\n\n    types.isArrayMap = function(x) {\n        return (x instanceof types.TransitArrayMap);\n    };\n\n    types.isMap = function(x) {\n        return ((x instanceof types.TransitArrayMap) ||\n                (x instanceof types.TransitMap));\n    };\n\n    /**\n     * @constructor\n     * @param {com.cognitect.transit.MapLike} map\n     */\n    types.TransitSet = function Transit$Set(map) {\n        this.map = map;\n        this.size = map.size;\n    };\n\n    types.TransitSet.prototype.toString = function() {\n        return types.printSet(this);\n    };\n\n    types.TransitSet.prototype[\"inspect\"] = function() {\n        return this.toString();\n    };\n\n    types.TransitSet.prototype.add = function(value) {\n        this.map.set(value, value);\n        this.size = this.map.size;\n    };\n    types.TransitSet.prototype[\"add\"] = types.TransitSet.prototype.add;\n\n    types.TransitSet.prototype.clear = function() {\n        this.map = new types.TransitMap();\n        this.size = 0;\n    };\n    types.TransitSet.prototype[\"clear\"] = types.TransitSet.prototype.clear;\n\n    types.TransitSet.prototype[\"delete\"] = function(value) {\n        var ret = this.map[\"delete\"](value);\n        this.size = this.map.size;\n        return ret;\n    };\n\n    types.TransitSet.prototype.entries = function() {\n        return this.map.entries();\n    };\n    types.TransitSet.prototype[\"entries\"] = types.TransitSet.prototype.entries;\n\n    /**\n     * @param {function(*,*)} iterator\n     * @param {Object=} thisArg\n     */\n    types.TransitSet.prototype.forEach = function(iterator, thisArg) {\n        var self = this;\n        this.map.forEach(function(v, k, m) {\n            iterator(k, self);\n        });\n    };\n    types.TransitSet.prototype[\"forEach\"] = types.TransitSet.prototype.forEach;\n\n    types.TransitSet.prototype.has = function(value) {\n        return this.map.has(value);\n    };\n    types.TransitSet.prototype[\"has\"] = types.TransitSet.prototype.has;\n\n    types.TransitSet.prototype.keys = function() {\n        return this.map.keys();\n    };\n    types.TransitSet.prototype[\"keys\"] = types.TransitSet.prototype.keys;\n\n    types.TransitSet.prototype.keySet = function() {\n        return this.map.keySet();\n    };\n    types.TransitSet.prototype[\"keySet\"] = types.TransitSet.prototype.keySet;\n\n    types.TransitSet.prototype.values = function() {\n        return this.map.values();\n    };\n    types.TransitSet.prototype[\"values\"] = types.TransitSet.prototype.values;\n\n    types.TransitSet.prototype.clone = function() {\n        var clone = types.set();\n\n        this.forEach(function(k) {\n            clone.add(k);\n        });\n\n        return clone;\n    };\n    types.TransitSet.prototype[\"clone\"] = types.TransitSet.prototype.clone;\n\n    types.TransitSet.prototype[types.ITERATOR] = function() {\n        return this.values();\n    };\n\n    types.TransitSet.prototype.com$cognitect$transit$equals = function(other) {\n        if(other instanceof types.TransitSet) {\n            if(this.size === other.size) {\n                return eq.equals(this.map, other.map);\n            }\n        } else {\n            return false;\n        }\n    };\n\n    types.TransitSet.prototype.com$cognitect$transit$hashCode = function(other) {\n        return eq.hashCode(this.map);\n    };\n\n    /**\n     * @param {Array=} arr\n     * @returns {com.cognitect.transit.SetLike}\n     */\n    types.set = function(arr) {\n        arr = arr || [];\n\n        var map  = {},\n            keys = [],\n            size = 0;\n\n        for(var i = 0; i < arr.length; i++) {\n            var code = eq.hashCode(arr[i]),\n                vals = map[code];\n            if(vals == null) {\n                keys.push(code);\n                map[code] = [arr[i], arr[i]];\n                size++\n            } else {\n                var newEntry = true;\n                for(var j = 0; j < vals.length; j+= 2) {\n                    if(eq.equals(vals[j], arr[i])) {\n                        newEntry = false;\n                        break;\n                    }\n                }\n                if(newEntry) {\n                    vals.push(arr[i]);\n                    vals.push(arr[i]);\n                    size++;\n                }\n            }\n        }\n\n        return new types.TransitSet(new types.TransitMap(keys, map, size));\n    };\n\n    types.isSet = function(x) {\n        return x instanceof types.TransitSet;\n    };\n\n    types.quoted = function(obj) {\n        return types.taggedValue(\"'\", obj);\n    };\n\n    types.isQuoted = function(x) {\n        return (x instanceof types.TaggedValue) && (x.tag === \"'\");\n    };\n\n    types.list = function(xs) {\n        return types.taggedValue(\"list\", xs);\n    };\n\n    types.isList = function(x) {\n        return (x instanceof types.TaggedValue) && (x.tag === \"list\");\n    };\n\n    types.link = function(rep) {\n        return types.taggedValue(\"link\", rep);\n    };\n\n    types.isLink = function(x) {\n        return (x instanceof types.TaggedValue) && (x.tag === \"link\")\n    };\n\n    types.specialDouble = function(v) {\n        switch(v) {\n            case \"-INF\":\n                return -Infinity;\n            case \"INF\":\n                return Infinity;\n            case \"NaN\":\n                return NaN;\n            default:\n                throw new Error(\"Invalid special double value \" + v);\n                break;\n        }\n    };\n\n});\n\n","^;",1569048066000,"^<",["^=",["^>","^N","^?","^S"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/types.js"],"^M",["^=",["^R"]],"^O",true,"^P",["^?","^>","^N","^S"]],["^ ","^3",[1569048066000],"^4","com.cognitect.transit.impl.decoder.js","^5",["^6","com/cognitect/transit/impl/decoder.js"],"^7","com/cognitect/transit/impl/decoder.js","^8","^9","^:","// Copyright 2014 Cognitect. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\ngoog.provide(\"com.cognitect.transit.impl.decoder\");\ngoog.require(\"com.cognitect.transit.util\");\ngoog.require(\"com.cognitect.transit.delimiters\");\ngoog.require(\"com.cognitect.transit.caching\");\ngoog.require(\"com.cognitect.transit.types\");\n\ngoog.scope(function () {\n\n    var decoder = com.cognitect.transit.impl.decoder,\n        util    = com.cognitect.transit.util,\n        d       = com.cognitect.transit.delimiters,\n        caching = com.cognitect.transit.caching,\n        types   = com.cognitect.transit.types;\n\n    // =========================================================================\n    // Decoder\n\n    /**\n     * @constructor\n     */\n    decoder.Tag = function Transit$Tag(s) {\n        this.str = s;\n    };\n\n    decoder.tag = function (s) {\n        return new decoder.Tag(s);\n    };\n\n    decoder.isTag = function (x) {\n        return x && (x instanceof decoder.Tag);\n    };\n\n    decoder.isGroundHandler = function (handler) {\n        switch (handler) {\n            case \"_\":\n            case \"s\":\n            case \"?\":\n            case \"i\":\n            case \"d\":\n            case \"b\":\n            case \"'\":\n            case \"array\":\n            case \"map\":\n                return true;\n        }\n        return false;\n    };\n\n    /**\n     * A transit decoder\n     * @constructor\n     */\n    decoder.Decoder = function Transit$Decoder(options) {\n        this.options = options || {};\n        this.handlers = {};\n        for (var h in this.defaults.handlers) {\n            this.handlers[h] = this.defaults.handlers[h];\n        }\n        for (var h in this.options[\"handlers\"]) {\n            if (decoder.isGroundHandler(h)) {\n                throw new Error(\"Cannot override handler for ground type \\\"\" + h + \"\\\"\");\n            }\n            this.handlers[h] = this.options[\"handlers\"][h];\n        }\n        this.preferStrings = this.options[\"preferStrings\"] != null ? this.options[\"preferStrings\"] : this.defaults.preferStrings;\n        this.preferBuffers = this.options[\"preferBuffers\"] != null ? this.options[\"preferBuffers\"] : this.defaults.preferBuffers;\n        this.defaultHandler = this.options[\"defaultHandler\"] || this.defaults.defaultHandler;\n        /* NOT PUBLIC */\n        this.mapBuilder = this.options[\"mapBuilder\"];\n        this.arrayBuilder = this.options[\"arrayBuilder\"];\n    };\n\n\n    decoder.Decoder.prototype.defaults = {\n        handlers: {\n            \"_\": function (v, d) {\n                return types.nullValue();\n            },\n            \"?\": function (v, d) {\n                return types.boolValue(v);\n            },\n            \"b\": function (v, d) {\n                return types.binary(v, d);\n            },\n            \"i\": function (v, d) {\n                return types.intValue(v);\n            },\n            \"n\": function (v, d) {\n                return types.bigInteger(v);\n            },\n            \"d\": function (v, d) {\n                return types.floatValue(v);\n            },\n            \"f\": function (v, d) {\n                return types.bigDecimalValue(v);\n            },\n            \"c\": function (v, d) {\n                return types.charValue(v);\n            },\n            \":\": function (v, d) {\n                return types.keyword(v);\n            },\n            \"$\": function (v, d) {\n                return types.symbol(v);\n            },\n            \"r\": function (v, d) {\n                return types.uri(v);\n            },\n            \"z\": function (v, d) {\n                return types.specialDouble(v);\n            },\n\n            // tagged\n            \"'\": function (v, d) {\n                return v;\n            },\n            \"m\": function (v, d) {\n                return types.date(v);\n            },\n            \"t\": function (v, d) {\n                return types.verboseDate(v);\n            },\n            \"u\": function (v, d) {\n                return types.uuid(v);\n            },\n            \"set\": function (v, d) {\n                return types.set(v);\n            },\n            \"list\": function (v, d) {\n                return types.list(v);\n            },\n            \"link\": function (v, d) {\n                return types.link(v);\n            },\n            \"cmap\": function (v, d) {\n                return types.map(v, false);\n            }\n        },\n        defaultHandler: function (c, val) {\n            return types.taggedValue(c, val);\n        },\n        preferStrings: true,\n        preferBuffers: true\n    };\n\n    /**\n     * @param {*} node\n     * @param {*} cache\n     * @param {boolean=} asMapKey\n     * @param {boolean=} tagValue\n     * @returns {*}\n     */\n    decoder.Decoder.prototype.decode = function (node, cache, asMapKey, tagValue) {\n        if (node == null) return null;\n\n        var t = typeof node;\n\n        switch (t) {\n            case \"string\":\n                return this.decodeString(node, cache, asMapKey, tagValue);\n                break;\n            case \"object\":\n                if (util.isArray(node)) {\n                    if (node[0] === \"^ \") {\n                        return this.decodeArrayHash(node, cache, asMapKey, tagValue);\n                    } else {\n                        return this.decodeArray(node, cache, asMapKey, tagValue);\n                    }\n                } else {\n                    return this.decodeHash(node, cache, asMapKey, tagValue);\n                }\n                break;\n        }\n\n        return node;\n    };\n    decoder.Decoder.prototype[\"decode\"] = decoder.Decoder.prototype.decode;\n\n    decoder.Decoder.prototype.decodeString = function (string, cache, asMapKey, tagValue) {\n        if (caching.isCacheable(string, asMapKey)) {\n            var val = this.parseString(string, cache, false);\n            if (cache) {\n                cache.write(val, asMapKey);\n            }\n            return val;\n        } else if (caching.isCacheCode(string)) {\n            return cache.read(string, asMapKey);\n        } else {\n            return this.parseString(string, cache, asMapKey);\n        }\n    };\n\n    decoder.Decoder.prototype.decodeHash = function (hash, cache, asMapKey, tagValue) {\n        var ks = util.objectKeys(hash),\n            key = ks[0],\n            tag = ks.length == 1 ? this.decode(key, cache, false, false) : null;\n\n        if (decoder.isTag(tag)) {\n            var val = hash[key],\n                handler = this.handlers[tag.str];\n            if (handler != null) {\n                return handler(this.decode(val, cache, false, true), this);\n            } else {\n                return types.taggedValue(tag.str, this.decode(val, cache, false, false));\n            }\n        } else if (this.mapBuilder) {\n            if ((ks.length < (types.SMALL_ARRAY_MAP_THRESHOLD * 2)) && this.mapBuilder.fromArray) {\n                var nodep = [];\n                for (var i = 0; i < ks.length; i++) {\n                    var strKey = ks[i];\n                    nodep.push(this.decode(strKey, cache, true, false));\n                    nodep.push(this.decode(hash[strKey], cache, false, false));\n                }\n                return this.mapBuilder.fromArray(nodep, hash);\n            } else {\n                var ret = this.mapBuilder.init(hash);\n                for (var i = 0; i < ks.length; i++) {\n                    var strKey = ks[i];\n                    ret = this.mapBuilder.add(ret,\n                        this.decode(strKey, cache, true, false),\n                        this.decode(hash[strKey], cache, false, false),\n                        hash);\n                }\n                return this.mapBuilder.finalize(ret, hash);\n            }\n        } else {\n            var nodep = [];\n\n            for (var i = 0; i < ks.length; i++) {\n                var strKey = ks[i];\n                nodep.push(this.decode(strKey, cache, true, false));\n                nodep.push(this.decode(hash[strKey], cache, false, false));\n            }\n\n            return types.map(nodep, false);\n        }\n    };\n\n    decoder.Decoder.prototype.decodeArrayHash = function (node, cache, asMapKey, tagValue) {\n        if (this.mapBuilder) {\n            if ((node.length < ((types.SMALL_ARRAY_MAP_THRESHOLD * 2) + 1)) && this.mapBuilder.fromArray) {\n                var nodep = [];\n                for (var i = 1; i < node.length; i += 2) {\n                    nodep.push(this.decode(node[i], cache, true, false));\n                    nodep.push(this.decode(node[i + 1], cache, false, false));\n                }\n                return this.mapBuilder.fromArray(nodep, node);\n            } else {\n                var ret = this.mapBuilder.init(node);\n                for (var i = 1; i < node.length; i += 2) {\n                    ret = this.mapBuilder.add(ret,\n                        this.decode(node[i], cache, true, false),\n                        this.decode(node[i + 1], cache, false, false),\n                        node)\n                }\n                return this.mapBuilder.finalize(ret, node);\n            }\n        } else {\n            var nodep = [];\n\n            // collect keys\n            for (var i = 1; i < node.length; i += 2) {\n                nodep.push(this.decode(node[i], cache, true, false));\n                nodep.push(this.decode(node[i + 1], cache, false, false));\n            }\n\n            return types.map(nodep, false);\n        }\n    };\n\n    decoder.Decoder.prototype.decodeArray = function (node, cache, asMapKey, tagValue) {\n        if (tagValue) {\n            var ret = [];\n            for (var i = 0; i < node.length; i++) {\n                ret.push(this.decode(node[i], cache, asMapKey, false));\n            }\n            return ret;\n        } else {\n            var cacheIdx = cache && cache.idx;\n            // tagged value as 2-array case\n            if ((node.length === 2) &&\n                (typeof node[0] === \"string\")) {\n                var tag = this.decode(node[0], cache, false, false);\n                if (decoder.isTag(tag)) {\n                    var val = node[1],\n                        handler = this.handlers[tag.str];\n                    if (handler != null) {\n                        var ret = handler(this.decode(val, cache, asMapKey, true), this);\n                        return ret;\n                    } else {\n                        return types.taggedValue(tag.str, this.decode(val, cache, asMapKey, false))\n                    }\n                }\n            }\n\n            // rewind cache\n            if (cache && (cacheIdx != cache.idx)) {\n                cache.idx = cacheIdx;\n            }\n\n            if (this.arrayBuilder) {\n                // NOTE: hard coded for ClojureScript for now - David\n                if (node.length <= 32 && this.arrayBuilder.fromArray) {\n                    var arr = [];\n                    for (var i = 0; i < node.length; i++) {\n                        arr.push(this.decode(node[i], cache, asMapKey, false));\n                    }\n                    return this.arrayBuilder.fromArray(arr, node);\n                } else {\n                    var ret = this.arrayBuilder.init(node);\n                    for (var i = 0; i < node.length; i++) {\n                        ret = this.arrayBuilder.add(ret, this.decode(node[i], cache, asMapKey, false), node);\n                    }\n                    return this.arrayBuilder.finalize(ret, node);\n                }\n            } else {\n                var ret = [];\n                for (var i = 0; i < node.length; i++) {\n                    ret.push(this.decode(node[i], cache, asMapKey, false));\n                }\n                return ret;\n            }\n        }\n    };\n\n    decoder.Decoder.prototype.parseString = function (string, cache, asMapKey) {\n        if (string.charAt(0) === d.ESC) {\n            var c = string.charAt(1);\n            if (c === d.ESC || c === d.SUB || c === d.RES) {\n                return string.substring(1);\n            } else if (c === d.TAG) {\n                return decoder.tag(string.substring(2));\n            } else {\n                var handler = this.handlers[c];\n                if (handler == null) {\n                    return this.defaultHandler(c, string.substring(2));\n                } else {\n                    return handler(string.substring(2), this);\n                }\n            }\n        } else {\n            return string;\n        }\n    };\n\n    decoder.decoder = function (options) {\n        return new decoder.Decoder(options);\n    };\n\n});\n","^;",1569048066000,"^<",["^=",["^>","^?","^R","^Q","^W"]],"^@",["^ ","^A","^B","^C","^D","^E","0.8.846","^F","transit-js","^G","Transit is a data format and a set of libraries for conveying values between applications written in different languages. This library provides support for marshalling Transit data to/from Javascript.","^H","http://github.com/cognitect/transit-js","^I","^J","^K",["^J","0.8.846"]],"^H",["^L","jar:file:/Users/clojure/.m2/repository/com/cognitect/transit-js/0.8.846/transit-js-0.8.846.jar!/com/cognitect/transit/impl/decoder.js"],"^M",["^=",["^V"]],"^O",true,"^P",["^?","^>","^Q","^W","^R"]]],"~:data-readers",null,"~:shadow.build.classpath/CACHE-TIMESTAMP",1585692398000]