{"version":3,"file":"js/chunk-vendors-c0d76f48.8cbf57cd.js","mappings":"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","sources":["webpack://campus-addresses/./node_modules/apollo-client/node_modules/ts-invariant/lib/invariant.esm.js","webpack://campus-addresses/./node_modules/apollo-client/bundle.esm.js","webpack://campus-addresses/./node_modules/apollo-client/node_modules/symbol-observable/es/ponyfill.js","webpack://campus-addresses/./node_modules/apollo-client/node_modules/symbol-observable/es/index.js","webpack://campus-addresses/./node_modules/apollo-link-http-common/node_modules/ts-invariant/lib/invariant.esm.js","webpack://campus-addresses/./node_modules/apollo-link-http-common/lib/bundle.esm.js","webpack://campus-addresses/./node_modules/apollo-link-http/lib/bundle.esm.js","webpack://campus-addresses/./node_modules/apollo-link/node_modules/ts-invariant/lib/invariant.esm.js","webpack://campus-addresses/./node_modules/apollo-link/lib/bundle.esm.js","webpack://campus-addresses/./node_modules/apollo-link/node_modules/zen-observable-ts/lib/bundle.esm.js","webpack://campus-addresses/./node_modules/apollo-utilities/node_modules/ts-invariant/lib/invariant.esm.js","webpack://campus-addresses/./node_modules/apollo-utilities/lib/bundle.esm.js","webpack://campus-addresses/./node_modules/apollo-utilities/node_modules/@wry/equality/lib/equality.esm.js","webpack://campus-addresses/./node_modules/fast-json-stable-stringify/index.js","webpack://campus-addresses/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://campus-addresses/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://campus-addresses/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://campus-addresses/./node_modules/@babel/runtime/helpers/esm/defineProperty.js"],"sourcesContent":["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","import { __extends, __assign, __awaiter, __generator } from 'tslib';\nimport { getOperationDefinition, isEqual, tryFunctionOrLogError, cloneDeep, mergeDeep, hasDirectives, removeClientSetsFromDocument, buildQueryFromSelectionSet, getMainDefinition, getFragmentDefinitions, createFragmentMap, mergeDeepArray, resultKeyNameFromField, argumentsObjectFromField, shouldInclude, isField, isInlineFragment, canUseWeakMap, graphQLResultHasError, removeConnectionDirectiveFromDocument, hasClientExports, getDefaultValues, getOperationName } from 'apollo-utilities';\nimport { Observable as Observable$1, execute, ApolloLink } from 'apollo-link';\nimport $$observable from 'symbol-observable';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { visit, BREAK } from 'graphql/language/visitor';\n\nvar NetworkStatus;\n(function (NetworkStatus) {\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\nfunction isNetworkRequestInFlight(networkStatus) {\n    return networkStatus < 7;\n}\n\nvar Observable = (function (_super) {\n    __extends(Observable, _super);\n    function Observable() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Observable.prototype[$$observable] = function () {\n        return this;\n    };\n    Observable.prototype['@@observable'] = function () {\n        return this;\n    };\n    return Observable;\n}(Observable$1));\n\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n\nfunction isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (isNonEmptyArray(err.graphQLErrors)) {\n        err.graphQLErrors.forEach(function (graphQLError) {\n            var errorMessage = graphQLError\n                ? graphQLError.message\n                : 'Error message not found.';\n            message += \"GraphQL error: \" + errorMessage + \"\\n\";\n        });\n    }\n    if (err.networkError) {\n        message += 'Network error: ' + err.networkError.message + '\\n';\n    }\n    message = message.replace(/\\n$/, '');\n    return message;\n};\nvar ApolloError = (function (_super) {\n    __extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.networkError = networkError || null;\n        if (!errorMessage) {\n            _this.message = generateErrorMessage(_this);\n        }\n        else {\n            _this.message = errorMessage;\n        }\n        _this.extraInfo = extraInfo;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\n\nvar FetchType;\n(function (FetchType) {\n    FetchType[FetchType[\"normal\"] = 1] = \"normal\";\n    FetchType[FetchType[\"refetch\"] = 2] = \"refetch\";\n    FetchType[FetchType[\"poll\"] = 3] = \"poll\";\n})(FetchType || (FetchType = {}));\n\nvar hasError = function (storeValue, policy) {\n    if (policy === void 0) { policy = 'none'; }\n    return storeValue && (storeValue.networkError ||\n        (policy === 'none' && isNonEmptyArray(storeValue.graphQLErrors)));\n};\nvar ObservableQuery = (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, options = _a.options, _b = _a.shouldSubscribe, shouldSubscribe = _b === void 0 ? true : _b;\n        var _this = _super.call(this, function (observer) {\n            return _this.onSubscribe(observer);\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.isTornDown = false;\n        _this.options = options;\n        _this.variables = options.variables || {};\n        _this.queryId = queryManager.generateQueryId();\n        _this.shouldSubscribe = shouldSubscribe;\n        var opDef = getOperationDefinition(options.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        _this.queryManager = queryManager;\n        return _this;\n    }\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    ObservableQuery.prototype.currentResult = function () {\n        var result = this.getCurrentResult();\n        if (result.data === undefined) {\n            result.data = {};\n        }\n        return result;\n    };\n    ObservableQuery.prototype.getCurrentResult = function () {\n        if (this.isTornDown) {\n            var lastResult = this.lastResult;\n            return {\n                data: !this.lastError && lastResult && lastResult.data || void 0,\n                error: this.lastError,\n                loading: false,\n                networkStatus: NetworkStatus.error,\n            };\n        }\n        var _a = this.queryManager.getCurrentQueryResult(this), data = _a.data, partial = _a.partial;\n        var queryStoreValue = this.queryManager.queryStore.get(this.queryId);\n        var result;\n        var fetchPolicy = this.options.fetchPolicy;\n        var isNetworkFetchPolicy = fetchPolicy === 'network-only' ||\n            fetchPolicy === 'no-cache';\n        if (queryStoreValue) {\n            var networkStatus = queryStoreValue.networkStatus;\n            if (hasError(queryStoreValue, this.options.errorPolicy)) {\n                return {\n                    data: void 0,\n                    loading: false,\n                    networkStatus: networkStatus,\n                    error: new ApolloError({\n                        graphQLErrors: queryStoreValue.graphQLErrors,\n                        networkError: queryStoreValue.networkError,\n                    }),\n                };\n            }\n            if (queryStoreValue.variables) {\n                this.options.variables = __assign(__assign({}, this.options.variables), queryStoreValue.variables);\n                this.variables = this.options.variables;\n            }\n            result = {\n                data: data,\n                loading: isNetworkRequestInFlight(networkStatus),\n                networkStatus: networkStatus,\n            };\n            if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {\n                result.errors = queryStoreValue.graphQLErrors;\n            }\n        }\n        else {\n            var loading = isNetworkFetchPolicy ||\n                (partial && fetchPolicy !== 'cache-only');\n            result = {\n                data: data,\n                loading: loading,\n                networkStatus: loading ? NetworkStatus.loading : NetworkStatus.ready,\n            };\n        }\n        if (!partial) {\n            this.updateLastResult(__assign(__assign({}, result), { stale: false }));\n        }\n        return __assign(__assign({}, result), { partial: partial });\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        var snapshot = this.lastResultSnapshot;\n        return !(snapshot &&\n            newResult &&\n            snapshot.networkStatus === newResult.networkStatus &&\n            snapshot.stale === newResult.stale &&\n            isEqual(snapshot.data, newResult.data));\n    };\n    ObservableQuery.prototype.getLastResult = function () {\n        return this.lastResult;\n    };\n    ObservableQuery.prototype.getLastError = function () {\n        return this.lastError;\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.lastResult;\n        delete this.lastResultSnapshot;\n        delete this.lastError;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        var queryStore = this.queryManager.queryStore.get(this.queryId);\n        if (queryStore) {\n            queryStore.networkError = null;\n            queryStore.graphQLErrors = [];\n        }\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === 'cache-only') {\n            return Promise.reject(process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('cache-only fetchPolicy option should not be used together with query refetch.'));\n        }\n        if (fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'cache-and-network') {\n            fetchPolicy = 'network-only';\n        }\n        if (!isEqual(this.variables, variables)) {\n            this.variables = __assign(__assign({}, this.variables), variables);\n        }\n        if (!isEqual(this.options.variables, this.variables)) {\n            this.options.variables = __assign(__assign({}, this.options.variables), this.variables);\n        }\n        return this.queryManager.fetchQuery(this.queryId, __assign(__assign({}, this.options), { fetchPolicy: fetchPolicy }), FetchType.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(fetchMoreOptions.updateQuery, 2) : invariant(fetchMoreOptions.updateQuery, 'updateQuery option is required. This function defines how to update the query data with the new results.');\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), { variables: __assign(__assign({}, this.variables), fetchMoreOptions.variables) }))), { fetchPolicy: 'network-only' });\n        var qid = this.queryManager.generateQueryId();\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, FetchType.normal, this.queryId)\n            .then(function (fetchMoreResult) {\n            _this.updateQuery(function (previousResult) {\n                return fetchMoreOptions.updateQuery(previousResult, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n            });\n            _this.queryManager.stopQuery(qid);\n            return fetchMoreResult;\n        }, function (error) {\n            _this.queryManager.stopQuery(qid);\n            throw error;\n        });\n    };\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                process.env.NODE_ENV === \"production\" || invariant.error('Unhandled GraphQL subscription error', err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (opts) {\n        var oldFetchPolicy = this.options.fetchPolicy;\n        this.options = __assign(__assign({}, this.options), opts);\n        if (opts.pollInterval) {\n            this.startPolling(opts.pollInterval);\n        }\n        else if (opts.pollInterval === 0) {\n            this.stopPolling();\n        }\n        var fetchPolicy = opts.fetchPolicy;\n        return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' ||\n            oldFetchPolicy === 'standby' ||\n            fetchPolicy === 'network-only'), opts.fetchResults);\n    };\n    ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {\n        if (tryFetch === void 0) { tryFetch = false; }\n        if (fetchResults === void 0) { fetchResults = true; }\n        this.isTornDown = false;\n        variables = variables || this.variables;\n        if (!tryFetch && isEqual(variables, this.variables)) {\n            return this.observers.size && fetchResults\n                ? this.result()\n                : Promise.resolve();\n        }\n        this.variables = this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.queryManager.fetchQuery(this.queryId, this.options);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var _a = queryManager.getQueryWithPreviousResult(this.queryId), previousResult = _a.previousResult, variables = _a.variables, document = _a.document;\n        var newResult = tryFunctionOrLogError(function () {\n            return mapFn(previousResult, { variables: variables });\n        });\n        if (newResult) {\n            queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.queryManager.stopPollingQuery(this.queryId);\n        this.options.pollInterval = undefined;\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        assertNotCacheFirstOrOnly(this);\n        this.options.pollInterval = pollInterval;\n        this.queryManager.startPollingQuery(this.options, this.queryId);\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult) {\n        var previousResult = this.lastResult;\n        this.lastResult = newResult;\n        this.lastResultSnapshot = this.queryManager.assumeImmutableResults\n            ? newResult\n            : cloneDeep(newResult);\n        return previousResult;\n    };\n    ObservableQuery.prototype.onSubscribe = function (observer) {\n        var _this = this;\n        try {\n            var subObserver = observer._subscription._observer;\n            if (subObserver && !subObserver.error) {\n                subObserver.error = defaultSubscriptionObserverErrorCallback;\n            }\n        }\n        catch (_a) { }\n        var first = !this.observers.size;\n        this.observers.add(observer);\n        if (observer.next && this.lastResult)\n            observer.next(this.lastResult);\n        if (observer.error && this.lastError)\n            observer.error(this.lastError);\n        if (first) {\n            this.setUpQuery();\n        }\n        return function () {\n            if (_this.observers.delete(observer) && !_this.observers.size) {\n                _this.tearDownQuery();\n            }\n        };\n    };\n    ObservableQuery.prototype.setUpQuery = function () {\n        var _this = this;\n        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;\n        if (this.shouldSubscribe) {\n            queryManager.addObservableQuery(queryId, this);\n        }\n        if (this.options.pollInterval) {\n            assertNotCacheFirstOrOnly(this);\n            queryManager.startPollingQuery(this.options, queryId);\n        }\n        var onError = function (error) {\n            _this.updateLastResult(__assign(__assign({}, _this.lastResult), { errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false }));\n            iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n        };\n        queryManager.observeQuery(queryId, this.options, {\n            next: function (result) {\n                if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n                    var previousResult_1 = _this.updateLastResult(result);\n                    var _a = _this.options, query_1 = _a.query, variables = _a.variables, fetchPolicy_1 = _a.fetchPolicy;\n                    if (queryManager.transform(query_1).hasClientExports) {\n                        queryManager.getLocalState().addExportedVariables(query_1, variables).then(function (variables) {\n                            var previousVariables = _this.variables;\n                            _this.variables = _this.options.variables = variables;\n                            if (!result.loading &&\n                                previousResult_1 &&\n                                fetchPolicy_1 !== 'cache-only' &&\n                                queryManager.transform(query_1).serverQuery &&\n                                !isEqual(previousVariables, variables)) {\n                                _this.refetch();\n                            }\n                            else {\n                                iterateObserversSafely(_this.observers, 'next', result);\n                            }\n                        });\n                    }\n                    else {\n                        iterateObserversSafely(_this.observers, 'next', result);\n                    }\n                }\n            },\n            error: onError,\n        }).catch(onError);\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        var queryManager = this.queryManager;\n        this.isTornDown = true;\n        queryManager.stopPollingQuery(this.queryId);\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        queryManager.removeObservableQuery(this.queryId);\n        queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n    };\n    return ObservableQuery;\n}(Observable));\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\nfunction iterateObserversSafely(observers, method, argument) {\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\nfunction assertNotCacheFirstOrOnly(obsQuery) {\n    var fetchPolicy = obsQuery.options.fetchPolicy;\n    process.env.NODE_ENV === \"production\" ? invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 3) : invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 'Queries that specify the cache-first and cache-only fetchPolicies cannot also be polling queries.');\n}\n\nvar MutationStore = (function () {\n    function MutationStore() {\n        this.store = {};\n    }\n    MutationStore.prototype.getStore = function () {\n        return this.store;\n    };\n    MutationStore.prototype.get = function (mutationId) {\n        return this.store[mutationId];\n    };\n    MutationStore.prototype.initMutation = function (mutationId, mutation, variables) {\n        this.store[mutationId] = {\n            mutation: mutation,\n            variables: variables || {},\n            loading: true,\n            error: null,\n        };\n    };\n    MutationStore.prototype.markMutationError = function (mutationId, error) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = error;\n        }\n    };\n    MutationStore.prototype.markMutationResult = function (mutationId) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = null;\n        }\n    };\n    MutationStore.prototype.reset = function () {\n        this.store = {};\n    };\n    return MutationStore;\n}());\n\nvar QueryStore = (function () {\n    function QueryStore() {\n        this.store = {};\n    }\n    QueryStore.prototype.getStore = function () {\n        return this.store;\n    };\n    QueryStore.prototype.get = function (queryId) {\n        return this.store[queryId];\n    };\n    QueryStore.prototype.initQuery = function (query) {\n        var previousQuery = this.store[query.queryId];\n        process.env.NODE_ENV === \"production\" ? invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 19) : invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 'Internal Error: may not update existing query string in store');\n        var isSetVariables = false;\n        var previousVariables = null;\n        if (query.storePreviousVariables &&\n            previousQuery &&\n            previousQuery.networkStatus !== NetworkStatus.loading) {\n            if (!isEqual(previousQuery.variables, query.variables)) {\n                isSetVariables = true;\n                previousVariables = previousQuery.variables;\n            }\n        }\n        var networkStatus;\n        if (isSetVariables) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        else if (query.isPoll) {\n            networkStatus = NetworkStatus.poll;\n        }\n        else if (query.isRefetch) {\n            networkStatus = NetworkStatus.refetch;\n        }\n        else {\n            networkStatus = NetworkStatus.loading;\n        }\n        var graphQLErrors = [];\n        if (previousQuery && previousQuery.graphQLErrors) {\n            graphQLErrors = previousQuery.graphQLErrors;\n        }\n        this.store[query.queryId] = {\n            document: query.document,\n            variables: query.variables,\n            previousVariables: previousVariables,\n            networkError: null,\n            graphQLErrors: graphQLErrors,\n            networkStatus: networkStatus,\n            metadata: query.metadata,\n        };\n        if (typeof query.fetchMoreForQueryId === 'string' &&\n            this.store[query.fetchMoreForQueryId]) {\n            this.store[query.fetchMoreForQueryId].networkStatus =\n                NetworkStatus.fetchMore;\n        }\n    };\n    QueryStore.prototype.markQueryResult = function (queryId, result, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = null;\n        this.store[queryId].graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];\n        this.store[queryId].previousVariables = null;\n        this.store[queryId].networkStatus = NetworkStatus.ready;\n        if (typeof fetchMoreForQueryId === 'string' &&\n            this.store[fetchMoreForQueryId]) {\n            this.store[fetchMoreForQueryId].networkStatus = NetworkStatus.ready;\n        }\n    };\n    QueryStore.prototype.markQueryError = function (queryId, error, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = error;\n        this.store[queryId].networkStatus = NetworkStatus.error;\n        if (typeof fetchMoreForQueryId === 'string') {\n            this.markQueryResultClient(fetchMoreForQueryId, true);\n        }\n    };\n    QueryStore.prototype.markQueryResultClient = function (queryId, complete) {\n        var storeValue = this.store && this.store[queryId];\n        if (storeValue) {\n            storeValue.networkError = null;\n            storeValue.previousVariables = null;\n            if (complete) {\n                storeValue.networkStatus = NetworkStatus.ready;\n            }\n        }\n    };\n    QueryStore.prototype.stopQuery = function (queryId) {\n        delete this.store[queryId];\n    };\n    QueryStore.prototype.reset = function (observableQueryIds) {\n        var _this = this;\n        Object.keys(this.store).forEach(function (queryId) {\n            if (observableQueryIds.indexOf(queryId) < 0) {\n                _this.stopQuery(queryId);\n            }\n            else {\n                _this.store[queryId].networkStatus = NetworkStatus.loading;\n            }\n        });\n    };\n    return QueryStore;\n}());\n\nfunction capitalizeFirstLetter(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nvar LocalState = (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    LocalState.prototype.runResolvers = function (_a) {\n        var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_c) {\n                if (document) {\n                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives(['client'], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n            process.env.NODE_ENV === \"production\" || invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' +\n                'were specified. This means ApolloClient local resolver handling ' +\n                'has been disabled, and @client directives will be passed through ' +\n                'to your link chain.');\n        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return this.resolvers ? removeClientSetsFromDocument(document) : document;\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var cache = this.cache;\n        var newContext = __assign(__assign({}, context), { cache: cache, getCacheKey: function (obj) {\n                if (cache.config) {\n                    return cache.config.dataIdFromObject(obj);\n                }\n                else {\n                    process.env.NODE_ENV === \"production\" ? invariant(false, 6) : invariant(false, 'To use context.getCacheKey, you need to use a cache that has ' +\n                        'a configurable dataIdFromObject, like apollo-cache-inmemory.');\n                }\n            } });\n        return newContext;\n    };\n    LocalState.prototype.addExportedVariables = function (document, variables, context) {\n        if (variables === void 0) { variables = {}; }\n        if (context === void 0) { context = {}; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === 'client' && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === 'always' &&\n                                arg.value.kind === 'BooleanValue' &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n        if (context === void 0) { context = {}; }\n        if (variables === void 0) { variables = {}; }\n        if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n        if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n        return __awaiter(this, void 0, void 0, function () {\n            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                definitionOperation = mainDefinition\n                    .operation;\n                defaultOperationType = definitionOperation\n                    ? capitalizeFirstLetter(definitionOperation)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache,\n                        client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (isField(selection)) {\n                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== 'undefined') {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            process.env.NODE_ENV === \"production\" ? invariant(fragment, 7) : invariant(fragment, \"No fragment named \" + selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2];\n                    });\n                }); };\n                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(resolve(rootValue, argumentsObjectFromField(field, variables), execContext.context, { field: field, fragmentMap: execContext.fragmentMap }));\n                        }\n                    }\n                }\n                return [2, resultPromise.then(function (result) {\n                        if (result === void 0) { result = defaultResult; }\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === 'export' && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        if (result == null) {\n                            return result;\n                        }\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, result, execContext);\n                        }\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, item, execContext);\n            }\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n            }\n        }));\n    };\n    return LocalState;\n}());\n\nfunction multiplex(inner) {\n    var observers = new Set();\n    var sub = null;\n    return new Observable(function (observer) {\n        observers.add(observer);\n        sub = sub || inner.subscribe({\n            next: function (value) {\n                observers.forEach(function (obs) { return obs.next && obs.next(value); });\n            },\n            error: function (error) {\n                observers.forEach(function (obs) { return obs.error && obs.error(error); });\n            },\n            complete: function () {\n                observers.forEach(function (obs) { return obs.complete && obs.complete(); });\n            },\n        });\n        return function () {\n            if (observers.delete(observer) && !observers.size && sub) {\n                sub.unsubscribe();\n                sub = null;\n            }\n        };\n    });\n}\nfunction asyncMap(observable, mapFn) {\n    return new Observable(function (observer) {\n        var next = observer.next, error = observer.error, complete = observer.complete;\n        var activeNextCount = 0;\n        var completed = false;\n        var handler = {\n            next: function (value) {\n                ++activeNextCount;\n                new Promise(function (resolve) {\n                    resolve(mapFn(value));\n                }).then(function (result) {\n                    --activeNextCount;\n                    next && next.call(observer, result);\n                    completed && handler.complete();\n                }, function (e) {\n                    --activeNextCount;\n                    error && error.call(observer, e);\n                });\n            },\n            error: function (e) {\n                error && error.call(observer, e);\n            },\n            complete: function () {\n                completed = true;\n                if (!activeNextCount) {\n                    complete && complete.call(observer);\n                }\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = (function () {\n    function QueryManager(_a) {\n        var link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, store = _a.store, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;\n        this.mutationStore = new MutationStore();\n        this.queryStore = new QueryStore();\n        this.clientAwareness = {};\n        this.idCounter = 1;\n        this.queries = new Map();\n        this.fetchQueryRejectFns = new Map();\n        this.transformCache = new (canUseWeakMap ? WeakMap : Map)();\n        this.inFlightLinkObservables = new Map();\n        this.pollingInfoByQueryId = new Map();\n        this.link = link;\n        this.queryDeduplication = queryDeduplication;\n        this.dataStore = store;\n        this.onBroadcast = onBroadcast;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: store.getCache() });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = !!assumeImmutableResults;\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError('QueryManager stopped while query was in flight'));\n        });\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, generateUpdateQueriesInfo, self;\n            var _this = this;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        process.env.NODE_ENV === \"production\" ? invariant(mutation, 9) : invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        process.env.NODE_ENV === \"production\" ? invariant(!fetchPolicy || fetchPolicy === 'no-cache', 10) : invariant(!fetchPolicy || fetchPolicy === 'no-cache', \"Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.\");\n                        mutationId = this.generateQueryId();\n                        mutation = this.transform(mutation).document;\n                        this.setQuery(mutationId, function () { return ({ document: mutation }); });\n                        variables = this.getVariables(mutation, variables);\n                        if (!this.transform(mutation).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = _f.sent();\n                        _f.label = 2;\n                    case 2:\n                        generateUpdateQueriesInfo = function () {\n                            var ret = {};\n                            if (updateQueriesByName) {\n                                _this.queries.forEach(function (_a, queryId) {\n                                    var observableQuery = _a.observableQuery;\n                                    if (observableQuery) {\n                                        var queryName = observableQuery.queryName;\n                                        if (queryName &&\n                                            hasOwnProperty.call(updateQueriesByName, queryName)) {\n                                            ret[queryId] = {\n                                                updater: updateQueriesByName[queryName],\n                                                query: _this.queryStore.get(queryId),\n                                            };\n                                        }\n                                    }\n                                });\n                            }\n                            return ret;\n                        };\n                        this.mutationStore.initMutation(mutationId, mutation, variables);\n                        this.dataStore.markMutationInit({\n                            mutationId: mutationId,\n                            document: mutation,\n                            variables: variables,\n                            updateQueries: generateUpdateQueriesInfo(),\n                            update: updateWithProxyFn,\n                            optimisticResponse: optimisticResponse,\n                        });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                var storeResult;\n                                var error;\n                                self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError({\n                                                graphQLErrors: result.errors,\n                                            });\n                                            return;\n                                        }\n                                        self.mutationStore.markMutationResult(mutationId);\n                                        if (fetchPolicy !== 'no-cache') {\n                                            self.dataStore.markMutationResult({\n                                                mutationId: mutationId,\n                                                result: result,\n                                                document: mutation,\n                                                variables: variables,\n                                                updateQueries: generateUpdateQueriesInfo(),\n                                                update: updateWithProxyFn,\n                                            });\n                                        }\n                                        storeResult = result;\n                                    },\n                                    error: function (err) {\n                                        self.mutationStore.markMutationError(mutationId, err);\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        self.setQuery(mutationId, function () { return ({ document: null }); });\n                                        reject(new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                    complete: function () {\n                                        if (error) {\n                                            self.mutationStore.markMutationError(mutationId, error);\n                                        }\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        if (error) {\n                                            reject(error);\n                                            return;\n                                        }\n                                        if (typeof refetchQueries === 'function') {\n                                            refetchQueries = refetchQueries(storeResult);\n                                        }\n                                        var refetchQueryPromises = [];\n                                        if (isNonEmptyArray(refetchQueries)) {\n                                            refetchQueries.forEach(function (refetchQuery) {\n                                                if (typeof refetchQuery === 'string') {\n                                                    self.queries.forEach(function (_a) {\n                                                        var observableQuery = _a.observableQuery;\n                                                        if (observableQuery &&\n                                                            observableQuery.queryName === refetchQuery) {\n                                                            refetchQueryPromises.push(observableQuery.refetch());\n                                                        }\n                                                    });\n                                                }\n                                                else {\n                                                    var queryOptions = {\n                                                        query: refetchQuery.query,\n                                                        variables: refetchQuery.variables,\n                                                        fetchPolicy: 'network-only',\n                                                    };\n                                                    if (refetchQuery.context) {\n                                                        queryOptions.context = refetchQuery.context;\n                                                    }\n                                                    refetchQueryPromises.push(self.query(queryOptions));\n                                                }\n                                            });\n                                        }\n                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                                            self.setQuery(mutationId, function () { return ({ document: null }); });\n                                            if (errorPolicy === 'ignore' &&\n                                                storeResult &&\n                                                graphQLResultHasError(storeResult)) {\n                                                delete storeResult.errors;\n                                            }\n                                            resolve(storeResult);\n                                        });\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, fetchType, fetchMoreForQueryId) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, metadata, _b, fetchPolicy, _c, context, query, variables, storeResult, isNetworkOnly, needToFetch, _d, complete, result, shouldFetch, requestId, cancel, networkResult;\n            var _this = this;\n            return __generator(this, function (_e) {\n                switch (_e.label) {\n                    case 0:\n                        _a = options.metadata, metadata = _a === void 0 ? null : _a, _b = options.fetchPolicy, fetchPolicy = _b === void 0 ? 'cache-first' : _b, _c = options.context, context = _c === void 0 ? {} : _c;\n                        query = this.transform(options.query).document;\n                        variables = this.getVariables(query, options.variables);\n                        if (!this.transform(query).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(query, variables, context)];\n                    case 1:\n                        variables = _e.sent();\n                        _e.label = 2;\n                    case 2:\n                        options = __assign(__assign({}, options), { variables: variables });\n                        isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n                        needToFetch = isNetworkOnly;\n                        if (!isNetworkOnly) {\n                            _d = this.dataStore.getCache().diff({\n                                query: query,\n                                variables: variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }), complete = _d.complete, result = _d.result;\n                            needToFetch = !complete || fetchPolicy === 'cache-and-network';\n                            storeResult = result;\n                        }\n                        shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';\n                        if (hasDirectives(['live'], query))\n                            shouldFetch = true;\n                        requestId = this.idCounter++;\n                        cancel = fetchPolicy !== 'no-cache'\n                            ? this.updateQueryWatch(queryId, query, options)\n                            : undefined;\n                        this.setQuery(queryId, function () { return ({\n                            document: query,\n                            lastRequestId: requestId,\n                            invalidated: true,\n                            cancel: cancel,\n                        }); });\n                        this.invalidate(fetchMoreForQueryId);\n                        this.queryStore.initQuery({\n                            queryId: queryId,\n                            document: query,\n                            storePreviousVariables: shouldFetch,\n                            variables: variables,\n                            isPoll: fetchType === FetchType.poll,\n                            isRefetch: fetchType === FetchType.refetch,\n                            metadata: metadata,\n                            fetchMoreForQueryId: fetchMoreForQueryId,\n                        });\n                        this.broadcastQueries();\n                        if (shouldFetch) {\n                            networkResult = this.fetchRequest({\n                                requestId: requestId,\n                                queryId: queryId,\n                                document: query,\n                                options: options,\n                                fetchMoreForQueryId: fetchMoreForQueryId,\n                            }).catch(function (error) {\n                                if (isApolloError(error)) {\n                                    throw error;\n                                }\n                                else {\n                                    if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                                        _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);\n                                        _this.invalidate(queryId);\n                                        _this.invalidate(fetchMoreForQueryId);\n                                        _this.broadcastQueries();\n                                    }\n                                    throw new ApolloError({ networkError: error });\n                                }\n                            });\n                            if (fetchPolicy !== 'cache-and-network') {\n                                return [2, networkResult];\n                            }\n                            networkResult.catch(function () { });\n                        }\n                        this.queryStore.markQueryResultClient(queryId, !shouldFetch);\n                        this.invalidate(queryId);\n                        this.invalidate(fetchMoreForQueryId);\n                        if (this.transform(query).hasForcedResolvers) {\n                            return [2, this.localState.runResolvers({\n                                    document: query,\n                                    remoteResult: { data: storeResult },\n                                    context: context,\n                                    variables: variables,\n                                    onlyRunForcedResolvers: true,\n                                }).then(function (result) {\n                                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                                    _this.broadcastQueries();\n                                    return result;\n                                })];\n                        }\n                        this.broadcastQueries();\n                        return [2, { data: storeResult }];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {\n        var fetchPolicy = _a.fetchPolicy, variables = _a.variables, errorPolicy = _a.errorPolicy;\n        if (fetchPolicy === 'no-cache') {\n            this.setQuery(queryId, function () { return ({\n                newData: { result: result.data, complete: true },\n            }); });\n        }\n        else {\n            this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');\n        }\n    };\n    QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {\n        var _this = this;\n        function invoke(method, argument) {\n            if (observer[method]) {\n                try {\n                    observer[method](argument);\n                }\n                catch (e) {\n                    process.env.NODE_ENV === \"production\" || invariant.error(e);\n                }\n            }\n            else if (method === 'error') {\n                process.env.NODE_ENV === \"production\" || invariant.error(argument);\n            }\n        }\n        return function (queryStoreValue, newData) {\n            _this.invalidate(queryId, false);\n            if (!queryStoreValue)\n                return;\n            var _a = _this.getQuery(queryId), observableQuery = _a.observableQuery, document = _a.document;\n            var fetchPolicy = observableQuery\n                ? observableQuery.options.fetchPolicy\n                : options.fetchPolicy;\n            if (fetchPolicy === 'standby')\n                return;\n            var loading = isNetworkRequestInFlight(queryStoreValue.networkStatus);\n            var lastResult = observableQuery && observableQuery.getLastResult();\n            var networkStatusChanged = !!(lastResult &&\n                lastResult.networkStatus !== queryStoreValue.networkStatus);\n            var shouldNotifyIfLoading = options.returnPartialData ||\n                (!newData && queryStoreValue.previousVariables) ||\n                (networkStatusChanged && options.notifyOnNetworkStatusChange) ||\n                fetchPolicy === 'cache-only' ||\n                fetchPolicy === 'cache-and-network';\n            if (loading && !shouldNotifyIfLoading) {\n                return;\n            }\n            var hasGraphQLErrors = isNonEmptyArray(queryStoreValue.graphQLErrors);\n            var errorPolicy = observableQuery\n                && observableQuery.options.errorPolicy\n                || options.errorPolicy\n                || 'none';\n            if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {\n                return invoke('error', new ApolloError({\n                    graphQLErrors: queryStoreValue.graphQLErrors,\n                    networkError: queryStoreValue.networkError,\n                }));\n            }\n            try {\n                var data = void 0;\n                var isMissing = void 0;\n                if (newData) {\n                    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {\n                        _this.setQuery(queryId, function () { return ({ newData: null }); });\n                    }\n                    data = newData.result;\n                    isMissing = !newData.complete;\n                }\n                else {\n                    var lastError = observableQuery && observableQuery.getLastError();\n                    var errorStatusChanged = errorPolicy !== 'none' &&\n                        (lastError && lastError.graphQLErrors) !==\n                            queryStoreValue.graphQLErrors;\n                    if (lastResult && lastResult.data && !errorStatusChanged) {\n                        data = lastResult.data;\n                        isMissing = false;\n                    }\n                    else {\n                        var diffResult = _this.dataStore.getCache().diff({\n                            query: document,\n                            variables: queryStoreValue.previousVariables ||\n                                queryStoreValue.variables,\n                            returnPartialData: true,\n                            optimistic: true,\n                        });\n                        data = diffResult.result;\n                        isMissing = !diffResult.complete;\n                    }\n                }\n                var stale = isMissing && !(options.returnPartialData ||\n                    fetchPolicy === 'cache-only');\n                var resultFromStore = {\n                    data: stale ? lastResult && lastResult.data : data,\n                    loading: loading,\n                    networkStatus: queryStoreValue.networkStatus,\n                    stale: stale,\n                };\n                if (errorPolicy === 'all' && hasGraphQLErrors) {\n                    resultFromStore.errors = queryStoreValue.graphQLErrors;\n                }\n                invoke('next', resultFromStore);\n            }\n            catch (networkError) {\n                invoke('error', new ApolloError({ networkError: networkError }));\n            }\n        };\n    };\n    QueryManager.prototype.transform = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cache = this.dataStore.getCache();\n            var transformed = cache.transformDocument(document);\n            var forLink = removeConnectionDirectiveFromDocument(cache.transformForLink(transformed));\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = this.localState.serverQuery(forLink);\n            var cacheEntry_1 = {\n                document: transformed,\n                hasClientExports: hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: getDefaultValues(getOperationDefinition(transformed)),\n            };\n            var add = function (doc) {\n                if (doc && !transformCache.has(doc)) {\n                    transformCache.set(doc, cacheEntry_1);\n                }\n            };\n            add(document);\n            add(transformed);\n            add(clientQuery);\n            add(serverQuery);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n        if (shouldSubscribe === void 0) { shouldSubscribe = true; }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'standby', 11) : invariant(options.fetchPolicy !== 'standby', 'client.watchQuery cannot be called with fetchPolicy set to \"standby\"');\n        options.variables = this.getVariables(options.query, options.variables);\n        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var transformedOptions = __assign({}, options);\n        return new ObservableQuery({\n            queryManager: this,\n            options: transformedOptions,\n            shouldSubscribe: shouldSubscribe,\n        });\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(options.query, 12) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        process.env.NODE_ENV === \"production\" ? invariant(options.query.kind === 'Document', 13) : invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.returnPartialData, 14) : invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.pollInterval, 15) : invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');\n        return new Promise(function (resolve, reject) {\n            var watchedQuery = _this.watchQuery(options, false);\n            _this.fetchQueryRejectFns.set(\"query:\" + watchedQuery.queryId, reject);\n            watchedQuery\n                .result()\n                .then(resolve, reject)\n                .then(function () {\n                return _this.fetchQueryRejectFns.delete(\"query:\" + watchedQuery.queryId);\n            });\n        });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.idCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        this.stopPollingQuery(queryId);\n        this.queryStore.stopQuery(queryId);\n        this.invalidate(queryId);\n    };\n    QueryManager.prototype.addQueryListener = function (queryId, listener) {\n        this.setQuery(queryId, function (_a) {\n            var listeners = _a.listeners;\n            listeners.add(listener);\n            return { invalidated: false };\n        });\n    };\n    QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {\n        var _this = this;\n        var cancel = this.getQuery(queryId).cancel;\n        if (cancel)\n            cancel();\n        var previousResult = function () {\n            var previousResult = null;\n            var observableQuery = _this.getQuery(queryId).observableQuery;\n            if (observableQuery) {\n                var lastResult = observableQuery.getLastResult();\n                if (lastResult) {\n                    previousResult = lastResult.data;\n                }\n            }\n            return previousResult;\n        };\n        return this.dataStore.getCache().watch({\n            query: document,\n            variables: options.variables,\n            optimistic: true,\n            previousResult: previousResult,\n            callback: function (newData) {\n                _this.setQuery(queryId, function () { return ({ invalidated: true, newData: newData }); });\n            },\n        });\n    };\n    QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {\n        this.setQuery(queryId, function () { return ({ observableQuery: observableQuery }); });\n    };\n    QueryManager.prototype.removeObservableQuery = function (queryId) {\n        var cancel = this.getQuery(queryId).cancel;\n        this.setQuery(queryId, function () { return ({ observableQuery: null }); });\n        if (cancel)\n            cancel();\n    };\n    QueryManager.prototype.clearStore = function () {\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(16) : new InvariantError('Store reset while query was in flight (not completed in link chain)'));\n        });\n        var resetIds = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery)\n                resetIds.push(queryId);\n        });\n        this.queryStore.reset(resetIds);\n        this.mutationStore.reset();\n        return this.dataStore.reset();\n    };\n    QueryManager.prototype.resetStore = function () {\n        var _this = this;\n        return this.clearStore().then(function () {\n            return _this.reFetchObservableQueries();\n        });\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery) {\n                var fetchPolicy = observableQuery.options.fetchPolicy;\n                observableQuery.resetLastResults();\n                if (fetchPolicy !== 'cache-only' &&\n                    (includeStandby || fetchPolicy !== 'standby')) {\n                    observableQueryPromises.push(observableQuery.refetch());\n                }\n                _this.setQuery(queryId, function () { return ({ newData: null }); });\n                _this.invalidate(queryId);\n            }\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.observeQuery = function (queryId, options, observer) {\n        this.addQueryListener(queryId, this.queryListenerForObserver(queryId, options, observer));\n        return this.fetchQuery(queryId, options);\n    };\n    QueryManager.prototype.startQuery = function (queryId, options, listener) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"The QueryManager.startQuery method has been deprecated\");\n        this.addQueryListener(queryId, listener);\n        this.fetchQuery(queryId, options)\n            .catch(function () { return undefined; });\n        return queryId;\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables;\n        query = this.transform(query).document;\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, {}, variables, false).map(function (result) {\n                if (!fetchPolicy || fetchPolicy !== 'no-cache') {\n                    _this.dataStore.markSubscriptionResult(result, query, variables);\n                    _this.broadcastQueries();\n                }\n                if (graphQLResultHasError(result)) {\n                    throw new ApolloError({\n                        graphQLErrors: result.errors,\n                    });\n                }\n                return result;\n            });\n        };\n        if (this.transform(query).hasClientExports) {\n            var observablePromise_1 = this.localState.addExportedVariables(query, variables).then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        this.fetchQueryRejectFns.delete(\"query:\" + queryId);\n        this.fetchQueryRejectFns.delete(\"fetchRequest:\" + queryId);\n        this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });\n        this.queries.delete(queryId);\n    };\n    QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {\n        if (optimistic === void 0) { optimistic = true; }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query, fetchPolicy = _a.fetchPolicy, returnPartialData = _a.returnPartialData;\n        var lastResult = observableQuery.getLastResult();\n        var newData = this.getQuery(observableQuery.queryId).newData;\n        if (newData && newData.complete) {\n            return { data: newData.result, partial: false };\n        }\n        if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {\n            return { data: undefined, partial: false };\n        }\n        var _b = this.dataStore.getCache().diff({\n            query: query,\n            variables: variables,\n            previousResult: lastResult ? lastResult.data : undefined,\n            returnPartialData: true,\n            optimistic: optimistic,\n        }), result = _b.result, complete = _b.complete;\n        return {\n            data: (complete || returnPartialData) ? result : void 0,\n            partial: !complete,\n        };\n    };\n    QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {\n        var observableQuery;\n        if (typeof queryIdOrObservable === 'string') {\n            var foundObserveableQuery = this.getQuery(queryIdOrObservable).observableQuery;\n            process.env.NODE_ENV === \"production\" ? invariant(foundObserveableQuery, 17) : invariant(foundObserveableQuery, \"ObservableQuery with this id doesn't exist: \" + queryIdOrObservable);\n            observableQuery = foundObserveableQuery;\n        }\n        else {\n            observableQuery = queryIdOrObservable;\n        }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query;\n        return {\n            previousResult: this.getCurrentQueryResult(observableQuery, false).data,\n            variables: variables,\n            document: query,\n        };\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        var _this = this;\n        this.onBroadcast();\n        this.queries.forEach(function (info, id) {\n            if (info.invalidated) {\n                info.listeners.forEach(function (listener) {\n                    if (listener) {\n                        listener(_this.queryStore.get(id), info.newData);\n                    }\n                });\n            }\n        });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n        var _this = this;\n        if (deduplication === void 0) { deduplication = this.queryDeduplication; }\n        var observable;\n        var serverQuery = this.transform(query).serverQuery;\n        if (serverQuery) {\n            var _a = this, inFlightLinkObservables_1 = _a.inFlightLinkObservables, link = _a.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n            };\n            context = operation.context;\n            if (deduplication) {\n                var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();\n                inFlightLinkObservables_1.set(serverQuery, byVariables_1);\n                var varJson_1 = JSON.stringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    byVariables_1.set(varJson_1, observable = multiplex(execute(link, operation)));\n                    var cleanup = function () {\n                        byVariables_1.delete(varJson_1);\n                        if (!byVariables_1.size)\n                            inFlightLinkObservables_1.delete(serverQuery);\n                        cleanupSub_1.unsubscribe();\n                    };\n                    var cleanupSub_1 = observable.subscribe({\n                        next: cleanup,\n                        error: cleanup,\n                        complete: cleanup,\n                    });\n                }\n            }\n            else {\n                observable = multiplex(execute(link, operation));\n            }\n        }\n        else {\n            observable = Observable.of({ data: {} });\n            context = this.prepareContext(context);\n        }\n        var clientQuery = this.transform(query).clientQuery;\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.fetchRequest = function (_a) {\n        var _this = this;\n        var requestId = _a.requestId, queryId = _a.queryId, document = _a.document, options = _a.options, fetchMoreForQueryId = _a.fetchMoreForQueryId;\n        var variables = options.variables, _b = options.errorPolicy, errorPolicy = _b === void 0 ? 'none' : _b, fetchPolicy = options.fetchPolicy;\n        var resultFromStore;\n        var errorsFromStore;\n        return new Promise(function (resolve, reject) {\n            var observable = _this.getObservableFromLink(document, options.context, variables);\n            var fqrfId = \"fetchRequest:\" + queryId;\n            _this.fetchQueryRejectFns.set(fqrfId, reject);\n            var cleanup = function () {\n                _this.fetchQueryRejectFns.delete(fqrfId);\n                _this.setQuery(queryId, function (_a) {\n                    var subscriptions = _a.subscriptions;\n                    subscriptions.delete(subscription);\n                });\n            };\n            var subscription = observable.map(function (result) {\n                if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                    _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);\n                    _this.invalidate(queryId);\n                    _this.invalidate(fetchMoreForQueryId);\n                    _this.broadcastQueries();\n                }\n                if (errorPolicy === 'none' && isNonEmptyArray(result.errors)) {\n                    return reject(new ApolloError({\n                        graphQLErrors: result.errors,\n                    }));\n                }\n                if (errorPolicy === 'all') {\n                    errorsFromStore = result.errors;\n                }\n                if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {\n                    resultFromStore = result.data;\n                }\n                else {\n                    var _a = _this.dataStore.getCache().diff({\n                        variables: variables,\n                        query: document,\n                        optimistic: false,\n                        returnPartialData: true,\n                    }), result_1 = _a.result, complete = _a.complete;\n                    if (complete || options.returnPartialData) {\n                        resultFromStore = result_1;\n                    }\n                }\n            }).subscribe({\n                error: function (error) {\n                    cleanup();\n                    reject(error);\n                },\n                complete: function () {\n                    cleanup();\n                    resolve({\n                        data: resultFromStore,\n                        errors: errorsFromStore,\n                        loading: false,\n                        networkStatus: NetworkStatus.ready,\n                        stale: false,\n                    });\n                },\n            });\n            _this.setQuery(queryId, function (_a) {\n                var subscriptions = _a.subscriptions;\n                subscriptions.add(subscription);\n            });\n        });\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        return (this.queries.get(queryId) || {\n            listeners: new Set(),\n            invalidated: false,\n            document: null,\n            newData: null,\n            lastRequestId: 1,\n            observableQuery: null,\n            subscriptions: new Set(),\n        });\n    };\n    QueryManager.prototype.setQuery = function (queryId, updater) {\n        var prev = this.getQuery(queryId);\n        var newInfo = __assign(__assign({}, prev), updater(prev));\n        this.queries.set(queryId, newInfo);\n    };\n    QueryManager.prototype.invalidate = function (queryId, invalidated) {\n        if (invalidated === void 0) { invalidated = true; }\n        if (queryId) {\n            this.setQuery(queryId, function () { return ({ invalidated: invalidated }); });\n        }\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign({}, newContext), { clientAwareness: this.clientAwareness });\n    };\n    QueryManager.prototype.checkInFlight = function (queryId) {\n        var query = this.queryStore.get(queryId);\n        return (query &&\n            query.networkStatus !== NetworkStatus.ready &&\n            query.networkStatus !== NetworkStatus.error);\n    };\n    QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n        var _this = this;\n        var pollInterval = options.pollInterval;\n        process.env.NODE_ENV === \"production\" ? invariant(pollInterval, 18) : invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');\n        if (!this.ssrMode) {\n            var info = this.pollingInfoByQueryId.get(queryId);\n            if (!info) {\n                this.pollingInfoByQueryId.set(queryId, (info = {}));\n            }\n            info.interval = pollInterval;\n            info.options = __assign(__assign({}, options), { fetchPolicy: 'network-only' });\n            var maybeFetch_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    if (_this.checkInFlight(queryId)) {\n                        poll_1();\n                    }\n                    else {\n                        _this.fetchQuery(queryId, info.options, FetchType.poll).then(poll_1, poll_1);\n                    }\n                }\n            };\n            var poll_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    clearTimeout(info.timeout);\n                    info.timeout = setTimeout(maybeFetch_1, info.interval);\n                }\n            };\n            if (listener) {\n                this.addQueryListener(queryId, listener);\n            }\n            poll_1();\n        }\n        return queryId;\n    };\n    QueryManager.prototype.stopPollingQuery = function (queryId) {\n        this.pollingInfoByQueryId.delete(queryId);\n    };\n    return QueryManager;\n}());\n\nvar DataStore = (function () {\n    function DataStore(initialCache) {\n        this.cache = initialCache;\n    }\n    DataStore.prototype.getCache = function () {\n        return this.cache;\n    };\n    DataStore.prototype.markQueryResult = function (result, document, variables, fetchMoreForQueryId, ignoreErrors) {\n        if (ignoreErrors === void 0) { ignoreErrors = false; }\n        var writeWithErrors = !graphQLResultHasError(result);\n        if (ignoreErrors && graphQLResultHasError(result) && result.data) {\n            writeWithErrors = true;\n        }\n        if (!fetchMoreForQueryId && writeWithErrors) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_QUERY',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markSubscriptionResult = function (result, document, variables) {\n        if (!graphQLResultHasError(result)) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_SUBSCRIPTION',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markMutationInit = function (mutation) {\n        var _this = this;\n        if (mutation.optimisticResponse) {\n            var optimistic_1;\n            if (typeof mutation.optimisticResponse === 'function') {\n                optimistic_1 = mutation.optimisticResponse(mutation.variables);\n            }\n            else {\n                optimistic_1 = mutation.optimisticResponse;\n            }\n            this.cache.recordOptimisticTransaction(function (c) {\n                var orig = _this.cache;\n                _this.cache = c;\n                try {\n                    _this.markMutationResult({\n                        mutationId: mutation.mutationId,\n                        result: { data: optimistic_1 },\n                        document: mutation.document,\n                        variables: mutation.variables,\n                        updateQueries: mutation.updateQueries,\n                        update: mutation.update,\n                    });\n                }\n                finally {\n                    _this.cache = orig;\n                }\n            }, mutation.mutationId);\n        }\n    };\n    DataStore.prototype.markMutationResult = function (mutation) {\n        var _this = this;\n        if (!graphQLResultHasError(mutation.result)) {\n            var cacheWrites_1 = [{\n                    result: mutation.result.data,\n                    dataId: 'ROOT_MUTATION',\n                    query: mutation.document,\n                    variables: mutation.variables,\n                }];\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                Object.keys(updateQueries_1).forEach(function (id) {\n                    var _a = updateQueries_1[id], query = _a.query, updater = _a.updater;\n                    var _b = _this.cache.diff({\n                        query: query.document,\n                        variables: query.variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _b.result, complete = _b.complete;\n                    if (complete) {\n                        var nextQueryResult = tryFunctionOrLogError(function () {\n                            return updater(currentQueryResult, {\n                                mutationResult: mutation.result,\n                                queryName: getOperationName(query.document) || undefined,\n                                queryVariables: query.variables,\n                            });\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites_1.push({\n                                result: nextQueryResult,\n                                dataId: 'ROOT_QUERY',\n                                query: query.document,\n                                variables: query.variables,\n                            });\n                        }\n                    }\n                });\n            }\n            this.cache.performTransaction(function (c) {\n                cacheWrites_1.forEach(function (write) { return c.write(write); });\n                var update = mutation.update;\n                if (update) {\n                    tryFunctionOrLogError(function () { return update(c, mutation.result); });\n                }\n            });\n        }\n    };\n    DataStore.prototype.markMutationComplete = function (_a) {\n        var mutationId = _a.mutationId, optimisticResponse = _a.optimisticResponse;\n        if (optimisticResponse) {\n            this.cache.removeOptimistic(mutationId);\n        }\n    };\n    DataStore.prototype.markUpdateQueryResult = function (document, variables, newResult) {\n        this.cache.write({\n            result: newResult,\n            dataId: 'ROOT_QUERY',\n            variables: variables,\n            query: document,\n        });\n    };\n    DataStore.prototype.reset = function () {\n        return this.cache.reset();\n    };\n    return DataStore;\n}());\n\nvar version = \"2.6.10\";\n\nvar hasSuggestedDevtools = false;\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.defaultOptions = {};\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        var cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? false : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;\n        var link = options.link;\n        if (!link && resolvers) {\n            link = ApolloLink.empty();\n        }\n        if (!link || !cache) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(4) : new InvariantError(\"In order to initialize Apollo Client, you must specify 'link' and 'cache' properties in the options object.\\n\" +\n                \"These options are part of the upgrade requirements when migrating from Apollo Client 1.x to Apollo Client 2.x.\\n\" +\n                \"For more information, please visit: https://www.apollographql.com/docs/tutorial/client.html#apollo-client-setup\");\n        }\n        this.link = link;\n        this.cache = cache;\n        this.store = new DataStore(cache);\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || {};\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        var defaultConnectToDevTools = process.env.NODE_ENV !== 'production' &&\n            typeof window !== 'undefined' &&\n            !window.__APOLLO_CLIENT__;\n        if (typeof connectToDevTools === 'undefined'\n            ? defaultConnectToDevTools\n            : connectToDevTools && typeof window !== 'undefined') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self) {\n                if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n                    if (window.navigator &&\n                        window.navigator.userAgent &&\n                        window.navigator.userAgent.indexOf('Chrome') > -1) {\n                        console.debug('Download the Apollo DevTools ' +\n                            'for a better development experience: ' +\n                            'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n                    }\n                }\n            }\n        }\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            link: this.link,\n            store: this.store,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: function () {\n                if (_this.devToolsHookCb) {\n                    _this.devToolsHookCb({\n                        action: {},\n                        state: {\n                            queries: _this.queryManager.queryStore.getStore(),\n                            mutations: _this.queryManager.mutationStore.getStore(),\n                        },\n                        dataWithOptimisticResults: _this.cache.extract(true),\n                    });\n                }\n            },\n        });\n    }\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = __assign(__assign({}, this.defaultOptions.watchQuery), options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = __assign(__assign({}, this.defaultOptions.query), options);\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'cache-and-network', 5) : invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +\n            'client.query can only return a single result. Please use client.watchQuery ' +\n            'to receive multiple results from the cache and the network, or consider ' +\n            'using a different fetchPolicy, such as cache-first or network-only.');\n        if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = __assign(__assign({}, this.defaultOptions.mutate), options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    ApolloClient.prototype.writeQuery = function (options) {\n        var result = this.cache.writeQuery(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        var result = this.cache.writeFragment(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeData = function (options) {\n        var result = this.cache.writeData(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    ApolloClient.prototype.initQueryManager = function () {\n        process.env.NODE_ENV === \"production\" || invariant.warn('Calling the initQueryManager method is no longer necessary, ' +\n            'and it will be removed from ApolloClient in version 3.0.');\n        return this.queryManager;\n    };\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    return ApolloClient;\n}());\n\nexport default ApolloClient;\nexport { ApolloClient, ApolloError, FetchType, NetworkStatus, ObservableQuery, isApolloError };\n//# sourceMappingURL=bundle.esm.js.map\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n","/* global window */\nimport ponyfill from './ponyfill.js';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\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","import { __assign } from 'tslib';\nimport { print } from 'graphql/language/printer';\nimport { InvariantError } from 'ts-invariant';\n\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n};\nvar defaultHeaders = {\n    accept: '*/*',\n    'content-type': 'application/json',\n};\nvar defaultOptions = {\n    method: 'POST',\n};\nvar fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nvar throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = 'ServerError';\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\nvar parseAndCheckHttpResponse = function (operations) { return function (response) {\n    return (response\n        .text()\n        .then(function (bodyText) {\n        try {\n            return JSON.parse(bodyText);\n        }\n        catch (err) {\n            var parseError = err;\n            parseError.name = 'ServerParseError';\n            parseError.response = response;\n            parseError.statusCode = response.status;\n            parseError.bodyText = bodyText;\n            return Promise.reject(parseError);\n        }\n    })\n        .then(function (result) {\n        if (response.status >= 300) {\n            throwServerError(response, result, \"Response not successful: Received status code \" + response.status);\n        }\n        if (!Array.isArray(result) &&\n            !result.hasOwnProperty('data') &&\n            !result.hasOwnProperty('errors')) {\n            throwServerError(response, result, \"Server response was missing for query '\" + (Array.isArray(operations)\n                ? operations.map(function (op) { return op.operationName; })\n                : operations.operationName) + \"'.\");\n        }\n        return result;\n    }));\n}; };\nvar checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === 'undefined') {\n        var library = 'unfetch';\n        if (typeof window === 'undefined')\n            library = 'node-fetch';\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError(\"\\nfetch is not found globally and no fetcher passed, to fix pass a fetch for\\nyour environment like https://www.npmjs.com/package/\" + library + \".\\n\\nFor example:\\nimport fetch from '\" + library + \"';\\nimport { createHttpLink } from 'apollo-link-http';\\n\\nconst link = createHttpLink({ uri: '/graphql', fetch: fetch });\");\n    }\n};\nvar createSignalIfSupported = function () {\n    if (typeof AbortController === 'undefined')\n        return { controller: false, signal: false };\n    var controller = new AbortController();\n    var signal = controller.signal;\n    return { controller: controller, signal: signal };\n};\nvar selectHttpOptionsAndBody = function (operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = __assign({}, fallbackConfig.options, { headers: fallbackConfig.headers, credentials: fallbackConfig.credentials });\n    var http = fallbackConfig.http;\n    configs.forEach(function (config) {\n        options = __assign({}, options, config.options, { headers: __assign({}, options.headers, config.headers) });\n        if (config.credentials)\n            options.credentials = config.credentials;\n        http = __assign({}, http, config.http);\n    });\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    if (http.includeQuery)\n        body.query = print(query);\n    return {\n        options: options,\n        body: body,\n    };\n};\nvar serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"Network request failed. \" + label + \" is not serializable: \" + e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\nvar selectURI = function (operation, fallbackURI) {\n    var context = operation.getContext();\n    var contextURI = context.uri;\n    if (contextURI) {\n        return contextURI;\n    }\n    else if (typeof fallbackURI === 'function') {\n        return fallbackURI(operation);\n    }\n    else {\n        return fallbackURI || '/graphql';\n    }\n};\n\nexport { checkFetcher, createSignalIfSupported, fallbackHttpConfig, parseAndCheckHttpResponse, selectHttpOptionsAndBody, selectURI, serializeFetchParameter, throwServerError };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __rest, __assign, __extends } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, createSignalIfSupported, serializeFetchParameter, parseAndCheckHttpResponse } from 'apollo-link-http-common';\n\nvar createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, fetcher = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"includeExtensions\", \"useGETForQueries\"]);\n    checkFetcher(fetcher);\n    if (!fetcher) {\n        fetcher = fetch;\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders['apollographql-client-name'] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders['apollographql-client-version'] = version;\n            }\n        }\n        var contextHeaders = __assign({}, clientAwarenessHeaders, context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        var controller;\n        if (!options.signal) {\n            var _c = createSignalIfSupported(), _controller = _c.controller, signal = _c.signal;\n            controller = _controller;\n            if (controller)\n                options.signal = signal;\n        }\n        var definitionIsMutation = function (d) {\n            return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n        };\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = 'GET';\n        }\n        if (options.method === 'GET') {\n            var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, 'Payload');\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            fetcher(chosenURI, options)\n                .then(function (response) {\n                operation.setContext({ response: response });\n                return response;\n            })\n                .then(parseAndCheckHttpResponse(operation))\n                .then(function (result) {\n                observer.next(result);\n                observer.complete();\n                return result;\n            })\n                .catch(function (err) {\n                if (err.name === 'AbortError')\n                    return;\n                if (err.result && err.result.errors && err.result.data) {\n                    observer.next(err.result);\n                }\n                observer.error(err);\n            });\n            return function () {\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\nfunction rewriteURIForGET(chosenURI, body) {\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(key + \"=\" + encodeURIComponent(value));\n    };\n    if ('query' in body) {\n        addQueryParam('query', body.query);\n    }\n    if (body.operationName) {\n        addQueryParam('operationName', body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('variables', serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('extensions', serializedExtensions);\n    }\n    var fragment = '', preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf('#');\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n    var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n    return { newURI: newURI };\n}\nvar HttpLink = (function (_super) {\n    __extends(HttpLink, _super);\n    function HttpLink(opts) {\n        return _super.call(this, createHttpLink(opts).request) || this;\n    }\n    return HttpLink;\n}(ApolloLink));\n\nexport { HttpLink, createHttpLink };\n//# sourceMappingURL=bundle.esm.js.map\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","import Observable from 'zen-observable-ts';\nexport { default as Observable } from 'zen-observable-ts';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { __extends, __assign } from 'tslib';\nimport { getOperationName } from 'apollo-utilities';\nexport { getOperationName } from 'apollo-utilities';\n\nfunction validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        'query',\n        'operationName',\n        'variables',\n        'extensions',\n        'context',\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"illegal argument: \" + key);\n        }\n    }\n    return operation;\n}\nvar LinkError = (function (_super) {\n    __extends(LinkError, _super);\n    function LinkError(message, link) {\n        var _this = _super.call(this, message) || this;\n        _this.link = link;\n        return _this;\n    }\n    return LinkError;\n}(Error));\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nfunction toPromise(observable) {\n    var completed = false;\n    return new Promise(function (resolve, reject) {\n        observable.subscribe({\n            next: function (data) {\n                if (completed) {\n                    process.env.NODE_ENV === \"production\" || invariant.warn(\"Promise Wrapper does not support multiple results from Observable\");\n                }\n                else {\n                    completed = true;\n                    resolve(data);\n                }\n            },\n            error: reject,\n        });\n    });\n}\nvar makePromise = toPromise;\nfunction fromPromise(promise) {\n    return new Observable(function (observer) {\n        promise\n            .then(function (value) {\n            observer.next(value);\n            observer.complete();\n        })\n            .catch(observer.error.bind(observer));\n    });\n}\nfunction fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\nfunction transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\n    };\n    if (!transformedOperation.operationName) {\n        transformedOperation.operationName =\n            typeof transformedOperation.query !== 'string'\n                ? getOperationName(transformedOperation.query)\n                : '';\n    }\n    return transformedOperation;\n}\nfunction createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === 'function') {\n            context = __assign({}, context, next(context));\n        }\n        else {\n            context = __assign({}, context, next);\n        }\n    };\n    var getContext = function () { return (__assign({}, context)); };\n    Object.defineProperty(operation, 'setContext', {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, 'getContext', {\n        enumerable: false,\n        value: getContext,\n    });\n    Object.defineProperty(operation, 'toKey', {\n        enumerable: false,\n        value: function () { return getKey(operation); },\n    });\n    return operation;\n}\nfunction getKey(operation) {\n    var query = operation.query, variables = operation.variables, operationName = operation.operationName;\n    return JSON.stringify([operationName, query, variables]);\n}\n\nfunction passthrough(op, forward) {\n    return forward ? forward(op) : Observable.of();\n}\nfunction toLink(handler) {\n    return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\nfunction empty() {\n    return new ApolloLink(function () { return Observable.of(); });\n}\nfunction from(links) {\n    if (links.length === 0)\n        return empty();\n    return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n}\nfunction split(test, left, right) {\n    var leftLink = toLink(left);\n    var rightLink = toLink(right || new ApolloLink(passthrough));\n    if (isTerminating(leftLink) && isTerminating(rightLink)) {\n        return new ApolloLink(function (operation) {\n            return test(operation)\n                ? leftLink.request(operation) || Observable.of()\n                : rightLink.request(operation) || Observable.of();\n        });\n    }\n    else {\n        return new ApolloLink(function (operation, forward) {\n            return test(operation)\n                ? leftLink.request(operation, forward) || Observable.of()\n                : rightLink.request(operation, forward) || Observable.of();\n        });\n    }\n}\nvar concat = function (first, second) {\n    var firstLink = toLink(first);\n    if (isTerminating(firstLink)) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(new LinkError(\"You are calling concat on a terminating link, which will have no effect\", firstLink));\n        return firstLink;\n    }\n    var nextLink = toLink(second);\n    if (isTerminating(nextLink)) {\n        return new ApolloLink(function (operation) {\n            return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n        });\n    }\n    else {\n        return new ApolloLink(function (operation, forward) {\n            return (firstLink.request(operation, function (op) {\n                return nextLink.request(op, forward) || Observable.of();\n            }) || Observable.of());\n        });\n    }\n};\nvar ApolloLink = (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('request is not implemented');\n    };\n    ApolloLink.empty = empty;\n    ApolloLink.from = from;\n    ApolloLink.split = split;\n    ApolloLink.execute = execute;\n    return ApolloLink;\n}());\nfunction execute(link, operation) {\n    return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n}\n\nexport { ApolloLink, concat, createOperation, empty, execute, from, fromError, fromPromise, makePromise, split, toPromise };\n//# sourceMappingURL=bundle.esm.js.map\n","import zenObservable from 'zen-observable';\n\nvar Observable = zenObservable;\n\nexport default Observable;\nexport { Observable };\n//# sourceMappingURL=bundle.esm.js.map\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","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","var _a = Object.prototype, toString = _a.toString, hasOwnProperty = _a.hasOwnProperty;\r\nvar previousComparisons = new Map();\r\n/**\r\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\r\n */\r\nfunction equal(a, b) {\r\n    try {\r\n        return check(a, b);\r\n    }\r\n    finally {\r\n        previousComparisons.clear();\r\n    }\r\n}\r\nfunction check(a, b) {\r\n    // If the two values are strictly equal, our job is easy.\r\n    if (a === b) {\r\n        return true;\r\n    }\r\n    // Object.prototype.toString returns a representation of the runtime type of\r\n    // the given value that is considerably more precise than typeof.\r\n    var aTag = toString.call(a);\r\n    var bTag = toString.call(b);\r\n    // If the runtime types of a and b are different, they could maybe be equal\r\n    // under some interpretation of equality, but for simplicity and performance\r\n    // we just return false instead.\r\n    if (aTag !== bTag) {\r\n        return false;\r\n    }\r\n    switch (aTag) {\r\n        case '[object Array]':\r\n            // Arrays are a lot like other objects, but we can cheaply compare their\r\n            // lengths as a short-cut before comparing their elements.\r\n            if (a.length !== b.length)\r\n                return false;\r\n        // Fall through to object case...\r\n        case '[object Object]': {\r\n            if (previouslyCompared(a, b))\r\n                return true;\r\n            var aKeys = Object.keys(a);\r\n            var bKeys = Object.keys(b);\r\n            // If `a` and `b` have a different number of enumerable keys, they\r\n            // must be different.\r\n            var keyCount = aKeys.length;\r\n            if (keyCount !== bKeys.length)\r\n                return false;\r\n            // Now make sure they have the same keys.\r\n            for (var k = 0; k < keyCount; ++k) {\r\n                if (!hasOwnProperty.call(b, aKeys[k])) {\r\n                    return false;\r\n                }\r\n            }\r\n            // Finally, check deep equality of all child properties.\r\n            for (var k = 0; k < keyCount; ++k) {\r\n                var key = aKeys[k];\r\n                if (!check(a[key], b[key])) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n        case '[object Error]':\r\n            return a.name === b.name && a.message === b.message;\r\n        case '[object Number]':\r\n            // Handle NaN, which is !== itself.\r\n            if (a !== a)\r\n                return b !== b;\r\n        // Fall through to shared +a === +b case...\r\n        case '[object Boolean]':\r\n        case '[object Date]':\r\n            return +a === +b;\r\n        case '[object RegExp]':\r\n        case '[object String]':\r\n            return a == \"\" + b;\r\n        case '[object Map]':\r\n        case '[object Set]': {\r\n            if (a.size !== b.size)\r\n                return false;\r\n            if (previouslyCompared(a, b))\r\n                return true;\r\n            var aIterator = a.entries();\r\n            var isMap = aTag === '[object Map]';\r\n            while (true) {\r\n                var info = aIterator.next();\r\n                if (info.done)\r\n                    break;\r\n                // If a instanceof Set, aValue === aKey.\r\n                var _a = info.value, aKey = _a[0], aValue = _a[1];\r\n                // So this works the same way for both Set and Map.\r\n                if (!b.has(aKey)) {\r\n                    return false;\r\n                }\r\n                // However, we care about deep equality of values only when dealing\r\n                // with Map structures.\r\n                if (isMap && !check(aValue, b.get(aKey))) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n    }\r\n    // Otherwise the values are not equal.\r\n    return false;\r\n}\r\nfunction previouslyCompared(a, b) {\r\n    // Though cyclic references can make an object graph appear infinite from the\r\n    // perspective of a depth-first traversal, the graph still contains a finite\r\n    // number of distinct object references. We use the previousComparisons cache\r\n    // to avoid comparing the same pair of object references more than once, which\r\n    // guarantees termination (even if we end up comparing every object in one\r\n    // graph to every object in the other graph, which is extremely unlikely),\r\n    // while still allowing weird isomorphic structures (like rings with different\r\n    // lengths) a chance to pass the equality test.\r\n    var bSet = previousComparisons.get(a);\r\n    if (bSet) {\r\n        // Return true here because we can be sure false will be returned somewhere\r\n        // else if the objects are not equivalent.\r\n        if (bSet.has(b))\r\n            return true;\r\n    }\r\n    else {\r\n        previousComparisons.set(a, bSet = new Set);\r\n    }\r\n    bSet.add(b);\r\n    return false;\r\n}\n\nexport default equal;\nexport { equal };\n//# sourceMappingURL=equality.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","export default function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}","import _typeof from \"./typeof.js\";\nexport default function toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : String(i);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}"],"names":["genericMessage","_a","Object","setPrototypeOf","obj","proto","__proto__","InvariantError","_super","message","_this","call","this","framesToPop","name","prototype","Error","invariant","condition","wrapConsoleMethod","method","console","apply","arguments","warn","error","processStub","env","process","Function","atLeastWeTried","NetworkStatus","isNetworkRequestInFlight","networkStatus","Observable","isNonEmptyArray","value","Array","isArray","length","isApolloError","err","hasOwnProperty","FetchType","generateErrorMessage","graphQLErrors","forEach","graphQLError","errorMessage","networkError","replace","ApolloError","extraInfo","hasError","storeValue","policy","ObservableQuery","queryManager","options","_b","shouldSubscribe","observer","onSubscribe","observers","Set","subscriptions","isTornDown","variables","queryId","generateQueryId","opDef","query","queryName","result","Promise","resolve","reject","next","delete","size","removeQuery","setTimeout","subscription","unsubscribe","subscribe","currentResult","getCurrentResult","undefined","data","lastResult","lastError","loading","getCurrentQueryResult","partial","queryStoreValue","queryStore","get","fetchPolicy","isNetworkFetchPolicy","errorPolicy","errors","ready","updateLastResult","stale","isDifferentFromLastResult","newResult","snapshot","lastResultSnapshot","getLastResult","getLastError","resetLastResults","resetQueryStoreErrors","refetch","fetchQuery","fetchMore","fetchMoreOptions","updateQuery","combinedOptions","qid","normal","then","fetchMoreResult","previousResult","stopQuery","subscribeToMore","startGraphQLSubscription","document","subscriptionData","previous","onError","add","setOptions","opts","oldFetchPolicy","pollInterval","startPolling","stopPolling","setVariables","fetchResults","tryFetch","mapFn","getQueryWithPreviousResult","dataStore","markUpdateQueryResult","broadcastQueries","stopPollingQuery","assertNotCacheFirstOrOnly","startPollingQuery","assumeImmutableResults","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","setUpQuery","tearDownQuery","addObservableQuery","iterateObserversSafely","observeQuery","previousResult_1","query_1","fetchPolicy_1","transform","hasClientExports","getLocalState","addExportedVariables","previousVariables","serverQuery","catch","sub","clear","removeObservableQuery","argument","observersWithMethod","obs","push","obsQuery","MutationStore","store","getStore","mutationId","initMutation","mutation","markMutationError","markMutationResult","reset","QueryStore","initQuery","previousQuery","isSetVariables","storePreviousVariables","isPoll","poll","isRefetch","metadata","fetchMoreForQueryId","markQueryResult","markQueryError","markQueryResultClient","complete","observableQueryIds","keys","indexOf","capitalizeFirstLetter","str","charAt","toUpperCase","slice","LocalState","cache","client","resolvers","fragmentMatcher","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","context","onlyRunForcedResolvers","_c","resolveDocument","localResult","getFragmentMatcher","clientQuery","prepareContext","newContext","getCacheKey","config","dataIdFromObject","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","Directive","enter","node","some","arg","kind","diff","returnPartialData","optimistic","rootValue","mainDefinition","fragments","fragmentMap","definitionOperation","defaultOperationType","execContext","operation","resolveSelectionSet","selectionSet","resultsToMerge","execute","selection","fragment","typeCondition","resolveField","fieldResult","fragmentResult","all","selections","map","field","fieldName","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","__typename","directives","directive","resolveSubSelectedArray","item","multiplex","inner","asyncMap","observable","activeNextCount","completed","handler","e","QueryManager","link","queryDeduplication","onBroadcast","_d","ssrMode","_e","clientAwareness","localState","mutationStore","idCounter","queries","Map","fetchQueryRejectFns","transformCache","WeakMap","inFlightLinkObservables","pollingInfoByQueryId","getCache","stop","_info","stopQueryNoBroadcast","mutate","optimisticResponse","updateQueriesByName","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","update","generateUpdateQueriesInfo","self","_f","label","setQuery","getVariables","sent","ret","observableQuery","updater","markMutationInit","storeResult","getObservableFromLink","markMutationComplete","refetchQueryPromises","refetchQuery","queryOptions","fetchType","isNetworkOnly","needToFetch","shouldFetch","requestId","cancel","networkResult","updateQueryWatch","lastRequestId","invalidated","invalidate","fetchRequest","getQuery","hasForcedResolvers","newData","queryListenerForObserver","invoke","networkStatusChanged","shouldNotifyIfLoading","notifyOnNetworkStatusChange","hasGraphQLErrors","isMissing","errorStatusChanged","diffResult","resultFromStore","has","transformed","transformDocument","forLink","transformForLink","cacheEntry_1","defaultVars","doc","set","watchQuery","transformedOptions","watchedQuery","String","stopQueryInStore","stopQueryInStoreNoBroadcast","addQueryListener","listener","listeners","watch","callback","clearStore","resetIds","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","startQuery","makeObservable","markSubscriptionResult","observablePromise_1","x","queryIdOrObservable","foundObserveableQuery","info","id","deduplication","inFlightLinkObservables_1","operationName","forceFetch","byVariables_1","varJson_1","JSON","stringify","cleanup","cleanupSub_1","of","errorsFromStore","fqrfId","result_1","prev","newInfo","checkInFlight","interval","maybeFetch_1","poll_1","clearTimeout","timeout","DataStore","initialCache","ignoreErrors","writeWithErrors","write","dataId","optimistic_1","recordOptimisticTransaction","c","orig","cacheWrites_1","updateQueries_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","performTransaction","removeOptimistic","version","ApolloClient","defaultOptions","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","empty","disableNetworkFetches","bind","defaultConnectToDevTools","window","__APOLLO_CLIENT__","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","extract","readQuery","readFragment","writeQuery","writeFragment","writeData","__actionHookForDevTools","cb","__requestRaw","payload","initQueryManager","fn","onResetStore","filter","onClearStore","restore","serializedState","setLocalStateFragmentMatcher","symbolObservablePonyfill","root","Symbol","g","module","defaultHttpOptions","includeQuery","includeExtensions","defaultHeaders","accept","fallbackHttpConfig","http","headers","throwServerError","response","statusCode","status","parseAndCheckHttpResponse","operations","text","bodyText","parse","parseError","op","checkFetcher","fetcher","fetch","createSignalIfSupported","AbortController","controller","signal","selectHttpOptionsAndBody","fallbackConfig","configs","_i","credentials","extensions","body","serializeFetchParameter","p","serialized","selectURI","fallbackURI","getContext","contextURI","uri","createHttpLink","linkOptions","useGETForQueries","requestOptions","linkConfig","fetchOptions","chosenURI","clientAwarenessHeaders","name_1","contextHeaders","contextConfig","_controller","definitionIsMutation","d","definitions","rewriteURIForGET","newURI","setContext","abort","queryParams","addQueryParam","key","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","join","HttpLink","request","validateOperation","OPERATION_FIELDS","LinkError","isTerminating","fromError","errorValue","transformOperation","transformedOperation","createOperation","starting","defineProperty","enumerable","getKey","passthrough","forward","toLink","ApolloLink","from","links","reduce","y","concat","split","test","left","right","leftLink","rightLink","second","firstLink","nextLink","isStringValue","isBooleanValue","isIntValue","isFloatValue","isVariable","isObjectValue","isListValue","isEnumValue","isNullValue","valueToObjectRepresentation","argObj","Number","nestedArgObj_1","fields","variableValue","values","listValue","nestedArgArrayObj","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","args","filterKeys","sort","queryArgs_1","filteredArgs_1","completeFieldName","stringifiedArgs","argumentsObjectFromField","argObj_1","resultKeyNameFromField","alias","isField","isInlineFragment","isIdValue","idObject","type","generated","toIdValue","idConfig","typename","isJsonValue","jsonObject","getDirectiveInfoFromField","directiveObj_1","shouldInclude","getInclusionDirectives","every","ifArgument","evaledValue","getDirectiveNames","names","hasDirectives","isInclusionDirective","directiveArguments","ifValue","getFragmentQueryDocument","fragmentName","actualFragmentName","definition","target","sources","source","checkDocument","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","queryDef","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","getDefaultValues","variableDefinitions","defaultValues","defaultValue","variable","defaultValueObj","filterInPlace","array","elem","i","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","create","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","_key","parent","Field","shouldRemoveField","remove","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","v","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","skip","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","getArgumentMatcher","aConfig","argMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","def","FragmentDefinition","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","isTypenameOnly","canUseWeakMap","navigator","product","toString","cloneDeep","cloneDeepHelper","val","seen","copy_1","child","copy_2","getPrototypeOf","getEnv","isEnv","isProduction","isTest","tryFunctionOrLogError","f","graphQLResultHasError","mergeDeep","mergeDeepArray","count","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","previousComparisons","equal","a","b","check","aTag","bTag","previouslyCompared","aKeys","bKeys","keyCount","k","aIterator","entries","isMap","done","aKey","aValue","bSet","exports","cmp","cycles","aobj","bobj","toJSON","isFinite","out","TypeError","seenIndex","splice","_typeof","o","iterator","constructor","toPrimitive","t","r","toPropertyKey","_defineProperty","configurable","writable"],"sourceRoot":""}