{"version":3,"file":"js/8746-84cff6ef5ffff64aff0b.js","mappings":"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","sources":["webpack://sniffspot/./node_modules/apollo-cache-inmemory/node_modules/tslib/tslib.es6.js","webpack://sniffspot/./node_modules/apollo-cache/lib/bundle.esm.js","webpack://sniffspot/./node_modules/apollo-cache-inmemory/node_modules/@wry/context/lib/context.esm.js","webpack://sniffspot/./node_modules/apollo-cache-inmemory/node_modules/optimism/lib/bundle.esm.js","webpack://sniffspot/./node_modules/apollo-cache-inmemory/lib/bundle.esm.js","webpack://sniffspot/./node_modules/apollo-utilities/node_modules/tslib/tslib.es6.js","webpack://sniffspot/./node_modules/apollo-utilities/lib/bundle.esm.js","webpack://sniffspot/./node_modules/fast-json-stable-stringify/index.js","webpack://sniffspot/./node_modules/graphql/jsutils/defineInspect.js","webpack://sniffspot/./node_modules/graphql/jsutils/inspect.js","webpack://sniffspot/./node_modules/graphql/jsutils/invariant.js","webpack://sniffspot/./node_modules/graphql/jsutils/nodejsCustomInspectSymbol.js","webpack://sniffspot/./node_modules/graphql/language/ast.js","webpack://sniffspot/./node_modules/graphql/language/visitor.js","webpack://sniffspot/./node_modules/ts-invariant/node_modules/tslib/tslib.es6.js","webpack://sniffspot/./node_modules/ts-invariant/lib/invariant.esm.js"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { getFragmentQueryDocument } from 'apollo-utilities';\n\nfunction queryFromPojo(obj) {\n    var op = {\n        kind: 'OperationDefinition',\n        operation: 'query',\n        name: {\n            kind: 'Name',\n            value: 'GeneratedClientQuery',\n        },\n        selectionSet: selectionSetFromObj(obj),\n    };\n    var out = {\n        kind: 'Document',\n        definitions: [op],\n    };\n    return out;\n}\nfunction fragmentFromPojo(obj, typename) {\n    var frag = {\n        kind: 'FragmentDefinition',\n        typeCondition: {\n            kind: 'NamedType',\n            name: {\n                kind: 'Name',\n                value: typename || '__FakeType',\n            },\n        },\n        name: {\n            kind: 'Name',\n            value: 'GeneratedClientQuery',\n        },\n        selectionSet: selectionSetFromObj(obj),\n    };\n    var out = {\n        kind: 'Document',\n        definitions: [frag],\n    };\n    return out;\n}\nfunction selectionSetFromObj(obj) {\n    if (typeof obj === 'number' ||\n        typeof obj === 'boolean' ||\n        typeof obj === 'string' ||\n        typeof obj === 'undefined' ||\n        obj === null) {\n        return null;\n    }\n    if (Array.isArray(obj)) {\n        return selectionSetFromObj(obj[0]);\n    }\n    var selections = [];\n    Object.keys(obj).forEach(function (key) {\n        var nestedSelSet = selectionSetFromObj(obj[key]);\n        var field = {\n            kind: 'Field',\n            name: {\n                kind: 'Name',\n                value: key,\n            },\n            selectionSet: nestedSelSet || undefined,\n        };\n        selections.push(field);\n    });\n    var selectionSet = {\n        kind: 'SelectionSet',\n        selections: selections,\n    };\n    return selectionSet;\n}\nvar justTypenameQuery = {\n    kind: 'Document',\n    definitions: [\n        {\n            kind: 'OperationDefinition',\n            operation: 'query',\n            name: null,\n            variableDefinitions: null,\n            directives: [],\n            selectionSet: {\n                kind: 'SelectionSet',\n                selections: [\n                    {\n                        kind: 'Field',\n                        alias: null,\n                        name: {\n                            kind: 'Name',\n                            value: '__typename',\n                        },\n                        arguments: [],\n                        directives: [],\n                        selectionSet: null,\n                    },\n                ],\n            },\n        },\n    ],\n};\n\nvar ApolloCache = (function () {\n    function ApolloCache() {\n    }\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: options.query,\n            variables: options.variables,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n            variables: options.variables,\n            rootId: options.id,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.writeQuery = function (options) {\n        this.write({\n            dataId: 'ROOT_QUERY',\n            result: options.data,\n            query: options.query,\n            variables: options.variables,\n        });\n    };\n    ApolloCache.prototype.writeFragment = function (options) {\n        this.write({\n            dataId: options.id,\n            result: options.data,\n            variables: options.variables,\n            query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n        });\n    };\n    ApolloCache.prototype.writeData = function (_a) {\n        var id = _a.id, data = _a.data;\n        if (typeof id !== 'undefined') {\n            var typenameResult = null;\n            try {\n                typenameResult = this.read({\n                    rootId: id,\n                    optimistic: false,\n                    query: justTypenameQuery,\n                });\n            }\n            catch (e) {\n            }\n            var __typename = (typenameResult && typenameResult.__typename) || '__ClientData';\n            var dataToWrite = Object.assign({ __typename: __typename }, data);\n            this.writeFragment({\n                id: id,\n                fragment: fragmentFromPojo(dataToWrite, __typename),\n                data: dataToWrite,\n            });\n        }\n        else {\n            this.writeQuery({ query: queryFromPojo(data), data: data });\n        }\n    };\n    return ApolloCache;\n}());\n\nvar Cache;\n(function (Cache) {\n})(Cache || (Cache = {}));\n\nexport { ApolloCache, Cache };\n//# sourceMappingURL=bundle.esm.js.map\n","// This currentContext variable will only be used if the makeSlotClass\r\n// function is called, which happens only if this is the first copy of the\r\n// @wry/context package to be imported.\r\nvar currentContext = null;\r\n// This unique internal object is used to denote the absence of a value\r\n// for a given Slot, and is never exposed to outside code.\r\nvar MISSING_VALUE = {};\r\nvar idCounter = 1;\r\n// Although we can't do anything about the cost of duplicated code from\r\n// accidentally bundling multiple copies of the @wry/context package, we can\r\n// avoid creating the Slot class more than once using makeSlotClass.\r\nvar makeSlotClass = function () { return /** @class */ (function () {\r\n    function Slot() {\r\n        // If you have a Slot object, you can find out its slot.id, but you cannot\r\n        // guess the slot.id of a Slot you don't have access to, thanks to the\r\n        // randomized suffix.\r\n        this.id = [\r\n            \"slot\",\r\n            idCounter++,\r\n            Date.now(),\r\n            Math.random().toString(36).slice(2),\r\n        ].join(\":\");\r\n    }\r\n    Slot.prototype.hasValue = function () {\r\n        for (var context_1 = currentContext; context_1; context_1 = context_1.parent) {\r\n            // We use the Slot object iself as a key to its value, which means the\r\n            // value cannot be obtained without a reference to the Slot object.\r\n            if (this.id in context_1.slots) {\r\n                var value = context_1.slots[this.id];\r\n                if (value === MISSING_VALUE)\r\n                    break;\r\n                if (context_1 !== currentContext) {\r\n                    // Cache the value in currentContext.slots so the next lookup will\r\n                    // be faster. This caching is safe because the tree of contexts and\r\n                    // the values of the slots are logically immutable.\r\n                    currentContext.slots[this.id] = value;\r\n                }\r\n                return true;\r\n            }\r\n        }\r\n        if (currentContext) {\r\n            // If a value was not found for this Slot, it's never going to be found\r\n            // no matter how many times we look it up, so we might as well cache\r\n            // the absence of the value, too.\r\n            currentContext.slots[this.id] = MISSING_VALUE;\r\n        }\r\n        return false;\r\n    };\r\n    Slot.prototype.getValue = function () {\r\n        if (this.hasValue()) {\r\n            return currentContext.slots[this.id];\r\n        }\r\n    };\r\n    Slot.prototype.withValue = function (value, callback, \r\n    // Given the prevalence of arrow functions, specifying arguments is likely\r\n    // to be much more common than specifying `this`, hence this ordering:\r\n    args, thisArg) {\r\n        var _a;\r\n        var slots = (_a = {\r\n                __proto__: null\r\n            },\r\n            _a[this.id] = value,\r\n            _a);\r\n        var parent = currentContext;\r\n        currentContext = { parent: parent, slots: slots };\r\n        try {\r\n            // Function.prototype.apply allows the arguments array argument to be\r\n            // omitted or undefined, so args! is fine here.\r\n            return callback.apply(thisArg, args);\r\n        }\r\n        finally {\r\n            currentContext = parent;\r\n        }\r\n    };\r\n    // Capture the current context and wrap a callback function so that it\r\n    // reestablishes the captured context when called.\r\n    Slot.bind = function (callback) {\r\n        var context = currentContext;\r\n        return function () {\r\n            var saved = currentContext;\r\n            try {\r\n                currentContext = context;\r\n                return callback.apply(this, arguments);\r\n            }\r\n            finally {\r\n                currentContext = saved;\r\n            }\r\n        };\r\n    };\r\n    // Immediately run a callback function without any captured context.\r\n    Slot.noContext = function (callback, \r\n    // Given the prevalence of arrow functions, specifying arguments is likely\r\n    // to be much more common than specifying `this`, hence this ordering:\r\n    args, thisArg) {\r\n        if (currentContext) {\r\n            var saved = currentContext;\r\n            try {\r\n                currentContext = null;\r\n                // Function.prototype.apply allows the arguments array argument to be\r\n                // omitted or undefined, so args! is fine here.\r\n                return callback.apply(thisArg, args);\r\n            }\r\n            finally {\r\n                currentContext = saved;\r\n            }\r\n        }\r\n        else {\r\n            return callback.apply(thisArg, args);\r\n        }\r\n    };\r\n    return Slot;\r\n}()); };\r\n// We store a single global implementation of the Slot class as a permanent\r\n// non-enumerable symbol property of the Array constructor. This obfuscation\r\n// does nothing to prevent access to the Slot class, but at least it ensures\r\n// the implementation (i.e. currentContext) cannot be tampered with, and all\r\n// copies of the @wry/context package (hopefully just one) will share the\r\n// same Slot implementation. Since the first copy of the @wry/context package\r\n// to be imported wins, this technique imposes a very high cost for any\r\n// future breaking changes to the Slot class.\r\nvar globalKey = \"@wry/context:Slot\";\r\nvar host = Array;\r\nvar Slot = host[globalKey] || function () {\r\n    var Slot = makeSlotClass();\r\n    try {\r\n        Object.defineProperty(host, globalKey, {\r\n            value: host[globalKey] = Slot,\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: false,\r\n        });\r\n    }\r\n    finally {\r\n        return Slot;\r\n    }\r\n}();\n\nvar bind = Slot.bind, noContext = Slot.noContext;\r\nfunction setTimeoutWithContext(callback, delay) {\r\n    return setTimeout(bind(callback), delay);\r\n}\r\n// Turn any generator function into an async function (using yield instead\r\n// of await), with context automatically preserved across yields.\r\nfunction asyncFromGen(genFn) {\r\n    return function () {\r\n        var gen = genFn.apply(this, arguments);\r\n        var boundNext = bind(gen.next);\r\n        var boundThrow = bind(gen.throw);\r\n        return new Promise(function (resolve, reject) {\r\n            function invoke(method, argument) {\r\n                try {\r\n                    var result = method.call(gen, argument);\r\n                }\r\n                catch (error) {\r\n                    return reject(error);\r\n                }\r\n                var next = result.done ? resolve : invokeNext;\r\n                if (isPromiseLike(result.value)) {\r\n                    result.value.then(next, result.done ? reject : invokeThrow);\r\n                }\r\n                else {\r\n                    next(result.value);\r\n                }\r\n            }\r\n            var invokeNext = function (value) { return invoke(boundNext, value); };\r\n            var invokeThrow = function (error) { return invoke(boundThrow, error); };\r\n            invokeNext();\r\n        });\r\n    };\r\n}\r\nfunction isPromiseLike(value) {\r\n    return value && typeof value.then === \"function\";\r\n}\r\n// If you use the fibers npm package to implement coroutines in Node.js,\r\n// you should call this function at least once to ensure context management\r\n// remains coherent across any yields.\r\nvar wrappedFibers = [];\r\nfunction wrapYieldingFiberMethods(Fiber) {\r\n    // There can be only one implementation of Fiber per process, so this array\r\n    // should never grow longer than one element.\r\n    if (wrappedFibers.indexOf(Fiber) < 0) {\r\n        var wrap = function (obj, method) {\r\n            var fn = obj[method];\r\n            obj[method] = function () {\r\n                return noContext(fn, arguments, this);\r\n            };\r\n        };\r\n        // These methods can yield, according to\r\n        // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\r\n        wrap(Fiber, \"yield\");\r\n        wrap(Fiber.prototype, \"run\");\r\n        wrap(Fiber.prototype, \"throwInto\");\r\n        wrappedFibers.push(Fiber);\r\n    }\r\n    return Fiber;\r\n}\n\nexport { Slot, asyncFromGen, bind, noContext, setTimeoutWithContext as setTimeout, wrapYieldingFiberMethods };\n//# sourceMappingURL=context.esm.js.map\n","import { Slot } from '@wry/context';\nexport { asyncFromGen, bind as bindContext, noContext, setTimeout } from '@wry/context';\n\nfunction defaultDispose() { }\r\nvar Cache = /** @class */ (function () {\r\n    function Cache(max, dispose) {\r\n        if (max === void 0) { max = Infinity; }\r\n        if (dispose === void 0) { dispose = defaultDispose; }\r\n        this.max = max;\r\n        this.dispose = dispose;\r\n        this.map = new Map();\r\n        this.newest = null;\r\n        this.oldest = null;\r\n    }\r\n    Cache.prototype.has = function (key) {\r\n        return this.map.has(key);\r\n    };\r\n    Cache.prototype.get = function (key) {\r\n        var entry = this.getEntry(key);\r\n        return entry && entry.value;\r\n    };\r\n    Cache.prototype.getEntry = function (key) {\r\n        var entry = this.map.get(key);\r\n        if (entry && entry !== this.newest) {\r\n            var older = entry.older, newer = entry.newer;\r\n            if (newer) {\r\n                newer.older = older;\r\n            }\r\n            if (older) {\r\n                older.newer = newer;\r\n            }\r\n            entry.older = this.newest;\r\n            entry.older.newer = entry;\r\n            entry.newer = null;\r\n            this.newest = entry;\r\n            if (entry === this.oldest) {\r\n                this.oldest = newer;\r\n            }\r\n        }\r\n        return entry;\r\n    };\r\n    Cache.prototype.set = function (key, value) {\r\n        var entry = this.getEntry(key);\r\n        if (entry) {\r\n            return entry.value = value;\r\n        }\r\n        entry = {\r\n            key: key,\r\n            value: value,\r\n            newer: null,\r\n            older: this.newest\r\n        };\r\n        if (this.newest) {\r\n            this.newest.newer = entry;\r\n        }\r\n        this.newest = entry;\r\n        this.oldest = this.oldest || entry;\r\n        this.map.set(key, entry);\r\n        return entry.value;\r\n    };\r\n    Cache.prototype.clean = function () {\r\n        while (this.oldest && this.map.size > this.max) {\r\n            this.delete(this.oldest.key);\r\n        }\r\n    };\r\n    Cache.prototype.delete = function (key) {\r\n        var entry = this.map.get(key);\r\n        if (entry) {\r\n            if (entry === this.newest) {\r\n                this.newest = entry.older;\r\n            }\r\n            if (entry === this.oldest) {\r\n                this.oldest = entry.newer;\r\n            }\r\n            if (entry.newer) {\r\n                entry.newer.older = entry.older;\r\n            }\r\n            if (entry.older) {\r\n                entry.older.newer = entry.newer;\r\n            }\r\n            this.map.delete(key);\r\n            this.dispose(entry.value, key);\r\n            return true;\r\n        }\r\n        return false;\r\n    };\r\n    return Cache;\r\n}());\n\nvar parentEntrySlot = new Slot();\n\nvar reusableEmptyArray = [];\r\nvar emptySetPool = [];\r\nvar POOL_TARGET_SIZE = 100;\r\n// Since this package might be used browsers, we should avoid using the\r\n// Node built-in assert module.\r\nfunction assert(condition, optionalMessage) {\r\n    if (!condition) {\r\n        throw new Error(optionalMessage || \"assertion failure\");\r\n    }\r\n}\r\nfunction valueIs(a, b) {\r\n    var len = a.length;\r\n    return (\r\n    // Unknown values are not equal to each other.\r\n    len > 0 &&\r\n        // Both values must be ordinary (or both exceptional) to be equal.\r\n        len === b.length &&\r\n        // The underlying value or exception must be the same.\r\n        a[len - 1] === b[len - 1]);\r\n}\r\nfunction valueGet(value) {\r\n    switch (value.length) {\r\n        case 0: throw new Error(\"unknown value\");\r\n        case 1: return value[0];\r\n        case 2: throw value[1];\r\n    }\r\n}\r\nfunction valueCopy(value) {\r\n    return value.slice(0);\r\n}\r\nvar Entry = /** @class */ (function () {\r\n    function Entry(fn, args) {\r\n        this.fn = fn;\r\n        this.args = args;\r\n        this.parents = new Set();\r\n        this.childValues = new Map();\r\n        // When this Entry has children that are dirty, this property becomes\r\n        // a Set containing other Entry objects, borrowed from emptySetPool.\r\n        // When the set becomes empty, it gets recycled back to emptySetPool.\r\n        this.dirtyChildren = null;\r\n        this.dirty = true;\r\n        this.recomputing = false;\r\n        this.value = [];\r\n        ++Entry.count;\r\n    }\r\n    // This is the most important method of the Entry API, because it\r\n    // determines whether the cached this.value can be returned immediately,\r\n    // or must be recomputed. The overall performance of the caching system\r\n    // depends on the truth of the following observations: (1) this.dirty is\r\n    // usually false, (2) this.dirtyChildren is usually null/empty, and thus\r\n    // (3) valueGet(this.value) is usually returned without recomputation.\r\n    Entry.prototype.recompute = function () {\r\n        assert(!this.recomputing, \"already recomputing\");\r\n        if (!rememberParent(this) && maybeReportOrphan(this)) {\r\n            // The recipient of the entry.reportOrphan callback decided to dispose\r\n            // of this orphan entry by calling entry.dispose(), so we don't need to\r\n            // (and should not) proceed with the recomputation.\r\n            return void 0;\r\n        }\r\n        return mightBeDirty(this)\r\n            ? reallyRecompute(this)\r\n            : valueGet(this.value);\r\n    };\r\n    Entry.prototype.setDirty = function () {\r\n        if (this.dirty)\r\n            return;\r\n        this.dirty = true;\r\n        this.value.length = 0;\r\n        reportDirty(this);\r\n        // We can go ahead and unsubscribe here, since any further dirty\r\n        // notifications we receive will be redundant, and unsubscribing may\r\n        // free up some resources, e.g. file watchers.\r\n        maybeUnsubscribe(this);\r\n    };\r\n    Entry.prototype.dispose = function () {\r\n        var _this = this;\r\n        forgetChildren(this).forEach(maybeReportOrphan);\r\n        maybeUnsubscribe(this);\r\n        // Because this entry has been kicked out of the cache (in index.js),\r\n        // we've lost the ability to find out if/when this entry becomes dirty,\r\n        // whether that happens through a subscription, because of a direct call\r\n        // to entry.setDirty(), or because one of its children becomes dirty.\r\n        // Because of this loss of future information, we have to assume the\r\n        // worst (that this entry might have become dirty very soon), so we must\r\n        // immediately mark this entry's parents as dirty. Normally we could\r\n        // just call entry.setDirty() rather than calling parent.setDirty() for\r\n        // each parent, but that would leave this entry in parent.childValues\r\n        // and parent.dirtyChildren, which would prevent the child from being\r\n        // truly forgotten.\r\n        this.parents.forEach(function (parent) {\r\n            parent.setDirty();\r\n            forgetChild(parent, _this);\r\n        });\r\n    };\r\n    Entry.count = 0;\r\n    return Entry;\r\n}());\r\nfunction rememberParent(child) {\r\n    var parent = parentEntrySlot.getValue();\r\n    if (parent) {\r\n        child.parents.add(parent);\r\n        if (!parent.childValues.has(child)) {\r\n            parent.childValues.set(child, []);\r\n        }\r\n        if (mightBeDirty(child)) {\r\n            reportDirtyChild(parent, child);\r\n        }\r\n        else {\r\n            reportCleanChild(parent, child);\r\n        }\r\n        return parent;\r\n    }\r\n}\r\nfunction reallyRecompute(entry) {\r\n    // Since this recomputation is likely to re-remember some of this\r\n    // entry's children, we forget our children here but do not call\r\n    // maybeReportOrphan until after the recomputation finishes.\r\n    var originalChildren = forgetChildren(entry);\r\n    // Set entry as the parent entry while calling recomputeNewValue(entry).\r\n    parentEntrySlot.withValue(entry, recomputeNewValue, [entry]);\r\n    if (maybeSubscribe(entry)) {\r\n        // If we successfully recomputed entry.value and did not fail to\r\n        // (re)subscribe, then this Entry is no longer explicitly dirty.\r\n        setClean(entry);\r\n    }\r\n    // Now that we've had a chance to re-remember any children that were\r\n    // involved in the recomputation, we can safely report any orphan\r\n    // children that remain.\r\n    originalChildren.forEach(maybeReportOrphan);\r\n    return valueGet(entry.value);\r\n}\r\nfunction recomputeNewValue(entry) {\r\n    entry.recomputing = true;\r\n    // Set entry.value as unknown.\r\n    entry.value.length = 0;\r\n    try {\r\n        // If entry.fn succeeds, entry.value will become a normal Value.\r\n        entry.value[0] = entry.fn.apply(null, entry.args);\r\n    }\r\n    catch (e) {\r\n        // If entry.fn throws, entry.value will become exceptional.\r\n        entry.value[1] = e;\r\n    }\r\n    // Either way, this line is always reached.\r\n    entry.recomputing = false;\r\n}\r\nfunction mightBeDirty(entry) {\r\n    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\r\n}\r\nfunction setClean(entry) {\r\n    entry.dirty = false;\r\n    if (mightBeDirty(entry)) {\r\n        // This Entry may still have dirty children, in which case we can't\r\n        // let our parents know we're clean just yet.\r\n        return;\r\n    }\r\n    reportClean(entry);\r\n}\r\nfunction reportDirty(child) {\r\n    child.parents.forEach(function (parent) { return reportDirtyChild(parent, child); });\r\n}\r\nfunction reportClean(child) {\r\n    child.parents.forEach(function (parent) { return reportCleanChild(parent, child); });\r\n}\r\n// Let a parent Entry know that one of its children may be dirty.\r\nfunction reportDirtyChild(parent, child) {\r\n    // Must have called rememberParent(child) before calling\r\n    // reportDirtyChild(parent, child).\r\n    assert(parent.childValues.has(child));\r\n    assert(mightBeDirty(child));\r\n    if (!parent.dirtyChildren) {\r\n        parent.dirtyChildren = emptySetPool.pop() || new Set;\r\n    }\r\n    else if (parent.dirtyChildren.has(child)) {\r\n        // If we already know this child is dirty, then we must have already\r\n        // informed our own parents that we are dirty, so we can terminate\r\n        // the recursion early.\r\n        return;\r\n    }\r\n    parent.dirtyChildren.add(child);\r\n    reportDirty(parent);\r\n}\r\n// Let a parent Entry know that one of its children is no longer dirty.\r\nfunction reportCleanChild(parent, child) {\r\n    // Must have called rememberChild(child) before calling\r\n    // reportCleanChild(parent, child).\r\n    assert(parent.childValues.has(child));\r\n    assert(!mightBeDirty(child));\r\n    var childValue = parent.childValues.get(child);\r\n    if (childValue.length === 0) {\r\n        parent.childValues.set(child, valueCopy(child.value));\r\n    }\r\n    else if (!valueIs(childValue, child.value)) {\r\n        parent.setDirty();\r\n    }\r\n    removeDirtyChild(parent, child);\r\n    if (mightBeDirty(parent)) {\r\n        return;\r\n    }\r\n    reportClean(parent);\r\n}\r\nfunction removeDirtyChild(parent, child) {\r\n    var dc = parent.dirtyChildren;\r\n    if (dc) {\r\n        dc.delete(child);\r\n        if (dc.size === 0) {\r\n            if (emptySetPool.length < POOL_TARGET_SIZE) {\r\n                emptySetPool.push(dc);\r\n            }\r\n            parent.dirtyChildren = null;\r\n        }\r\n    }\r\n}\r\n// If the given entry has a reportOrphan method, and no remaining parents,\r\n// call entry.reportOrphan and return true iff it returns true. The\r\n// reportOrphan function should return true to indicate entry.dispose()\r\n// has been called, and the entry has been removed from any other caches\r\n// (see index.js for the only current example).\r\nfunction maybeReportOrphan(entry) {\r\n    return entry.parents.size === 0 &&\r\n        typeof entry.reportOrphan === \"function\" &&\r\n        entry.reportOrphan() === true;\r\n}\r\n// Removes all children from this entry and returns an array of the\r\n// removed children.\r\nfunction forgetChildren(parent) {\r\n    var children = reusableEmptyArray;\r\n    if (parent.childValues.size > 0) {\r\n        children = [];\r\n        parent.childValues.forEach(function (_value, child) {\r\n            forgetChild(parent, child);\r\n            children.push(child);\r\n        });\r\n    }\r\n    // After we forget all our children, this.dirtyChildren must be empty\r\n    // and therefore must have been reset to null.\r\n    assert(parent.dirtyChildren === null);\r\n    return children;\r\n}\r\nfunction forgetChild(parent, child) {\r\n    child.parents.delete(parent);\r\n    parent.childValues.delete(child);\r\n    removeDirtyChild(parent, child);\r\n}\r\nfunction maybeSubscribe(entry) {\r\n    if (typeof entry.subscribe === \"function\") {\r\n        try {\r\n            maybeUnsubscribe(entry); // Prevent double subscriptions.\r\n            entry.unsubscribe = entry.subscribe.apply(null, entry.args);\r\n        }\r\n        catch (e) {\r\n            // If this Entry has a subscribe function and it threw an exception\r\n            // (or an unsubscribe function it previously returned now throws),\r\n            // return false to indicate that we were not able to subscribe (or\r\n            // unsubscribe), and this Entry should remain dirty.\r\n            entry.setDirty();\r\n            return false;\r\n        }\r\n    }\r\n    // Returning true indicates either that there was no entry.subscribe\r\n    // function or that it succeeded.\r\n    return true;\r\n}\r\nfunction maybeUnsubscribe(entry) {\r\n    var unsubscribe = entry.unsubscribe;\r\n    if (typeof unsubscribe === \"function\") {\r\n        entry.unsubscribe = void 0;\r\n        unsubscribe();\r\n    }\r\n}\n\n// A trie data structure that holds object keys weakly, yet can also hold\r\n// non-object keys, unlike the native `WeakMap`.\r\nvar KeyTrie = /** @class */ (function () {\r\n    function KeyTrie(weakness) {\r\n        this.weakness = weakness;\r\n    }\r\n    KeyTrie.prototype.lookup = function () {\r\n        var array = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            array[_i] = arguments[_i];\r\n        }\r\n        return this.lookupArray(array);\r\n    };\r\n    KeyTrie.prototype.lookupArray = function (array) {\r\n        var node = this;\r\n        array.forEach(function (key) { return node = node.getChildTrie(key); });\r\n        return node.data || (node.data = Object.create(null));\r\n    };\r\n    KeyTrie.prototype.getChildTrie = function (key) {\r\n        var map = this.weakness && isObjRef(key)\r\n            ? this.weak || (this.weak = new WeakMap())\r\n            : this.strong || (this.strong = new Map());\r\n        var child = map.get(key);\r\n        if (!child)\r\n            map.set(key, child = new KeyTrie(this.weakness));\r\n        return child;\r\n    };\r\n    return KeyTrie;\r\n}());\r\nfunction isObjRef(value) {\r\n    switch (typeof value) {\r\n        case \"object\":\r\n            if (value === null)\r\n                break;\r\n        // Fall through to return true...\r\n        case \"function\":\r\n            return true;\r\n    }\r\n    return false;\r\n}\n\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\r\n// a unique object for any shallow-identical list of arguments. If you need\r\n// to implement a custom makeCacheKey function, you may find it helpful to\r\n// delegate the final work to defaultMakeCacheKey, which is why we export it\r\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\r\n// does not support WeakMap, or you have the ability to return a string key.\r\n// In those cases, just write your own custom makeCacheKey functions.\r\nvar keyTrie = new KeyTrie(typeof WeakMap === \"function\");\r\nfunction defaultMakeCacheKey() {\r\n    var args = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        args[_i] = arguments[_i];\r\n    }\r\n    return keyTrie.lookupArray(args);\r\n}\r\nvar caches = new Set();\r\nfunction wrap(originalFunction, options) {\r\n    if (options === void 0) { options = Object.create(null); }\r\n    var cache = new Cache(options.max || Math.pow(2, 16), function (entry) { return entry.dispose(); });\r\n    var disposable = !!options.disposable;\r\n    var makeCacheKey = options.makeCacheKey || defaultMakeCacheKey;\r\n    function optimistic() {\r\n        if (disposable && !parentEntrySlot.hasValue()) {\r\n            // If there's no current parent computation, and this wrapped\r\n            // function is disposable (meaning we don't care about entry.value,\r\n            // just dependency tracking), then we can short-cut everything else\r\n            // in this function, because entry.recompute() is going to recycle\r\n            // the entry object without recomputing anything, anyway.\r\n            return void 0;\r\n        }\r\n        var key = makeCacheKey.apply(null, arguments);\r\n        if (key === void 0) {\r\n            return originalFunction.apply(null, arguments);\r\n        }\r\n        var args = Array.prototype.slice.call(arguments);\r\n        var entry = cache.get(key);\r\n        if (entry) {\r\n            entry.args = args;\r\n        }\r\n        else {\r\n            entry = new Entry(originalFunction, args);\r\n            cache.set(key, entry);\r\n            entry.subscribe = options.subscribe;\r\n            if (disposable) {\r\n                entry.reportOrphan = function () { return cache.delete(key); };\r\n            }\r\n        }\r\n        var value = entry.recompute();\r\n        // Move this entry to the front of the least-recently used queue,\r\n        // since we just finished computing its value.\r\n        cache.set(key, entry);\r\n        caches.add(cache);\r\n        // Clean up any excess entries in the cache, but only if there is no\r\n        // active parent entry, meaning we're not in the middle of a larger\r\n        // computation that might be flummoxed by the cleaning.\r\n        if (!parentEntrySlot.hasValue()) {\r\n            caches.forEach(function (cache) { return cache.clean(); });\r\n            caches.clear();\r\n        }\r\n        // If options.disposable is truthy, the caller of wrap is telling us\r\n        // they don't care about the result of entry.recompute(), so we should\r\n        // avoid returning the value, so it won't be accidentally used.\r\n        return disposable ? void 0 : value;\r\n    }\r\n    optimistic.dirty = function () {\r\n        var key = makeCacheKey.apply(null, arguments);\r\n        var child = key !== void 0 && cache.get(key);\r\n        if (child) {\r\n            child.setDirty();\r\n        }\r\n    };\r\n    return optimistic;\r\n}\n\nexport { KeyTrie, defaultMakeCacheKey, wrap };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __assign, __extends } from 'tslib';\nimport { ApolloCache } from 'apollo-cache';\nimport { isTest, getQueryDefinition, assign, getDefaultValues, isEqual, getMainDefinition, getFragmentDefinitions, createFragmentMap, shouldInclude, isField, resultKeyNameFromField, isInlineFragment, mergeDeepArray, argumentsObjectFromField, getDirectiveInfoFromField, maybeDeepFreeze, isIdValue, getStoreKeyName, toIdValue, isJsonValue, canUseWeakMap, getOperationDefinition, isProduction, storeKeyNameFromField, addTypenameToDocument } from 'apollo-utilities';\nimport { wrap, KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\n\nvar haveWarned = false;\nfunction shouldWarn() {\n    var answer = !haveWarned;\n    if (!isTest()) {\n        haveWarned = true;\n    }\n    return answer;\n}\nvar HeuristicFragmentMatcher = (function () {\n    function HeuristicFragmentMatcher() {\n    }\n    HeuristicFragmentMatcher.prototype.ensureReady = function () {\n        return Promise.resolve();\n    };\n    HeuristicFragmentMatcher.prototype.canBypassInit = function () {\n        return true;\n    };\n    HeuristicFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        if (!__typename) {\n            if (shouldWarn()) {\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"You're using fragments in your queries, but either don't have the addTypename:\\n  true option set in Apollo Client, or you are trying to write a fragment to the store without the __typename.\\n   Please turn on the addTypename option and include __typename when writing fragments so that Apollo Client\\n   can accurately match fragments.\");\n                process.env.NODE_ENV === \"production\" || invariant.warn('Could not find __typename on Fragment ', typeCondition, obj);\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"DEPRECATION WARNING: using fragments without __typename is unsupported behavior \" +\n                    \"and will be removed in future versions of Apollo client. You should fix this and set addTypename to true now.\");\n            }\n            return 'heuristic';\n        }\n        if (__typename === typeCondition) {\n            return true;\n        }\n        if (shouldWarn()) {\n            process.env.NODE_ENV === \"production\" || invariant.error('You are using the simple (heuristic) fragment matcher, but your ' +\n                'queries contain union or interface types. Apollo Client will not be ' +\n                'able to accurately map fragments. To make this error go away, use ' +\n                'the `IntrospectionFragmentMatcher` as described in the docs: ' +\n                'https://www.apollographql.com/docs/react/advanced/fragments.html#fragment-matcher');\n        }\n        return 'heuristic';\n    };\n    return HeuristicFragmentMatcher;\n}());\nvar IntrospectionFragmentMatcher = (function () {\n    function IntrospectionFragmentMatcher(options) {\n        if (options && options.introspectionQueryResultData) {\n            this.possibleTypesMap = this.parseIntrospectionResult(options.introspectionQueryResultData);\n            this.isReady = true;\n        }\n        else {\n            this.isReady = false;\n        }\n        this.match = this.match.bind(this);\n    }\n    IntrospectionFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        process.env.NODE_ENV === \"production\" ? invariant(this.isReady, 1) : invariant(this.isReady, 'FragmentMatcher.match() was called before FragmentMatcher.init()');\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        process.env.NODE_ENV === \"production\" ? invariant(__typename, 2) : invariant(__typename, \"Cannot match fragment because __typename property is missing: \" + JSON.stringify(obj));\n        if (__typename === typeCondition) {\n            return true;\n        }\n        var implementingTypes = this.possibleTypesMap[typeCondition];\n        if (__typename &&\n            implementingTypes &&\n            implementingTypes.indexOf(__typename) > -1) {\n            return true;\n        }\n        return false;\n    };\n    IntrospectionFragmentMatcher.prototype.parseIntrospectionResult = function (introspectionResultData) {\n        var typeMap = {};\n        introspectionResultData.__schema.types.forEach(function (type) {\n            if (type.kind === 'UNION' || type.kind === 'INTERFACE') {\n                typeMap[type.name] = type.possibleTypes.map(function (implementingType) { return implementingType.name; });\n            }\n        });\n        return typeMap;\n    };\n    return IntrospectionFragmentMatcher;\n}());\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar DepTrackingCache = (function () {\n    function DepTrackingCache(data) {\n        var _this = this;\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n        this.depend = wrap(function (dataId) { return _this.data[dataId]; }, {\n            disposable: true,\n            makeCacheKey: function (dataId) {\n                return dataId;\n            },\n        });\n    }\n    DepTrackingCache.prototype.toObject = function () {\n        return this.data;\n    };\n    DepTrackingCache.prototype.get = function (dataId) {\n        this.depend(dataId);\n        return this.data[dataId];\n    };\n    DepTrackingCache.prototype.set = function (dataId, value) {\n        var oldValue = this.data[dataId];\n        if (value !== oldValue) {\n            this.data[dataId] = value;\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.delete = function (dataId) {\n        if (hasOwn.call(this.data, dataId)) {\n            delete this.data[dataId];\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.clear = function () {\n        this.replace(null);\n    };\n    DepTrackingCache.prototype.replace = function (newData) {\n        var _this = this;\n        if (newData) {\n            Object.keys(newData).forEach(function (dataId) {\n                _this.set(dataId, newData[dataId]);\n            });\n            Object.keys(this.data).forEach(function (dataId) {\n                if (!hasOwn.call(newData, dataId)) {\n                    _this.delete(dataId);\n                }\n            });\n        }\n        else {\n            Object.keys(this.data).forEach(function (dataId) {\n                _this.delete(dataId);\n            });\n        }\n    };\n    return DepTrackingCache;\n}());\nfunction defaultNormalizedCacheFactory(seed) {\n    return new DepTrackingCache(seed);\n}\n\nvar StoreReader = (function () {\n    function StoreReader(_a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.cacheKeyRoot, cacheKeyRoot = _c === void 0 ? new KeyTrie(canUseWeakMap) : _c, _d = _b.freezeResults, freezeResults = _d === void 0 ? false : _d;\n        var _e = this, executeStoreQuery = _e.executeStoreQuery, executeSelectionSet = _e.executeSelectionSet, executeSubSelectedArray = _e.executeSubSelectedArray;\n        this.freezeResults = freezeResults;\n        this.executeStoreQuery = wrap(function (options) {\n            return executeStoreQuery.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, fragmentMatcher = _a.fragmentMatcher;\n                if (contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(contextValue.store, query, fragmentMatcher, JSON.stringify(variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSelectionSet = wrap(function (options) {\n            return executeSelectionSet.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, selectionSet, execContext.fragmentMatcher, JSON.stringify(execContext.variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            return executeSubSelectedArray.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, field, array, JSON.stringify(execContext.variableValues));\n                }\n            }\n        });\n    }\n    StoreReader.prototype.readQueryFromStore = function (options) {\n        return this.diffQueryAgainstStore(__assign(__assign({}, options), { returnPartialData: false })).result;\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, variables = _a.variables, previousResult = _a.previousResult, _b = _a.returnPartialData, returnPartialData = _b === void 0 ? true : _b, _c = _a.rootId, rootId = _c === void 0 ? 'ROOT_QUERY' : _c, fragmentMatcherFunction = _a.fragmentMatcherFunction, config = _a.config;\n        var queryDefinition = getQueryDefinition(query);\n        variables = assign({}, getDefaultValues(queryDefinition), variables);\n        var context = {\n            store: store,\n            dataIdFromObject: config && config.dataIdFromObject,\n            cacheRedirects: (config && config.cacheRedirects) || {},\n        };\n        var execResult = this.executeStoreQuery({\n            query: query,\n            rootValue: {\n                type: 'id',\n                id: rootId,\n                generated: true,\n                typename: 'Query',\n            },\n            contextValue: context,\n            variableValues: variables,\n            fragmentMatcher: fragmentMatcherFunction,\n        });\n        var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n        if (hasMissingFields && !returnPartialData) {\n            execResult.missing.forEach(function (info) {\n                if (info.tolerable)\n                    return;\n                throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Can't find field \" + info.fieldName + \" on object \" + JSON.stringify(info.object, null, 2) + \".\");\n            });\n        }\n        if (previousResult) {\n            if (isEqual(previousResult, execResult.result)) {\n                execResult.result = previousResult;\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !hasMissingFields,\n        };\n    };\n    StoreReader.prototype.executeStoreQuery = function (_a) {\n        var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, _b = _a.fragmentMatcher, fragmentMatcher = _b === void 0 ? defaultFragmentMatcher : _b;\n        var mainDefinition = getMainDefinition(query);\n        var fragments = getFragmentDefinitions(query);\n        var fragmentMap = createFragmentMap(fragments);\n        var execContext = {\n            query: query,\n            fragmentMap: fragmentMap,\n            contextValue: contextValue,\n            variableValues: variableValues,\n            fragmentMatcher: fragmentMatcher,\n        };\n        return this.executeSelectionSet({\n            selectionSet: mainDefinition.selectionSet,\n            rootValue: rootValue,\n            execContext: execContext,\n        });\n    };\n    StoreReader.prototype.executeSelectionSet = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n        var fragmentMap = execContext.fragmentMap, contextValue = execContext.contextValue, variables = execContext.variableValues;\n        var finalResult = { result: null };\n        var objectsToMerge = [];\n        var object = contextValue.store.get(rootValue.id);\n        var typename = (object && object.__typename) ||\n            (rootValue.id === 'ROOT_QUERY' && 'Query') ||\n            void 0;\n        function handleMissing(result) {\n            var _a;\n            if (result.missing) {\n                finalResult.missing = finalResult.missing || [];\n                (_a = finalResult.missing).push.apply(_a, result.missing);\n            }\n            return result.result;\n        }\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var fieldResult = handleMissing(_this.executeField(object, typename, selection, execContext));\n                if (typeof fieldResult !== 'undefined') {\n                    objectsToMerge.push((_a = {},\n                        _a[resultKeyNameFromField(selection)] = fieldResult,\n                        _a));\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = fragmentMap[selection.name.value];\n                    if (!fragment) {\n                        throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"No fragment named \" + selection.name.value);\n                    }\n                }\n                var typeCondition = fragment.typeCondition && fragment.typeCondition.name.value;\n                var match = !typeCondition ||\n                    execContext.fragmentMatcher(rootValue, typeCondition, contextValue);\n                if (match) {\n                    var fragmentExecResult = _this.executeSelectionSet({\n                        selectionSet: fragment.selectionSet,\n                        rootValue: rootValue,\n                        execContext: execContext,\n                    });\n                    if (match === 'heuristic' && fragmentExecResult.missing) {\n                        fragmentExecResult = __assign(__assign({}, fragmentExecResult), { missing: fragmentExecResult.missing.map(function (info) {\n                                return __assign(__assign({}, info), { tolerable: true });\n                            }) });\n                    }\n                    objectsToMerge.push(handleMissing(fragmentExecResult));\n                }\n            }\n        });\n        finalResult.result = mergeDeepArray(objectsToMerge);\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(finalResult.result);\n        }\n        return finalResult;\n    };\n    StoreReader.prototype.executeField = function (object, typename, field, execContext) {\n        var variables = execContext.variableValues, contextValue = execContext.contextValue;\n        var fieldName = field.name.value;\n        var args = argumentsObjectFromField(field, variables);\n        var info = {\n            resultKey: resultKeyNameFromField(field),\n            directives: getDirectiveInfoFromField(field, variables),\n        };\n        var readStoreResult = readStoreResolver(object, typename, fieldName, args, contextValue, info);\n        if (Array.isArray(readStoreResult.result)) {\n            return this.combineExecResults(readStoreResult, this.executeSubSelectedArray({\n                field: field,\n                array: readStoreResult.result,\n                execContext: execContext,\n            }));\n        }\n        if (!field.selectionSet) {\n            assertSelectionSetForIdValue(field, readStoreResult.result);\n            if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n                maybeDeepFreeze(readStoreResult);\n            }\n            return readStoreResult;\n        }\n        if (readStoreResult.result == null) {\n            return readStoreResult;\n        }\n        return this.combineExecResults(readStoreResult, this.executeSelectionSet({\n            selectionSet: field.selectionSet,\n            rootValue: readStoreResult.result,\n            execContext: execContext,\n        }));\n    };\n    StoreReader.prototype.combineExecResults = function () {\n        var execResults = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            execResults[_i] = arguments[_i];\n        }\n        var missing;\n        execResults.forEach(function (execResult) {\n            if (execResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, execResult.missing);\n            }\n        });\n        return {\n            result: execResults.pop().result,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.executeSubSelectedArray = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, execContext = _a.execContext;\n        var missing;\n        function handleMissing(childResult) {\n            if (childResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, childResult.missing);\n            }\n            return childResult.result;\n        }\n        array = array.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    execContext: execContext,\n                }));\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    rootValue: item,\n                    execContext: execContext,\n                }));\n            }\n            assertSelectionSetForIdValue(field, item);\n            return item;\n        });\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(array);\n        }\n        return { result: array, missing: missing };\n    };\n    return StoreReader;\n}());\nfunction assertSelectionSetForIdValue(field, value) {\n    if (!field.selectionSet && isIdValue(value)) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError(\"Missing selection set for object of type \" + value.typename + \" returned for query field \" + field.name.value);\n    }\n}\nfunction defaultFragmentMatcher() {\n    return true;\n}\nfunction assertIdValue(idValue) {\n    process.env.NODE_ENV === \"production\" ? invariant(isIdValue(idValue), 11) : invariant(isIdValue(idValue), \"Encountered a sub-selection on the query, but the store doesn't have an object reference. This should never happen during normal use unless you have custom code that is directly manipulating the store; please file an issue.\");\n}\nfunction readStoreResolver(object, typename, fieldName, args, context, _a) {\n    var resultKey = _a.resultKey, directives = _a.directives;\n    var storeKeyName = fieldName;\n    if (args || directives) {\n        storeKeyName = getStoreKeyName(storeKeyName, args, directives);\n    }\n    var fieldValue = void 0;\n    if (object) {\n        fieldValue = object[storeKeyName];\n        if (typeof fieldValue === 'undefined' &&\n            context.cacheRedirects &&\n            typeof typename === 'string') {\n            var type = context.cacheRedirects[typename];\n            if (type) {\n                var resolver = type[fieldName];\n                if (resolver) {\n                    fieldValue = resolver(object, args, {\n                        getCacheKey: function (storeObj) {\n                            var id = context.dataIdFromObject(storeObj);\n                            return id && toIdValue({\n                                id: id,\n                                typename: storeObj.__typename,\n                            });\n                        },\n                    });\n                }\n            }\n        }\n    }\n    if (typeof fieldValue === 'undefined') {\n        return {\n            result: fieldValue,\n            missing: [{\n                    object: object,\n                    fieldName: storeKeyName,\n                    tolerable: false,\n                }],\n        };\n    }\n    if (isJsonValue(fieldValue)) {\n        fieldValue = fieldValue.json;\n    }\n    return {\n        result: fieldValue,\n    };\n}\n\nvar ObjectCache = (function () {\n    function ObjectCache(data) {\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n    }\n    ObjectCache.prototype.toObject = function () {\n        return this.data;\n    };\n    ObjectCache.prototype.get = function (dataId) {\n        return this.data[dataId];\n    };\n    ObjectCache.prototype.set = function (dataId, value) {\n        this.data[dataId] = value;\n    };\n    ObjectCache.prototype.delete = function (dataId) {\n        this.data[dataId] = void 0;\n    };\n    ObjectCache.prototype.clear = function () {\n        this.data = Object.create(null);\n    };\n    ObjectCache.prototype.replace = function (newData) {\n        this.data = newData || Object.create(null);\n    };\n    return ObjectCache;\n}());\nfunction defaultNormalizedCacheFactory$1(seed) {\n    return new ObjectCache(seed);\n}\n\nvar WriteError = (function (_super) {\n    __extends(WriteError, _super);\n    function WriteError() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = 'WriteError';\n        return _this;\n    }\n    return WriteError;\n}(Error));\nfunction enhanceErrorWithDocument(error, document) {\n    var enhancedError = new WriteError(\"Error writing result to store for query:\\n \" + JSON.stringify(document));\n    enhancedError.message += '\\n' + error.message;\n    enhancedError.stack = error.stack;\n    return enhancedError;\n}\nvar StoreWriter = (function () {\n    function StoreWriter() {\n    }\n    StoreWriter.prototype.writeQueryToStore = function (_a) {\n        var query = _a.query, result = _a.result, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        return this.writeResultToStore({\n            dataId: 'ROOT_QUERY',\n            result: result,\n            document: query,\n            store: store,\n            variables: variables,\n            dataIdFromObject: dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n    };\n    StoreWriter.prototype.writeResultToStore = function (_a) {\n        var dataId = _a.dataId, result = _a.result, document = _a.document, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        var operationDefinition = getOperationDefinition(document);\n        try {\n            return this.writeSelectionSetToStore({\n                result: result,\n                dataId: dataId,\n                selectionSet: operationDefinition.selectionSet,\n                context: {\n                    store: store,\n                    processedData: {},\n                    variables: assign({}, getDefaultValues(operationDefinition), variables),\n                    dataIdFromObject: dataIdFromObject,\n                    fragmentMap: createFragmentMap(getFragmentDefinitions(document)),\n                    fragmentMatcherFunction: fragmentMatcherFunction,\n                },\n            });\n        }\n        catch (e) {\n            throw enhanceErrorWithDocument(e, document);\n        }\n    };\n    StoreWriter.prototype.writeSelectionSetToStore = function (_a) {\n        var _this = this;\n        var result = _a.result, dataId = _a.dataId, selectionSet = _a.selectionSet, context = _a.context;\n        var variables = context.variables, store = context.store, fragmentMap = context.fragmentMap;\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var resultFieldKey = resultKeyNameFromField(selection);\n                var value = result[resultFieldKey];\n                if (typeof value !== 'undefined') {\n                    _this.writeFieldToStore({\n                        dataId: dataId,\n                        value: value,\n                        field: selection,\n                        context: context,\n                    });\n                }\n                else {\n                    var isDefered = false;\n                    var isClient = false;\n                    if (selection.directives && selection.directives.length) {\n                        isDefered = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'defer'; });\n                        isClient = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'client'; });\n                    }\n                    if (!isDefered && !isClient && context.fragmentMatcherFunction) {\n                        process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing field \" + resultFieldKey + \" in \" + JSON.stringify(result, null, 2).substring(0, 100));\n                    }\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = (fragmentMap || {})[selection.name.value];\n                    process.env.NODE_ENV === \"production\" ? invariant(fragment, 3) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n                }\n                var matches = true;\n                if (context.fragmentMatcherFunction && fragment.typeCondition) {\n                    var id = dataId || 'self';\n                    var idValue = toIdValue({ id: id, typename: undefined });\n                    var fakeContext = {\n                        store: new ObjectCache((_a = {}, _a[id] = result, _a)),\n                        cacheRedirects: {},\n                    };\n                    var match = context.fragmentMatcherFunction(idValue, fragment.typeCondition.name.value, fakeContext);\n                    if (!isProduction() && match === 'heuristic') {\n                        process.env.NODE_ENV === \"production\" || invariant.error('WARNING: heuristic fragment matching going on!');\n                    }\n                    matches = !!match;\n                }\n                if (matches) {\n                    _this.writeSelectionSetToStore({\n                        result: result,\n                        selectionSet: fragment.selectionSet,\n                        dataId: dataId,\n                        context: context,\n                    });\n                }\n            }\n        });\n        return store;\n    };\n    StoreWriter.prototype.writeFieldToStore = function (_a) {\n        var _b;\n        var field = _a.field, value = _a.value, dataId = _a.dataId, context = _a.context;\n        var variables = context.variables, dataIdFromObject = context.dataIdFromObject, store = context.store;\n        var storeValue;\n        var storeObject;\n        var storeFieldName = storeKeyNameFromField(field, variables);\n        if (!field.selectionSet || value === null) {\n            storeValue =\n                value != null && typeof value === 'object'\n                    ?\n                        { type: 'json', json: value }\n                    :\n                        value;\n        }\n        else if (Array.isArray(value)) {\n            var generatedId = dataId + \".\" + storeFieldName;\n            storeValue = this.processArrayValue(value, generatedId, field.selectionSet, context);\n        }\n        else {\n            var valueDataId = dataId + \".\" + storeFieldName;\n            var generated = true;\n            if (!isGeneratedId(valueDataId)) {\n                valueDataId = '$' + valueDataId;\n            }\n            if (dataIdFromObject) {\n                var semanticId = dataIdFromObject(value);\n                process.env.NODE_ENV === \"production\" ? invariant(!semanticId || !isGeneratedId(semanticId), 4) : invariant(!semanticId || !isGeneratedId(semanticId), 'IDs returned by dataIdFromObject cannot begin with the \"$\" character.');\n                if (semanticId ||\n                    (typeof semanticId === 'number' && semanticId === 0)) {\n                    valueDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(valueDataId, field, context.processedData)) {\n                this.writeSelectionSetToStore({\n                    dataId: valueDataId,\n                    result: value,\n                    selectionSet: field.selectionSet,\n                    context: context,\n                });\n            }\n            var typename = value.__typename;\n            storeValue = toIdValue({ id: valueDataId, typename: typename }, generated);\n            storeObject = store.get(dataId);\n            var escapedId = storeObject && storeObject[storeFieldName];\n            if (escapedId !== storeValue && isIdValue(escapedId)) {\n                var hadTypename = escapedId.typename !== undefined;\n                var hasTypename = typename !== undefined;\n                var typenameChanged = hadTypename && hasTypename && escapedId.typename !== typename;\n                process.env.NODE_ENV === \"production\" ? invariant(!generated || escapedId.generated || typenameChanged, 5) : invariant(!generated || escapedId.generated || typenameChanged, \"Store error: the application attempted to write an object with no provided id but the store already contains an id of \" + escapedId.id + \" for this object. The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                process.env.NODE_ENV === \"production\" ? invariant(!hadTypename || hasTypename, 6) : invariant(!hadTypename || hasTypename, \"Store error: the application attempted to write an object with no provided typename but the store already contains an object with typename of \" + escapedId.typename + \" for the object of id \" + escapedId.id + \". The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                if (escapedId.generated) {\n                    if (typenameChanged) {\n                        if (!generated) {\n                            store.delete(escapedId.id);\n                        }\n                    }\n                    else {\n                        mergeWithGenerated(escapedId.id, storeValue.id, store);\n                    }\n                }\n            }\n        }\n        storeObject = store.get(dataId);\n        if (!storeObject || !isEqual(storeValue, storeObject[storeFieldName])) {\n            store.set(dataId, __assign(__assign({}, storeObject), (_b = {}, _b[storeFieldName] = storeValue, _b)));\n        }\n    };\n    StoreWriter.prototype.processArrayValue = function (value, generatedId, selectionSet, context) {\n        var _this = this;\n        return value.map(function (item, index) {\n            if (item === null) {\n                return null;\n            }\n            var itemDataId = generatedId + \".\" + index;\n            if (Array.isArray(item)) {\n                return _this.processArrayValue(item, itemDataId, selectionSet, context);\n            }\n            var generated = true;\n            if (context.dataIdFromObject) {\n                var semanticId = context.dataIdFromObject(item);\n                if (semanticId) {\n                    itemDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(itemDataId, selectionSet, context.processedData)) {\n                _this.writeSelectionSetToStore({\n                    dataId: itemDataId,\n                    result: item,\n                    selectionSet: selectionSet,\n                    context: context,\n                });\n            }\n            return toIdValue({ id: itemDataId, typename: item.__typename }, generated);\n        });\n    };\n    return StoreWriter;\n}());\nfunction isGeneratedId(id) {\n    return id[0] === '$';\n}\nfunction mergeWithGenerated(generatedKey, realKey, cache) {\n    if (generatedKey === realKey) {\n        return false;\n    }\n    var generated = cache.get(generatedKey);\n    var real = cache.get(realKey);\n    var madeChanges = false;\n    Object.keys(generated).forEach(function (key) {\n        var value = generated[key];\n        var realValue = real[key];\n        if (isIdValue(value) &&\n            isGeneratedId(value.id) &&\n            isIdValue(realValue) &&\n            !isEqual(value, realValue) &&\n            mergeWithGenerated(value.id, realValue.id, cache)) {\n            madeChanges = true;\n        }\n    });\n    cache.delete(generatedKey);\n    var newRealValue = __assign(__assign({}, generated), real);\n    if (isEqual(newRealValue, real)) {\n        return madeChanges;\n    }\n    cache.set(realKey, newRealValue);\n    return true;\n}\nfunction isDataProcessed(dataId, field, processedData) {\n    if (!processedData) {\n        return false;\n    }\n    if (processedData[dataId]) {\n        if (processedData[dataId].indexOf(field) >= 0) {\n            return true;\n        }\n        else {\n            processedData[dataId].push(field);\n        }\n    }\n    else {\n        processedData[dataId] = [field];\n    }\n    return false;\n}\n\nvar defaultConfig = {\n    fragmentMatcher: new HeuristicFragmentMatcher(),\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    freezeResults: false,\n};\nfunction defaultDataIdFromObject(result) {\n    if (result.__typename) {\n        if (result.id !== undefined) {\n            return result.__typename + \":\" + result.id;\n        }\n        if (result._id !== undefined) {\n            return result.__typename + \":\" + result._id;\n        }\n    }\n    return null;\n}\nvar hasOwn$1 = Object.prototype.hasOwnProperty;\nvar OptimisticCacheLayer = (function (_super) {\n    __extends(OptimisticCacheLayer, _super);\n    function OptimisticCacheLayer(optimisticId, parent, transaction) {\n        var _this = _super.call(this, Object.create(null)) || this;\n        _this.optimisticId = optimisticId;\n        _this.parent = parent;\n        _this.transaction = transaction;\n        return _this;\n    }\n    OptimisticCacheLayer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    OptimisticCacheLayer.prototype.get = function (dataId) {\n        return hasOwn$1.call(this.data, dataId)\n            ? this.data[dataId]\n            : this.parent.get(dataId);\n    };\n    return OptimisticCacheLayer;\n}(ObjectCache));\nvar InMemoryCache = (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.typenameDocumentCache = new Map();\n        _this.cacheKeyRoot = new KeyTrie(canUseWeakMap);\n        _this.silenceBroadcast = false;\n        _this.config = __assign(__assign({}, defaultConfig), config);\n        if (_this.config.customResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.customResolvers;\n        }\n        if (_this.config.cacheResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.cacheResolvers;\n        }\n        _this.addTypename = !!_this.config.addTypename;\n        _this.data = _this.config.resultCaching\n            ? new DepTrackingCache()\n            : new ObjectCache();\n        _this.optimisticData = _this.data;\n        _this.storeWriter = new StoreWriter();\n        _this.storeReader = new StoreReader({\n            cacheKeyRoot: _this.cacheKeyRoot,\n            freezeResults: config.freezeResults,\n        });\n        var cache = _this;\n        var maybeBroadcastWatch = cache.maybeBroadcastWatch;\n        _this.maybeBroadcastWatch = wrap(function (c) {\n            return maybeBroadcastWatch.call(_this, c);\n        }, {\n            makeCacheKey: function (c) {\n                if (c.optimistic) {\n                    return;\n                }\n                if (c.previousResult) {\n                    return;\n                }\n                if (cache.data instanceof DepTrackingCache) {\n                    return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));\n                }\n            }\n        });\n        return _this;\n    }\n    InMemoryCache.prototype.restore = function (data) {\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).toObject();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        if (typeof options.rootId === 'string' &&\n            typeof this.data.get(options.rootId) === 'undefined') {\n            return null;\n        }\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.readQueryFromStore({\n            store: options.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(options.query),\n            variables: options.variables,\n            rootId: options.rootId,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            previousResult: options.previousResult,\n            config: this.config,\n        }) || null;\n    };\n    InMemoryCache.prototype.write = function (write) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        this.storeWriter.writeResultToStore({\n            dataId: write.dataId,\n            result: write.result,\n            variables: write.variables,\n            document: this.transformDocument(write.query),\n            store: this.data,\n            dataIdFromObject: this.config.dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.diff = function (query) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.diffQueryAgainstStore({\n            store: query.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(query.query),\n            variables: query.variables,\n            returnPartialData: query.returnPartialData,\n            previousResult: query.previousResult,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            config: this.config,\n        });\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        this.watches.add(watch);\n        return function () {\n            _this.watches.delete(watch);\n        };\n    };\n    InMemoryCache.prototype.evict = function (query) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(7) : new InvariantError(\"eviction is not implemented on InMemory Cache\");\n    };\n    InMemoryCache.prototype.reset = function () {\n        this.data.clear();\n        this.broadcastWatches();\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var toReapply = [];\n        var removedCount = 0;\n        var layer = this.optimisticData;\n        while (layer instanceof OptimisticCacheLayer) {\n            if (layer.optimisticId === idToRemove) {\n                ++removedCount;\n            }\n            else {\n                toReapply.push(layer);\n            }\n            layer = layer.parent;\n        }\n        if (removedCount > 0) {\n            this.optimisticData = layer;\n            while (toReapply.length > 0) {\n                var layer_1 = toReapply.pop();\n                this.performTransaction(layer_1.transaction, layer_1.optimisticId);\n            }\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n        var _a = this, data = _a.data, silenceBroadcast = _a.silenceBroadcast;\n        this.silenceBroadcast = true;\n        if (typeof optimisticId === 'string') {\n            this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);\n        }\n        try {\n            transaction(this);\n        }\n        finally {\n            this.silenceBroadcast = silenceBroadcast;\n            this.data = data;\n        }\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {\n        return this.performTransaction(transaction, id);\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        if (this.addTypename) {\n            var result = this.typenameDocumentCache.get(document);\n            if (!result) {\n                result = addTypenameToDocument(document);\n                this.typenameDocumentCache.set(document, result);\n                this.typenameDocumentCache.set(result, result);\n            }\n            return result;\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function () {\n        var _this = this;\n        if (!this.silenceBroadcast) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c); });\n        }\n    };\n    InMemoryCache.prototype.maybeBroadcastWatch = function (c) {\n        c.callback(this.diff({\n            query: c.query,\n            variables: c.variables,\n            previousResult: c.previousResult && c.previousResult(),\n            optimistic: c.optimistic,\n        }));\n    };\n    return InMemoryCache;\n}(ApolloCache));\n\nexport { HeuristicFragmentMatcher, InMemoryCache, IntrospectionFragmentMatcher, ObjectCache, StoreReader, StoreWriter, WriteError, assertIdValue, defaultDataIdFromObject, defaultNormalizedCacheFactory$1 as defaultNormalizedCacheFactory, enhanceErrorWithDocument };\n//# sourceMappingURL=bundle.esm.js.map\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { visit } from 'graphql/language/visitor';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { __assign, __spreadArrays } from 'tslib';\nimport stringify from 'fast-json-stable-stringify';\nexport { equal as isEqual } from '@wry/equality';\n\nfunction isScalarValue(value) {\n    return ['StringValue', 'BooleanValue', 'EnumValue'].indexOf(value.kind) > -1;\n}\nfunction isNumberValue(value) {\n    return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\nfunction isStringValue(value) {\n    return value.kind === 'StringValue';\n}\nfunction isBooleanValue(value) {\n    return value.kind === 'BooleanValue';\n}\nfunction isIntValue(value) {\n    return value.kind === 'IntValue';\n}\nfunction isFloatValue(value) {\n    return value.kind === 'FloatValue';\n}\nfunction isVariable(value) {\n    return value.kind === 'Variable';\n}\nfunction isObjectValue(value) {\n    return value.kind === 'ObjectValue';\n}\nfunction isListValue(value) {\n    return value.kind === 'ListValue';\n}\nfunction isEnumValue(value) {\n    return value.kind === 'EnumValue';\n}\nfunction isNullValue(value) {\n    return value.kind === 'NullValue';\n}\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(17) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.');\n    }\n}\nfunction storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    'connection',\n    'include',\n    'skip',\n    'client',\n    'rest',\n    'export',\n];\nfunction getStoreKeyName(fieldName, args, directives) {\n    if (directives &&\n        directives['connection'] &&\n        directives['connection']['key']) {\n        if (directives['connection']['filter'] &&\n            directives['connection']['filter'].length > 0) {\n            var filterKeys = directives['connection']['filter']\n                ? directives['connection']['filter']\n                : [];\n            filterKeys.sort();\n            var queryArgs_1 = args;\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = queryArgs_1[key];\n            });\n            return directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n        }\n        else {\n            return directives['connection']['key'];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\" + stringifiedArgs + \")\";\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n            }\n            else {\n                completeFieldName += \"@\" + key;\n            }\n        });\n    }\n    return completeFieldName;\n}\nfunction argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nfunction resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nfunction isField(selection) {\n    return selection.kind === 'Field';\n}\nfunction isInlineFragment(selection) {\n    return selection.kind === 'InlineFragment';\n}\nfunction isIdValue(idObject) {\n    return idObject &&\n        idObject.type === 'id' &&\n        typeof idObject.generated === 'boolean';\n}\nfunction toIdValue(idConfig, generated) {\n    if (generated === void 0) { generated = false; }\n    return __assign({ type: 'id', generated: generated }, (typeof idConfig === 'string'\n        ? { id: idConfig, typename: undefined }\n        : idConfig));\n}\nfunction isJsonValue(jsonObject) {\n    return (jsonObject != null &&\n        typeof jsonObject === 'object' &&\n        jsonObject.type === 'json');\n}\nfunction defaultValueFromVariable(node) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(18) : new InvariantError(\"Variable nodes are not supported by valueFromNode\");\n}\nfunction valueFromNode(node, onVariable) {\n    if (onVariable === void 0) { onVariable = defaultValueFromVariable; }\n    switch (node.kind) {\n        case 'Variable':\n            return onVariable(node);\n        case 'NullValue':\n            return null;\n        case 'IntValue':\n            return parseInt(node.value, 10);\n        case 'FloatValue':\n            return parseFloat(node.value);\n        case 'ListValue':\n            return node.values.map(function (v) { return valueFromNode(v, onVariable); });\n        case 'ObjectValue': {\n            var value = {};\n            for (var _i = 0, _a = node.fields; _i < _a.length; _i++) {\n                var field = _a[_i];\n                value[field.name.value] = valueFromNode(field.value, onVariable);\n            }\n            return value;\n        }\n        default:\n            return node.value;\n    }\n}\n\nfunction getDirectiveInfoFromField(field, variables) {\n    if (field.directives && field.directives.length) {\n        var directiveObj_1 = {};\n        field.directives.forEach(function (directive) {\n            directiveObj_1[directive.name.value] = argumentsObjectFromField(directive, variables);\n        });\n        return directiveObj_1;\n    }\n    return null;\n}\nfunction shouldInclude(selection, variables) {\n    if (variables === void 0) { variables = {}; }\n    return getInclusionDirectives(selection.directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === 'Variable') {\n            evaledValue = variables[ifArgument.value.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 13) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\nfunction getDirectiveNames(doc) {\n    var names = [];\n    visit(doc, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nfunction hasDirectives(names, doc) {\n    return getDirectiveNames(doc).some(function (name) { return names.indexOf(name) > -1; });\n}\nfunction hasClientExports(document) {\n    return (document &&\n        hasDirectives(['client'], document) &&\n        hasDirectives(['export'], document));\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\nfunction getInclusionDirectives(directives) {\n    return directives ? directives.filter(isInclusionDirective).map(function (directive) {\n        var directiveArguments = directive.arguments;\n        var directiveName = directive.name.value;\n        process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 14) : invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\" + directiveName + \" directive.\");\n        var ifArgument = directiveArguments[0];\n        process.env.NODE_ENV === \"production\" ? invariant(ifArgument.name && ifArgument.name.value === 'if', 15) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n        var ifValue = ifArgument.value;\n        process.env.NODE_ENV === \"production\" ? invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 16) : invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n        return { directive: directive, ifArgument: ifArgument };\n    }) : [];\n}\n\nfunction getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(11) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 12) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArrays([\n            {\n                kind: 'OperationDefinition',\n                operation: 'query',\n                selectionSet: {\n                    kind: 'SelectionSet',\n                    selections: [\n                        {\n                            kind: 'FragmentSpread',\n                            name: {\n                                kind: 'Name',\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions) });\n    return query;\n}\n\nfunction assign(target) {\n    var sources = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        sources[_i - 1] = arguments[_i];\n    }\n    sources.forEach(function (source) {\n        if (typeof source === 'undefined' || source === null) {\n            return;\n        }\n        Object.keys(source).forEach(function (key) {\n            target[key] = source[key];\n        });\n    });\n    return target;\n}\n\nfunction getMutationDefinition(doc) {\n    checkDocument(doc);\n    var mutationDef = doc.definitions.filter(function (definition) {\n        return definition.kind === 'OperationDefinition' &&\n            definition.operation === 'mutation';\n    })[0];\n    process.env.NODE_ENV === \"production\" ? invariant(mutationDef, 1) : invariant(mutationDef, 'Must contain a mutation definition.');\n    return mutationDef;\n}\nfunction checkDocument(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 2) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(3) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n        }\n        return definition;\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 4) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\n    return doc;\n}\nfunction getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];\n}\nfunction getOperationDefinitionOrDie(document) {\n    var def = getOperationDefinition(document);\n    process.env.NODE_ENV === \"production\" ? invariant(def, 5) : invariant(def, \"GraphQL document is missing an operation\");\n    return def;\n}\nfunction getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === 'OperationDefinition' && definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\nfunction getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });\n}\nfunction getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 6) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n    return queryDef;\n}\nfunction getFragmentDefinition(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 7) : invariant(doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    process.env.NODE_ENV === \"production\" ? invariant(doc.definitions.length <= 1, 8) : invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.');\n    var fragmentDef = doc.definitions[0];\n    process.env.NODE_ENV === \"production\" ? invariant(fragmentDef.kind === 'FragmentDefinition', 9) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\n    return fragmentDef;\n}\nfunction getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === 'OperationDefinition') {\n            var operation = definition.operation;\n            if (operation === 'query' ||\n                operation === 'mutation' ||\n                operation === 'subscription') {\n                return definition;\n            }\n        }\n        if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\n}\nfunction createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nfunction getDefaultValues(definition) {\n    if (definition &&\n        definition.variableDefinitions &&\n        definition.variableDefinitions.length) {\n        var defaultValues = definition.variableDefinitions\n            .filter(function (_a) {\n            var defaultValue = _a.defaultValue;\n            return defaultValue;\n        })\n            .map(function (_a) {\n            var variable = _a.variable, defaultValue = _a.defaultValue;\n            var defaultValueObj = {};\n            valueToObjectRepresentation(defaultValueObj, variable.name, defaultValue);\n            return defaultValueObj;\n        });\n        return assign.apply(void 0, __spreadArrays([{}], defaultValues));\n    }\n    return {};\n}\nfunction variablesInOperation(operation) {\n    var names = new Set();\n    if (operation.variableDefinitions) {\n        for (var _i = 0, _a = operation.variableDefinitions; _i < _a.length; _i++) {\n            var definition = _a[_i];\n            names.add(definition.variable.name.value);\n        }\n    }\n    return names;\n}\n\nfunction filterInPlace(array, test, context) {\n    var target = 0;\n    array.forEach(function (elem, i) {\n        if (test.call(this, elem, i, array)) {\n            array[target++] = elem;\n        }\n    }, context);\n    array.length = target;\n    return array;\n}\n\nvar TYPENAME_FIELD = {\n    kind: 'Field',\n    name: {\n        kind: 'Name',\n        value: '__typename',\n    },\n};\nfunction isEmpty(op, fragments) {\n    return op.selectionSet.selections.every(function (selection) {\n        return selection.kind === 'FragmentSpread' &&\n            isEmpty(fragments[selection.name.value], fragments);\n    });\n}\nfunction nullIfDocIsEmpty(doc) {\n    return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))\n        ? null\n        : doc;\n}\nfunction getDirectiveMatcher(directives) {\n    return function directiveMatcher(directive) {\n        return directives.some(function (dir) {\n            return (dir.name && dir.name === directive.name.value) ||\n                (dir.test && dir.test(directive));\n        });\n    };\n}\nfunction removeDirectivesFromDocument(directives, doc) {\n    var variablesInUse = Object.create(null);\n    var variablesToRemove = [];\n    var fragmentSpreadsInUse = Object.create(null);\n    var fragmentSpreadsToRemove = [];\n    var modifiedDoc = nullIfDocIsEmpty(visit(doc, {\n        Variable: {\n            enter: function (node, _key, parent) {\n                if (parent.kind !== 'VariableDefinition') {\n                    variablesInUse[node.name.value] = true;\n                }\n            },\n        },\n        Field: {\n            enter: function (node) {\n                if (directives && node.directives) {\n                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });\n                    if (shouldRemoveField &&\n                        node.directives &&\n                        node.directives.some(getDirectiveMatcher(directives))) {\n                        if (node.arguments) {\n                            node.arguments.forEach(function (arg) {\n                                if (arg.value.kind === 'Variable') {\n                                    variablesToRemove.push({\n                                        name: arg.value.name.value,\n                                    });\n                                }\n                            });\n                        }\n                        if (node.selectionSet) {\n                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                                fragmentSpreadsToRemove.push({\n                                    name: frag.name.value,\n                                });\n                            });\n                        }\n                        return null;\n                    }\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node) {\n                fragmentSpreadsInUse[node.name.value] = true;\n            },\n        },\n        Directive: {\n            enter: function (node) {\n                if (getDirectiveMatcher(directives)(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n    if (modifiedDoc &&\n        filterInPlace(variablesToRemove, function (v) { return !variablesInUse[v.name]; }).length) {\n        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n    }\n    if (modifiedDoc &&\n        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !fragmentSpreadsInUse[fs.name]; })\n            .length) {\n        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n    }\n    return modifiedDoc;\n}\nfunction addTypenameToDocument(doc) {\n    return visit(checkDocument(doc), {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind === 'OperationDefinition') {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === '__typename' ||\n                            selection.name.value.lastIndexOf('__', 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === 'export'; })) {\n                    return;\n                }\n                return __assign(__assign({}, node), { selections: __spreadArrays(selections, [TYPENAME_FIELD]) });\n            },\n        },\n    });\n}\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === 'connection';\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' +\n                    'You may want to use the key parameter to specify a store key.');\n            }\n        }\n        return willRemove;\n    },\n};\nfunction removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    var parentPath;\n    return nullIfDocIsEmpty(visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, _parent, path) {\n                var currentPath = path.join('-');\n                if (!parentPath ||\n                    currentPath === parentPath ||\n                    !currentPath.startsWith(parentPath)) {\n                    if (node.selections) {\n                        var selectionsWithDirectives = node.selections.filter(function (selection) { return hasDirectivesInSelection(directives, selection); });\n                        if (hasDirectivesInSelectionSet(directives, node, false)) {\n                            parentPath = currentPath;\n                        }\n                        return __assign(__assign({}, node), { selections: selectionsWithDirectives });\n                    }\n                    else {\n                        return null;\n                    }\n                }\n            },\n        },\n    }));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === 'Variable' &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nfunction removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                    }) });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    node.arguments.forEach(function (arg) {\n                        if (argMatcher(arg)) {\n                            argMatchCount_1 += 1;\n                        }\n                    });\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nfunction removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n    var allFragments = [];\n    selectionSet.selections.forEach(function (selection) {\n        if ((isField(selection) || isInlineFragment(selection)) &&\n            selection.selectionSet) {\n            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });\n        }\n        else if (selection.kind === 'FragmentSpread') {\n            allFragments.push(selection);\n        }\n    });\n    return allFragments;\n}\nfunction buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === 'query') {\n        return document;\n    }\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: 'query' });\n            },\n        },\n    });\n    return modifiedDoc;\n}\nfunction removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === 'client'; },\n            remove: true,\n        },\n    ], document);\n    if (modifiedDoc) {\n        modifiedDoc = visit(modifiedDoc, {\n            FragmentDefinition: {\n                enter: function (node) {\n                    if (node.selectionSet) {\n                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n                            return isField(selection) && selection.name.value === '__typename';\n                        });\n                        if (isTypenameOnly) {\n                            return null;\n                        }\n                    }\n                },\n            },\n        });\n    }\n    return modifiedDoc;\n}\n\nvar canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&\n    navigator.product === 'ReactNative');\n\nvar toString = Object.prototype.toString;\nfunction cloneDeep(value) {\n    return cloneDeepHelper(value, new Map());\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n\nfunction getEnv() {\n    if (typeof process !== 'undefined' && process.env.NODE_ENV) {\n        return process.env.NODE_ENV;\n    }\n    return 'development';\n}\nfunction isEnv(env) {\n    return getEnv() === env;\n}\nfunction isProduction() {\n    return isEnv('production') === true;\n}\nfunction isDevelopment() {\n    return isEnv('development') === true;\n}\nfunction isTest() {\n    return isEnv('test') === true;\n}\n\nfunction tryFunctionOrLogError(f) {\n    try {\n        return f();\n    }\n    catch (e) {\n        if (console.error) {\n            console.error(e);\n        }\n    }\n}\nfunction graphQLResultHasError(result) {\n    return result.errors && result.errors.length;\n}\n\nfunction deepFreeze(o) {\n    Object.freeze(o);\n    Object.getOwnPropertyNames(o).forEach(function (prop) {\n        if (o[prop] !== null &&\n            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n            !Object.isFrozen(o[prop])) {\n            deepFreeze(o[prop]);\n        }\n    });\n    return o;\n}\nfunction maybeDeepFreeze(obj) {\n    if (isDevelopment() || isTest()) {\n        var symbolIsPolyfilled = typeof Symbol === 'function' && typeof Symbol('') === 'string';\n        if (!symbolIsPolyfilled) {\n            return deepFreeze(obj);\n        }\n    }\n    return obj;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nfunction mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var pastCopies = [];\n        target = shallowCopyForMerge(target, pastCopies);\n        for (var i = 1; i < count; ++i) {\n            target = mergeHelper(target, sources[i], pastCopies);\n        }\n    }\n    return target;\n}\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\nfunction mergeHelper(target, source, pastCopies) {\n    if (isObject(source) && isObject(target)) {\n        if (Object.isExtensible && !Object.isExtensible(target)) {\n            target = shallowCopyForMerge(target, pastCopies);\n        }\n        Object.keys(source).forEach(function (sourceKey) {\n            var sourceValue = source[sourceKey];\n            if (hasOwnProperty.call(target, sourceKey)) {\n                var targetValue = target[sourceKey];\n                if (sourceValue !== targetValue) {\n                    target[sourceKey] = mergeHelper(shallowCopyForMerge(targetValue, pastCopies), sourceValue, pastCopies);\n                }\n            }\n            else {\n                target[sourceKey] = sourceValue;\n            }\n        });\n        return target;\n    }\n    return source;\n}\nfunction shallowCopyForMerge(value, pastCopies) {\n    if (value !== null &&\n        typeof value === 'object' &&\n        pastCopies.indexOf(value) < 0) {\n        if (Array.isArray(value)) {\n            value = value.slice(0);\n        }\n        else {\n            value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n        }\n        pastCopies.push(value);\n    }\n    return value;\n}\n\nvar haveWarned = Object.create({});\nfunction warnOnceInDevelopment(msg, type) {\n    if (type === void 0) { type = 'warn'; }\n    if (!isProduction() && !haveWarned[msg]) {\n        if (!isTest()) {\n            haveWarned[msg] = true;\n        }\n        if (type === 'error') {\n            console.error(msg);\n        }\n        else {\n            console.warn(msg);\n        }\n    }\n}\n\nfunction stripSymbols(data) {\n    return JSON.parse(JSON.stringify(data));\n}\n\nexport { addTypenameToDocument, argumentsObjectFromField, assign, buildQueryFromSelectionSet, canUseWeakMap, checkDocument, cloneDeep, createFragmentMap, getDefaultValues, getDirectiveInfoFromField, getDirectiveNames, getDirectivesFromDocument, getEnv, getFragmentDefinition, getFragmentDefinitions, getFragmentQueryDocument, getInclusionDirectives, getMainDefinition, getMutationDefinition, getOperationDefinition, getOperationDefinitionOrDie, getOperationName, getQueryDefinition, getStoreKeyName, graphQLResultHasError, hasClientExports, hasDirectives, isDevelopment, isEnv, isField, isIdValue, isInlineFragment, isJsonValue, isNumberValue, isProduction, isScalarValue, isTest, maybeDeepFreeze, mergeDeep, mergeDeepArray, removeArgumentsFromDocument, removeClientSetsFromDocument, removeConnectionDirectiveFromDocument, removeDirectivesFromDocument, removeFragmentSpreadFromDocument, resultKeyNameFromField, shouldInclude, storeKeyNameFromField, stripSymbols, toIdValue, tryFunctionOrLogError, valueFromNode, valueToObjectRepresentation, variablesInOperation, warnOnceInDevelopment };\n//# sourceMappingURL=bundle.esm.js.map\n","'use strict';\n\nmodule.exports = function (data, opts) {\n    if (!opts) opts = {};\n    if (typeof opts === 'function') opts = { cmp: opts };\n    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;\n\n    var cmp = opts.cmp && (function (f) {\n        return function (node) {\n            return function (a, b) {\n                var aobj = { key: a, value: node[a] };\n                var bobj = { key: b, value: node[b] };\n                return f(aobj, bobj);\n            };\n        };\n    })(opts.cmp);\n\n    var seen = [];\n    return (function stringify (node) {\n        if (node && node.toJSON && typeof node.toJSON === 'function') {\n            node = node.toJSON();\n        }\n\n        if (node === undefined) return;\n        if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';\n        if (typeof node !== 'object') return JSON.stringify(node);\n\n        var i, out;\n        if (Array.isArray(node)) {\n            out = '[';\n            for (i = 0; i < node.length; i++) {\n                if (i) out += ',';\n                out += stringify(node[i]) || 'null';\n            }\n            return out + ']';\n        }\n\n        if (node === null) return 'null';\n\n        if (seen.indexOf(node) !== -1) {\n            if (cycles) return JSON.stringify('__cycle__');\n            throw new TypeError('Converting circular structure to JSON');\n        }\n\n        var seenIndex = seen.push(node) - 1;\n        var keys = Object.keys(node).sort(cmp && cmp(node));\n        out = '';\n        for (i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            var value = stringify(node[key]);\n\n            if (!value) continue;\n            if (out) out += ',';\n            out += JSON.stringify(key) + ':' + value;\n        }\n        seen.splice(seenIndex, 1);\n        return '{' + out + '}';\n    })(data);\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = defineInspect;\n\nvar _invariant = _interopRequireDefault(require(\"./invariant.js\"));\n\nvar _nodejsCustomInspectSymbol = _interopRequireDefault(require(\"./nodejsCustomInspectSymbol.js\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`\n */\nfunction defineInspect(classObject) {\n  var fn = classObject.prototype.toJSON;\n  typeof fn === 'function' || (0, _invariant.default)(0);\n  classObject.prototype.inspect = fn; // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2317')\n\n  if (_nodejsCustomInspectSymbol.default) {\n    classObject.prototype[_nodejsCustomInspectSymbol.default] = fn;\n  }\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = inspect;\n\nvar _nodejsCustomInspectSymbol = _interopRequireDefault(require(\"./nodejsCustomInspectSymbol.js\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar MAX_ARRAY_LENGTH = 10;\nvar MAX_RECURSIVE_DEPTH = 2;\n/**\n * Used to print values in error messages.\n */\n\nfunction inspect(value) {\n  return formatValue(value, []);\n}\n\nfunction formatValue(value, seenValues) {\n  switch (_typeof(value)) {\n    case 'string':\n      return JSON.stringify(value);\n\n    case 'function':\n      return value.name ? \"[function \".concat(value.name, \"]\") : '[function]';\n\n    case 'object':\n      if (value === null) {\n        return 'null';\n      }\n\n      return formatObjectValue(value, seenValues);\n\n    default:\n      return String(value);\n  }\n}\n\nfunction formatObjectValue(value, previouslySeenValues) {\n  if (previouslySeenValues.indexOf(value) !== -1) {\n    return '[Circular]';\n  }\n\n  var seenValues = [].concat(previouslySeenValues, [value]);\n  var customInspectFn = getCustomFn(value);\n\n  if (customInspectFn !== undefined) {\n    var customValue = customInspectFn.call(value); // check for infinite recursion\n\n    if (customValue !== value) {\n      return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);\n    }\n  } else if (Array.isArray(value)) {\n    return formatArray(value, seenValues);\n  }\n\n  return formatObject(value, seenValues);\n}\n\nfunction formatObject(object, seenValues) {\n  var keys = Object.keys(object);\n\n  if (keys.length === 0) {\n    return '{}';\n  }\n\n  if (seenValues.length > MAX_RECURSIVE_DEPTH) {\n    return '[' + getObjectTag(object) + ']';\n  }\n\n  var properties = keys.map(function (key) {\n    var value = formatValue(object[key], seenValues);\n    return key + ': ' + value;\n  });\n  return '{ ' + properties.join(', ') + ' }';\n}\n\nfunction formatArray(array, seenValues) {\n  if (array.length === 0) {\n    return '[]';\n  }\n\n  if (seenValues.length > MAX_RECURSIVE_DEPTH) {\n    return '[Array]';\n  }\n\n  var len = Math.min(MAX_ARRAY_LENGTH, array.length);\n  var remaining = array.length - len;\n  var items = [];\n\n  for (var i = 0; i < len; ++i) {\n    items.push(formatValue(array[i], seenValues));\n  }\n\n  if (remaining === 1) {\n    items.push('... 1 more item');\n  } else if (remaining > 1) {\n    items.push(\"... \".concat(remaining, \" more items\"));\n  }\n\n  return '[' + items.join(', ') + ']';\n}\n\nfunction getCustomFn(object) {\n  var customInspectFn = object[String(_nodejsCustomInspectSymbol.default)];\n\n  if (typeof customInspectFn === 'function') {\n    return customInspectFn;\n  }\n\n  if (typeof object.inspect === 'function') {\n    return object.inspect;\n  }\n}\n\nfunction getObjectTag(object) {\n  var tag = Object.prototype.toString.call(object).replace(/^\\[object /, '').replace(/]$/, '');\n\n  if (tag === 'Object' && typeof object.constructor === 'function') {\n    var name = object.constructor.name;\n\n    if (typeof name === 'string' && name !== '') {\n      return name;\n    }\n  }\n\n  return tag;\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = invariant;\n\nfunction invariant(condition, message) {\n  var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')\n\n  if (!booleanCondition) {\n    throw new Error(message != null ? message : 'Unexpected invariant triggered.');\n  }\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\nvar nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;\nvar _default = nodejsCustomInspectSymbol;\nexports.default = _default;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.isNode = isNode;\nexports.Token = exports.Location = void 0;\n\nvar _defineInspect = _interopRequireDefault(require(\"../jsutils/defineInspect.js\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Contains a range of UTF-8 character offsets and token references that\n * identify the region of the source from which the AST derived.\n */\nvar Location = /*#__PURE__*/function () {\n  /**\n   * The character offset at which this Node begins.\n   */\n\n  /**\n   * The character offset at which this Node ends.\n   */\n\n  /**\n   * The Token at which this Node begins.\n   */\n\n  /**\n   * The Token at which this Node ends.\n   */\n\n  /**\n   * The Source document the AST represents.\n   */\n  function Location(startToken, endToken, source) {\n    this.start = startToken.start;\n    this.end = endToken.end;\n    this.startToken = startToken;\n    this.endToken = endToken;\n    this.source = source;\n  }\n\n  var _proto = Location.prototype;\n\n  _proto.toJSON = function toJSON() {\n    return {\n      start: this.start,\n      end: this.end\n    };\n  };\n\n  return Location;\n}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.\n\n\nexports.Location = Location;\n(0, _defineInspect.default)(Location);\n/**\n * Represents a range of characters represented by a lexical token\n * within a Source.\n */\n\nvar Token = /*#__PURE__*/function () {\n  /**\n   * The kind of Token.\n   */\n\n  /**\n   * The character offset at which this Node begins.\n   */\n\n  /**\n   * The character offset at which this Node ends.\n   */\n\n  /**\n   * The 1-indexed line number on which this Token appears.\n   */\n\n  /**\n   * The 1-indexed column number at which this Token begins.\n   */\n\n  /**\n   * For non-punctuation tokens, represents the interpreted value of the token.\n   */\n\n  /**\n   * Tokens exist as nodes in a double-linked-list amongst all tokens\n   * including ignored tokens. <SOF> is always the first node and <EOF>\n   * the last.\n   */\n  function Token(kind, start, end, line, column, prev, value) {\n    this.kind = kind;\n    this.start = start;\n    this.end = end;\n    this.line = line;\n    this.column = column;\n    this.value = value;\n    this.prev = prev;\n    this.next = null;\n  }\n\n  var _proto2 = Token.prototype;\n\n  _proto2.toJSON = function toJSON() {\n    return {\n      kind: this.kind,\n      value: this.value,\n      line: this.line,\n      column: this.column\n    };\n  };\n\n  return Token;\n}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.\n\n\nexports.Token = Token;\n(0, _defineInspect.default)(Token);\n/**\n * @internal\n */\n\nfunction isNode(maybeNode) {\n  return maybeNode != null && typeof maybeNode.kind === 'string';\n}\n/**\n * The list of all possible AST node types.\n */\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.visit = visit;\nexports.visitInParallel = visitInParallel;\nexports.getVisitFn = getVisitFn;\nexports.BREAK = exports.QueryDocumentKeys = void 0;\n\nvar _inspect = _interopRequireDefault(require(\"../jsutils/inspect.js\"));\n\nvar _ast = require(\"./ast.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar QueryDocumentKeys = {\n  Name: [],\n  Document: ['definitions'],\n  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],\n  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],\n  Variable: ['name'],\n  SelectionSet: ['selections'],\n  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],\n  Argument: ['name', 'value'],\n  FragmentSpread: ['name', 'directives'],\n  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],\n  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed\n  // or removed in the future.\n  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],\n  IntValue: [],\n  FloatValue: [],\n  StringValue: [],\n  BooleanValue: [],\n  NullValue: [],\n  EnumValue: [],\n  ListValue: ['values'],\n  ObjectValue: ['fields'],\n  ObjectField: ['name', 'value'],\n  Directive: ['name', 'arguments'],\n  NamedType: ['name'],\n  ListType: ['type'],\n  NonNullType: ['type'],\n  SchemaDefinition: ['description', 'directives', 'operationTypes'],\n  OperationTypeDefinition: ['type'],\n  ScalarTypeDefinition: ['description', 'name', 'directives'],\n  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],\n  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],\n  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],\n  InterfaceTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],\n  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],\n  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],\n  EnumValueDefinition: ['description', 'name', 'directives'],\n  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],\n  SchemaExtension: ['directives', 'operationTypes'],\n  ScalarTypeExtension: ['name', 'directives'],\n  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],\n  InterfaceTypeExtension: ['name', 'interfaces', 'directives', 'fields'],\n  UnionTypeExtension: ['name', 'directives', 'types'],\n  EnumTypeExtension: ['name', 'directives', 'values'],\n  InputObjectTypeExtension: ['name', 'directives', 'fields']\n};\nexports.QueryDocumentKeys = QueryDocumentKeys;\nvar BREAK = Object.freeze({});\n/**\n * visit() will walk through an AST using a depth-first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n *     const editedAST = visit(ast, {\n *       enter(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: skip visiting this node\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       },\n *       leave(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: no action\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       }\n *     });\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to four permutations of the\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node of a specific kind.\n *\n *     visit(ast, {\n *       Kind(node) {\n *         // enter the \"Kind\" node\n *       }\n *     })\n *\n * 2) Named visitors that trigger upon entering and leaving a node of\n *    a specific kind.\n *\n *     visit(ast, {\n *       Kind: {\n *         enter(node) {\n *           // enter the \"Kind\" node\n *         }\n *         leave(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n *     visit(ast, {\n *       enter(node) {\n *         // enter any node\n *       },\n *       leave(node) {\n *         // leave any node\n *       }\n *     })\n *\n * 4) Parallel visitors for entering and leaving nodes of a specific kind.\n *\n *     visit(ast, {\n *       enter: {\n *         Kind(node) {\n *           // enter the \"Kind\" node\n *         }\n *       },\n *       leave: {\n *         Kind(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n */\n\nexports.BREAK = BREAK;\n\nfunction visit(root, visitor) {\n  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;\n\n  /* eslint-disable no-undef-init */\n  var stack = undefined;\n  var inArray = Array.isArray(root);\n  var keys = [root];\n  var index = -1;\n  var edits = [];\n  var node = undefined;\n  var key = undefined;\n  var parent = undefined;\n  var path = [];\n  var ancestors = [];\n  var newRoot = root;\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    var isLeaving = index === keys.length;\n    var isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n        } else {\n          var clone = {};\n\n          for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) {\n            var k = _Object$keys2[_i2];\n            clone[k] = node[k];\n          }\n\n          node = clone;\n        }\n\n        var editOffset = 0;\n\n        for (var ii = 0; ii < edits.length; ii++) {\n          var editKey = edits[ii][0];\n          var editValue = edits[ii][1];\n\n          if (inArray) {\n            editKey -= editOffset;\n          }\n\n          if (inArray && editValue === null) {\n            node.splice(editKey, 1);\n            editOffset++;\n          } else {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else {\n      key = parent ? inArray ? index : keys[index] : undefined;\n      node = parent ? parent[key] : newRoot;\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      if (parent) {\n        path.push(key);\n      }\n    }\n\n    var result = void 0;\n\n    if (!Array.isArray(node)) {\n      if (!(0, _ast.isNode)(node)) {\n        throw new Error(\"Invalid AST Node: \".concat((0, _inspect.default)(node), \".\"));\n      }\n\n      var visitFn = getVisitFn(visitor, node.kind, isLeaving);\n\n      if (visitFn) {\n        result = visitFn.call(visitor, node, key, parent, path, ancestors);\n\n        if (result === BREAK) {\n          break;\n        }\n\n        if (result === false) {\n          if (!isLeaving) {\n            path.pop();\n            continue;\n          }\n        } else if (result !== undefined) {\n          edits.push([key, result]);\n\n          if (!isLeaving) {\n            if ((0, _ast.isNode)(result)) {\n              node = result;\n            } else {\n              path.pop();\n              continue;\n            }\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      var _visitorKeys$node$kin;\n\n      stack = {\n        inArray: inArray,\n        index: index,\n        keys: keys,\n        edits: edits,\n        prev: stack\n      };\n      inArray = Array.isArray(node);\n      keys = inArray ? node : (_visitorKeys$node$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    newRoot = edits[edits.length - 1][1];\n  }\n\n  return newRoot;\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\n\nfunction visitInParallel(visitors) {\n  var skipping = new Array(visitors.length);\n  return {\n    enter: function enter(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (skipping[i] == null) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          false);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      }\n    },\n    leave: function leave(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (skipping[i] == null) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          true);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          }\n        } else if (skipping[i] === node) {\n          skipping[i] = null;\n        }\n      }\n    }\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n */\n\n\nfunction getVisitFn(visitor, kind, isLeaving) {\n  var kindVisitor = visitor[kind];\n\n  if (kindVisitor) {\n    if (!isLeaving && typeof kindVisitor === 'function') {\n      // { Kind() {} }\n      return kindVisitor;\n    }\n\n    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;\n\n    if (typeof kindSpecificVisitor === 'function') {\n      // { Kind: { enter() {}, leave() {} } }\n      return kindSpecificVisitor;\n    }\n  } else {\n    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;\n\n    if (specificVisitor) {\n      if (typeof specificVisitor === 'function') {\n        // { enter() {}, leave() {} }\n        return specificVisitor;\n      }\n\n      var specificKindVisitor = specificVisitor[kind];\n\n      if (typeof specificKindVisitor === 'function') {\n        // { enter: { Kind() {} }, leave: { Kind() {} } }\n        return specificKindVisitor;\n      }\n    }\n  }\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __extends } from 'tslib';\n\nvar genericMessage = \"Invariant Violation\";\r\nvar _a = Object.setPrototypeOf, setPrototypeOf = _a === void 0 ? function (obj, proto) {\r\n    obj.__proto__ = proto;\r\n    return obj;\r\n} : _a;\r\nvar InvariantError = /** @class */ (function (_super) {\r\n    __extends(InvariantError, _super);\r\n    function InvariantError(message) {\r\n        if (message === void 0) { message = genericMessage; }\r\n        var _this = _super.call(this, typeof message === \"number\"\r\n            ? genericMessage + \": \" + message + \" (see https://github.com/apollographql/invariant-packages)\"\r\n            : message) || this;\r\n        _this.framesToPop = 1;\r\n        _this.name = genericMessage;\r\n        setPrototypeOf(_this, InvariantError.prototype);\r\n        return _this;\r\n    }\r\n    return InvariantError;\r\n}(Error));\r\nfunction invariant(condition, message) {\r\n    if (!condition) {\r\n        throw new InvariantError(message);\r\n    }\r\n}\r\nfunction wrapConsoleMethod(method) {\r\n    return function () {\r\n        return console[method].apply(console, arguments);\r\n    };\r\n}\r\n(function (invariant) {\r\n    invariant.warn = wrapConsoleMethod(\"warn\");\r\n    invariant.error = wrapConsoleMethod(\"error\");\r\n})(invariant || (invariant = {}));\r\n// Code that uses ts-invariant with rollup-plugin-invariant may want to\r\n// import this process stub to avoid errors evaluating process.env.NODE_ENV.\r\n// However, because most ESM-to-CJS compilers will rewrite the process import\r\n// as tsInvariant.process, which prevents proper replacement by minifiers, we\r\n// also attempt to define the stub globally when it is not already defined.\r\nvar processStub = { env: {} };\r\nif (typeof process === \"object\") {\r\n    processStub = process;\r\n}\r\nelse\r\n    try {\r\n        // Using Function to evaluate this assignment in global scope also escapes\r\n        // the strict mode of the current module, thereby allowing the assignment.\r\n        // Inspired by https://github.com/facebook/regenerator/pull/369.\r\n        Function(\"stub\", \"process = stub\")(processStub);\r\n    }\r\n    catch (atLeastWeTried) {\r\n        // The assignment can fail if a Content Security Policy heavy-handedly\r\n        // forbids Function usage. In those environments, developers should take\r\n        // extra care to replace process.env.NODE_ENV in their production builds,\r\n        // or define an appropriate global.process polyfill.\r\n    }\r\nvar invariant$1 = invariant;\n\nexport default invariant$1;\nexport { InvariantError, invariant, processStub as process };\n//# sourceMappingURL=invariant.esm.js.map\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__extends","__","this","constructor","prototype","create","__assign","assign","t","s","i","n","arguments","length","call","apply","queryFromPojo","obj","kind","definitions","operation","name","value","selectionSet","selectionSetFromObj","isArray","selections","keys","forEach","key","field","undefined","push","Cache","justTypenameQuery","variableDefinitions","directives","alias","ApolloCache","transformDocument","document","transformForLink","readQuery","options","optimistic","read","query","variables","readFragment","fragment","fragmentName","rootId","id","writeQuery","write","dataId","result","data","writeFragment","writeData","_a","typename","typenameResult","e","__typename","dataToWrite","typeCondition","currentContext","MISSING_VALUE","idCounter","globalKey","host","Slot","Date","now","Math","random","toString","slice","join","hasValue","context_1","parent","slots","getValue","withValue","callback","args","thisArg","bind","context","saved","noContext","defineProperty","enumerable","writable","configurable","defaultDispose","max","dispose","Infinity","map","Map","newest","oldest","has","get","entry","getEntry","older","newer","set","clean","size","delete","parentEntrySlot","reusableEmptyArray","emptySetPool","assert","condition","optionalMessage","Error","valueGet","Entry","fn","parents","Set","childValues","dirtyChildren","dirty","recomputing","count","recompute","child","add","mightBeDirty","reportDirtyChild","reportCleanChild","rememberParent","maybeReportOrphan","originalChildren","forgetChildren","recomputeNewValue","subscribe","maybeUnsubscribe","unsubscribe","setDirty","maybeSubscribe","reportClean","setClean","reallyRecompute","reportDirty","_this","forgetChild","pop","a","len","childValue","removeDirtyChild","dc","reportOrphan","children","_value","KeyTrie","weakness","lookup","array","_i","lookupArray","node","getChildTrie","isObjRef","weak","WeakMap","strong","keyTrie","defaultMakeCacheKey","caches","wrap","originalFunction","cache","pow","disposable","makeCacheKey","clear","haveWarned","shouldWarn","answer","HeuristicFragmentMatcher","ensureReady","Promise","resolve","canBypassInit","match","idValue","store","isRootQuery","hasOwn","IntrospectionFragmentMatcher","introspectionQueryResultData","possibleTypesMap","parseIntrospectionResult","isReady","implementingTypes","indexOf","introspectionResultData","typeMap","__schema","types","type","possibleTypes","implementingType","DepTrackingCache","depend","toObject","replace","newData","defaultNormalizedCacheFactory","seed","StoreReader","_b","_c","cacheKeyRoot","_d","freezeResults","_e","executeStoreQuery","executeSelectionSet","executeSubSelectedArray","rootValue","contextValue","variableValues","fragmentMatcher","JSON","stringify","execContext","readQueryFromStore","diffQueryAgainstStore","returnPartialData","previousResult","fragmentMatcherFunction","config","queryDefinition","dataIdFromObject","cacheRedirects","execResult","generated","hasMissingFields","missing","info","tolerable","complete","defaultFragmentMatcher","mainDefinition","fragments","fragmentMap","finalResult","objectsToMerge","object","handleMissing","selection","fieldResult","executeField","fragmentExecResult","readStoreResult","fieldName","resultKey","storeKeyName","fieldValue","resolver","getCacheKey","storeObj","json","readStoreResolver","combineExecResults","assertSelectionSetForIdValue","execResults","childResult","item","ObjectCache","WriteError","_super","StoreWriter","writeQueryToStore","writeResultToStore","operationDefinition","writeSelectionSetToStore","processedData","error","enhancedError","message","stack","enhanceErrorWithDocument","resultFieldKey","writeFieldToStore","isDefered","isClient","some","directive","matches","fakeContext","storeValue","storeObject","storeFieldName","generatedId","processArrayValue","valueDataId","isGeneratedId","semanticId","isDataProcessed","escapedId","hadTypename","hasTypename","typenameChanged","mergeWithGenerated","index","itemDataId","generatedKey","realKey","real","madeChanges","realValue","newRealValue","defaultConfig","defaultDataIdFromObject","addTypename","resultCaching","_id","hasOwn$1","OptimisticCacheLayer","optimisticId","transaction","InMemoryCache","watches","typenameDocumentCache","silenceBroadcast","customResolvers","cacheResolvers","optimisticData","storeWriter","storeReader","maybeBroadcastWatch","c","restore","extract","broadcastWatches","diff","watch","evict","reset","removeOptimistic","idToRemove","toReapply","removedCount","layer","layer_1","performTransaction","recordOptimisticTransaction","__spreadArrays","il","r","k","j","jl","valueToObjectRepresentation","argObj","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","fields","isVariable","variableValue","isListValue","values","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","filterKeys","sort","queryArgs_1","filteredArgs_1","completeFieldName","stringifiedArgs","argumentsObjectFromField","argObj_1","resultKeyNameFromField","isField","isInlineFragment","isIdValue","idObject","toIdValue","idConfig","isJsonValue","jsonObject","getDirectiveInfoFromField","directiveObj_1","shouldInclude","filter","isInclusionDirective","directiveArguments","ifArgument","ifValue","every","evaledValue","hasDirectives","names","doc","visit","Directive","getDirectiveNames","hasClientExports","getFragmentQueryDocument","actualFragmentName","definition","target","sources","source","checkDocument","operations","getOperationDefinition","getOperationName","x","getFragmentDefinitions","getQueryDefinition","queryDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","getDefaultValues","defaultValues","defaultValue","variable","defaultValueObj","filterInPlace","test","elem","TYPENAME_FIELD","isEmpty","op","nullIfDocIsEmpty","fragmentDef","getFragmentDefinition","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","Field","remove","arg","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","v","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","removeArgumentsFromDocument","fs","def","FragmentDefinition","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","canUseWeakMap","navigator","product","cloneDeep","cloneDeepHelper","val","seen","copy_1","copy_2","getPrototypeOf","isEnv","env","process","isProduction","isTest","tryFunctionOrLogError","f","console","graphQLResultHasError","errors","mergeDeep","mergeDeepArray","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","module","exports","opts","cmp","cycles","aobj","bobj","toJSON","isFinite","out","TypeError","seenIndex","splice","classObject","_invariant","default","inspect","_nodejsCustomInspectSymbol","_interopRequireDefault","__esModule","formatValue","_typeof","Symbol","iterator","MAX_ARRAY_LENGTH","MAX_RECURSIVE_DEPTH","seenValues","concat","previouslySeenValues","customInspectFn","String","getCustomFn","customValue","min","remaining","items","formatArray","tag","getObjectTag","properties","formatObject","formatObjectValue","Boolean","_default","for","isNode","maybeNode","Token","Location","_defineInspect","startToken","endToken","start","end","line","column","prev","next","root","visitor","visitorKeys","QueryDocumentKeys","inArray","edits","path","ancestors","newRoot","isLeaving","isEdited","clone","_i2","_Object$keys2","editOffset","ii","editKey","editValue","_visitorKeys$node$kin","_ast","_inspect","visitFn","getVisitFn","BREAK","visitInParallel","visitors","skipping","leave","Name","Document","VariableDefinition","InlineFragment","IntValue","FloatValue","StringValue","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","NamedType","ListType","NonNullType","SchemaDefinition","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","FieldDefinition","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","freeze","kindVisitor","kindSpecificVisitor","specificVisitor","specificKindVisitor","genericMessage","proto","InvariantError","framesToPop","invariant","wrapConsoleMethod","method","warn","processStub","Function","atLeastWeTried"],"sourceRoot":""}