{"version":3,"sources":["webpack:///./node_modules/apollo-client/bundle.esm.js"],"names":["NetworkStatus","isNetworkRequestInFlight","networkStatus","Observable","_super","apply","this","arguments","prototype","isNonEmptyArray","value","Array","isArray","length","isApolloError","err","hasOwnProperty","FetchType","generateErrorMessage","message","graphQLErrors","forEach","graphQLError","errorMessage","networkError","replace","ApolloError","_a","extraInfo","_this","call","__proto__","Error","hasError","storeValue","policy","ObservableQuery","queryManager","options","_b","shouldSubscribe","observer","onSubscribe","observers","Set","subscriptions","isTornDown","variables","queryId","generateQueryId","opDef","query","queryName","name","result","Promise","resolve","reject","next","delete","size","removeQuery","setTimeout","subscription","unsubscribe","error","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","method","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","Object","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","obj","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"],"mappings":"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","file":"js/npm.apollo-client~2977f88b.ce049127.js","sourcesContent":["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"],"sourceRoot":""}