{"version":3,"sources":["../../../node_modules/apollo-link-persisted-queries/lib/index.js","../../../node_modules/apollo-cache/lib/bundle.esm.js","../../../node_modules/apollo-cache-inmemory/node_modules/@wry/context/lib/context.esm.js","../../../node_modules/apollo-cache-inmemory/node_modules/optimism/lib/bundle.esm.js","../../../node_modules/apollo-cache-inmemory/lib/bundle.esm.js","../../../node_modules/apollo-link-batch/lib/bundle.esm.js","../../../node_modules/apollo-link-batch-http/lib/bundle.esm.js","../../../node_modules/apollo-link/lib/bundle.esm.js","../../../node_modules/apollo-link-http/lib/bundle.esm.js","../../../node_modules/apollo-link-error/lib/bundle.esm.js","../../../node_modules/apollo-link-retry/lib/bundle.esm.js","../../../node_modules/@wry/equality/lib/equality.esm.js","../../../node_modules/apollo-link-http-common/lib/bundle.esm.js","../../../node_modules/apollo-utilities/lib/bundle.esm.js","../../../node_modules/apollo-client/bundle.esm.js"],"names":["sha256","defaultOptions","generateHash","query","update","digest","disable","_a","graphQLErrors","operation","some","message","response","getContext","status","useGETForHashedQueries","definitionIsMutation","d","kind","hasOwnProperty","Object","prototype","hashesKeyString","hashesKey","Symbol","for","nextHashesChildKey","createPersistedQueryLink","options","assign","supportsPersistedQueries","hashesChildKey","getQueryHash","call","defineProperty","value","create","enumerable","hashes","forward","Error","hashError","extensions","persistedQuery","version","sha256Hash","e","observer","subscription","originalFetchOptions","retried","setFetchOptions","retry","cb","networkError","errors","disablePayload","undefined","unsubscribe","setContext","http","includeQuery","includeExtensions","fetchOptions","subscribe","handler","next","error","complete","bind","definitions","operationIsQuery","_b","method","queryFromPojo","obj","name","selectionSet","selectionSetFromObj","Array","isArray","selections","keys","forEach","key","field","push","Cache","justTypenameQuery","variableDefinitions","directives","alias","arguments","ApolloCache","transformDocument","document","transformForLink","readQuery","optimistic","this","read","variables","readFragment","fragment","fragmentName","rootId","id","writeQuery","write","dataId","result","data","writeFragment","writeData","typename","typenameResult","__typename","dataToWrite","typeCondition","currentContext","MISSING_VALUE","idCounter","globalKey","host","Slot","Date","now","Math","random","toString","slice","join","hasValue","context_1","parent","slots","getValue","withValue","callback","args","thisArg","__proto__","apply","context","saved","noContext","writable","configurable","defaultDispose","max","dispose","Infinity","map","Map","newest","oldest","has","get","entry","getEntry","older","newer","set","clean","size","delete","parentEntrySlot","reusableEmptyArray","emptySetPool","assert","condition","optionalMessage","valueGet","length","Entry","fn","parents","Set","childValues","dirtyChildren","dirty","recomputing","count","recompute","child","add","mightBeDirty","reportDirtyChild","reportCleanChild","rememberParent","maybeReportOrphan","originalChildren","forgetChildren","recomputeNewValue","maybeUnsubscribe","setDirty","maybeSubscribe","reportClean","setClean","reallyRecompute","reportDirty","_this","forgetChild","pop","childValue","a","b","len","valueIs","removeDirtyChild","dc","reportOrphan","children","_value","KeyTrie","weakness","lookup","array","_i","lookupArray","node","getChildTrie","isObjRef","weak","WeakMap","strong","keyTrie","defaultMakeCacheKey","caches","wrap","originalFunction","cache","pow","disposable","makeCacheKey","clear","haveWarned","shouldWarn","answer","HeuristicFragmentMatcher","ensureReady","Promise","resolve","canBypassInit","match","idValue","store","isRootQuery","hasOwn","IntrospectionFragmentMatcher","introspectionQueryResultData","possibleTypesMap","parseIntrospectionResult","isReady","implementingTypes","indexOf","introspectionResultData","typeMap","__schema","types","type","possibleTypes","implementingType","DepTrackingCache","depend","toObject","replace","newData","defaultNormalizedCacheFactory","seed","StoreReader","_c","cacheKeyRoot","_d","freezeResults","_e","executeStoreQuery","executeSelectionSet","executeSubSelectedArray","rootValue","contextValue","variableValues","fragmentMatcher","JSON","stringify","execContext","readQueryFromStore","diffQueryAgainstStore","returnPartialData","previousResult","fragmentMatcherFunction","config","queryDefinition","dataIdFromObject","cacheRedirects","execResult","generated","hasMissingFields","missing","info","tolerable","defaultFragmentMatcher","mainDefinition","fragments","fragmentMap","finalResult","objectsToMerge","object","handleMissing","selection","fieldResult","executeField","fragmentExecResult","readStoreResult","fieldName","resultKey","storeKeyName","fieldValue","resolver","getCacheKey","storeObj","json","readStoreResolver","combineExecResults","assertSelectionSetForIdValue","execResults","childResult","item","ObjectCache","_super","WriteError","StoreWriter","writeQueryToStore","writeResultToStore","operationDefinition","writeSelectionSetToStore","processedData","enhancedError","stack","enhanceErrorWithDocument","resultFieldKey","writeFieldToStore","isDefered","isClient","directive","matches","fakeContext","storeValue","storeObject","storeFieldName","generatedId","processArrayValue","valueDataId","isGeneratedId","semanticId","isDataProcessed","escapedId","hadTypename","hasTypename","typenameChanged","mergeWithGenerated","index","itemDataId","generatedKey","realKey","real","madeChanges","realValue","newRealValue","defaultConfig","defaultDataIdFromObject","addTypename","resultCaching","_id","hasOwn$1","OptimisticCacheLayer","optimisticId","transaction","InMemoryCache","watches","typenameDocumentCache","silenceBroadcast","customResolvers","cacheResolvers","optimisticData","storeWriter","storeReader","maybeBroadcastWatch","c","restore","extract","broadcastWatches","diff","watch","evict","reset","removeOptimistic","idToRemove","toReapply","removedCount","layer","layer_1","performTransaction","recordOptimisticTransaction","OperationBatcher","batchInterval","batchMax","batchHandler","batchKey","queuedRequests","enqueueRequest","request","requestCopy","queued","observable","scheduleQueueConsumption","consumeQueue","requestKey","requests","queuedRequest","forwards","observables","nexts","completes","batchableRequest","batchedObservable","of","onError","rejecters","results","setTimeout","BatchLink","fetchParams","batcher","BatchHttpLink","uri","fetcher","fetch","requestOptions","linkConfig","credentials","headers","contextConfig","operations","chosenURI","clientAwarenessHeaders","clientAwareness","name_1","controller","optsAndBody","loadedBody","body","parseError","signal","_controller","then","catch","err","abort","LinkError","link","isTerminating","toPromise","completed","reject","makePromise","fromPromise","promise","fromError","errorValue","createOperation","starting","operationName","getKey","passthrough","op","toLink","ApolloLink","empty","from","links","reduce","x","y","concat","split","test","left","right","leftLink","rightLink","first","second","firstLink","nextLink","execute","transformedOperation","transformOperation","OPERATION_FIELDS","validateOperation","createHttpLink","linkOptions","useGETForQueries","contextHeaders","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","rewriteURIForGET","HttpLink","opts","errorHandler","sub","retriedSub","retriedResult","ErrorLink","RetryableOperation","delayFor","retryIf","retryCount","values","canceled","observers","currentSubscription","onNext","onComplete","label","sent","scheduleRetry","every","o","cancel","start","try","clearTimeout","timerId","delay","RetryLink","attempts","delayOptions","initial","jitter","baseDelay","min","buildDelayFunction","retryOptions","buildRetryFunction","retryable","previousComparisons","equal","check","aTag","previouslyCompared","aKeys","bKeys","keyCount","k","aIterator","entries","isMap","done","aKey","aValue","bSet","fallbackHttpConfig","accept","throwServerError","statusCode","parseAndCheckHttpResponse","text","bodyText","parse","checkFetcher","window","createSignalIfSupported","AbortController","selectHttpOptionsAndBody","fallbackConfig","configs","serializeFetchParameter","p","serialized","selectURI","fallbackURI","contextURI","valueToObjectRepresentation","argObj","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","fields","isVariable","variableValue","isListValue","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","filterKeys","sort","queryArgs_1","filteredArgs_1","completeFieldName","stringifiedArgs","argumentsObjectFromField","argObj_1","resultKeyNameFromField","isField","isInlineFragment","isIdValue","idObject","toIdValue","idConfig","isJsonValue","jsonObject","getDirectiveInfoFromField","directiveObj_1","shouldInclude","filter","isInclusionDirective","directiveArguments","ifArgument","ifValue","evaledValue","hasDirectives","names","doc","Directive","getDirectiveNames","hasClientExports","getFragmentQueryDocument","actualFragmentName","definition","target","sources","source","checkDocument","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","queryDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","getDefaultValues","defaultValues","defaultValue","variable","defaultValueObj","filterInPlace","elem","i","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","fragmentDef","getFragmentDefinition","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","Field","remove","arg","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","v","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","removeArgumentsFromDocument","fs","def","FragmentDefinition","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","canUseWeakMap","navigator","product","cloneDeep","cloneDeepHelper","val","seen","copy_1","copy_2","getPrototypeOf","isEnv","env","process","isProduction","isTest","tryFunctionOrLogError","f","console","graphQLResultHasError","deepFreeze","freeze","getOwnPropertyNames","prop","isFrozen","maybeDeepFreeze","mergeDeep","mergeDeepArray","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","NetworkStatus","isNetworkRequestInFlight","networkStatus","Observable","isNonEmptyArray","FetchType","ApolloError","errorMessage","extraInfo","graphQLError","generateErrorMessage","ObservableQuery","queryManager","shouldSubscribe","onSubscribe","subscriptions","isTornDown","queryId","generateQueryId","opDef","queryName","removeQuery","currentResult","getCurrentResult","lastResult","lastError","loading","policy","getCurrentQueryResult","partial","queryStoreValue","queryStore","fetchPolicy","isNetworkFetchPolicy","errorPolicy","ready","updateLastResult","stale","isDifferentFromLastResult","newResult","snapshot","lastResultSnapshot","getLastResult","getLastError","resetLastResults","resetQueryStoreErrors","refetch","fetchQuery","fetchMore","fetchMoreOptions","updateQuery","combinedOptions","qid","normal","fetchMoreResult","stopQuery","subscribeToMore","startGraphQLSubscription","subscriptionData","previous","setOptions","oldFetchPolicy","pollInterval","startPolling","stopPolling","setVariables","fetchResults","tryFetch","mapFn","getQueryWithPreviousResult","dataStore","markUpdateQueryResult","broadcastQueries","stopPollingQuery","assertNotCacheFirstOrOnly","startPollingQuery","assumeImmutableResults","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","setUpQuery","tearDownQuery","addObservableQuery","iterateObserversSafely","observeQuery","previousResult_1","query_1","fetchPolicy_1","transform","getLocalState","addExportedVariables","previousVariables","serverQuery","removeObservableQuery","observersWithMethod","obs","obsQuery","MutationStore","getStore","mutationId","initMutation","mutation","markMutationError","markMutationResult","QueryStore","initQuery","previousQuery","isSetVariables","storePreviousVariables","isPoll","poll","isRefetch","metadata","fetchMoreForQueryId","markQueryResult","markQueryError","markQueryResultClient","observableQueryIds","LocalState","client","resolvers","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","resolveDocument","localResult","getFragmentMatcher","clientQuery","prepareContext","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","definitionOperation","defaultOperationType","str","charAt","toUpperCase","resolveSelectionSet","resultsToMerge","resolveField","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","resolveSubSelectedArray","multiplex","inner","_error","QueryManager","queryDeduplication","onBroadcast","ssrMode","localState","mutationStore","queries","fetchQueryRejectFns","transformCache","inFlightLinkObservables","pollingInfoByQueryId","getCache","stop","_info","stopQueryNoBroadcast","mutate","optimisticResponse","updateQueriesByName","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","generateUpdateQueriesInfo","self","_f","setQuery","getVariables","ret","observableQuery","updater","markMutationInit","storeResult","getObservableFromLink","markMutationComplete","refetchQueryPromises","refetchQuery","queryOptions","fetchType","isNetworkOnly","needToFetch","shouldFetch","requestId","networkResult","updateQueryWatch","lastRequestId","invalidated","invalidate","fetchRequest","getQuery","hasForcedResolvers","queryListenerForObserver","invoke","networkStatusChanged","shouldNotifyIfLoading","notifyOnNetworkStatusChange","hasGraphQLErrors","isMissing","errorStatusChanged","diffResult","resultFromStore","transformed","forLink","cacheEntry_1","defaultVars","watchQuery","transformedOptions","watchedQuery","String","stopQueryInStore","stopQueryInStoreNoBroadcast","addQueryListener","listener","listeners","clearStore","resetIds","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","startQuery","makeObservable","markSubscriptionResult","observablePromise_1","queryIdOrObservable","foundObserveableQuery","deduplication","inFlightLinkObservables_1","forceFetch","byVariables_1","varJson_1","cleanup","cleanupSub_1","_next","_error2","_complete","activeNextCount","asyncMap","errorsFromStore","fqrfId","result_1","_error3","prev","newInfo","newContext","checkInFlight","interval","maybeFetch_1","poll_1","timeout","DataStore","initialCache","ignoreErrors","writeWithErrors","optimistic_1","orig","cacheWrites_1","updateQueries_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","disableNetworkFetches","__APOLLO_CLIENT__","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","__actionHookForDevTools","__requestRaw","payload","initQueryManager","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher"],"mappings":"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","file":"js/vendors~main~4134d62c.425c85f4.js","sourcesContent":["import { ApolloLink, Observable } from 'apollo-link';\n\nvar sha256 = require('hash.js/lib/hash/sha/256');\n\nimport { print } from 'graphql/language/printer';\nexport var VERSION = 1;\nexport var defaultGenerateHash = function defaultGenerateHash(query) {\n  return sha256().update(print(query)).digest('hex');\n};\nexport var defaultOptions = {\n  generateHash: defaultGenerateHash,\n  disable: function disable(_a) {\n    var graphQLErrors = _a.graphQLErrors,\n        operation = _a.operation;\n\n    if (graphQLErrors && graphQLErrors.some(function (_a) {\n      var message = _a.message;\n      return message === 'PersistedQueryNotSupported';\n    })) {\n      return true;\n    }\n\n    var response = operation.getContext().response;\n\n    if (response && response.status && (response.status === 400 || response.status === 500)) {\n      return true;\n    }\n\n    return false;\n  },\n  useGETForHashedQueries: false\n};\n\nfunction definitionIsMutation(d) {\n  return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n}\n\nfunction operationIsQuery(operation) {\n  return !operation.query.definitions.some(definitionIsMutation);\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar hashesKeyString = '__createPersistedQueryLink_hashes';\nvar hashesKey = typeof Symbol === 'function' ? Symbol.for(hashesKeyString) : hashesKeyString;\nvar nextHashesChildKey = 0;\nexport var createPersistedQueryLink = function createPersistedQueryLink(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _a = Object.assign({}, defaultOptions, options),\n      generateHash = _a.generateHash,\n      disable = _a.disable,\n      useGETForHashedQueries = _a.useGETForHashedQueries;\n\n  var supportsPersistedQueries = true;\n  var hashesChildKey = 'forLink' + nextHashesChildKey++;\n\n  function getQueryHash(query) {\n    if (!query || typeof query !== \"object\") {\n      return generateHash(query);\n    }\n\n    if (!hasOwnProperty.call(query, hashesKey)) {\n      Object.defineProperty(query, hashesKey, {\n        value: Object.create(null),\n        enumerable: false\n      });\n    }\n\n    var hashes = query[hashesKey];\n    return hasOwnProperty.call(hashes, hashesChildKey) ? hashes[hashesChildKey] : hashes[hashesChildKey] = generateHash(query);\n  }\n\n  return new ApolloLink(function (operation, forward) {\n    if (!forward) {\n      throw new Error('PersistedQueryLink cannot be the last link in the chain.');\n    }\n\n    var query = operation.query;\n    var hashError;\n\n    if (supportsPersistedQueries) {\n      try {\n        operation.extensions.persistedQuery = {\n          version: VERSION,\n          sha256Hash: getQueryHash(query)\n        };\n      } catch (e) {\n        hashError = e;\n      }\n    }\n\n    return new Observable(function (observer) {\n      if (hashError) {\n        observer.error(hashError);\n        return;\n      }\n\n      var subscription;\n      var retried = false;\n      var originalFetchOptions;\n      var setFetchOptions = false;\n\n      var retry = function retry(_a, cb) {\n        var response = _a.response,\n            networkError = _a.networkError;\n\n        if (!retried && (response && response.errors || networkError)) {\n          retried = true;\n          var disablePayload = {\n            response: response,\n            networkError: networkError,\n            operation: operation,\n            graphQLErrors: response ? response.errors : undefined\n          };\n          supportsPersistedQueries = !disable(disablePayload);\n\n          if (response && response.errors && response.errors.some(function (_a) {\n            var message = _a.message;\n            return message === 'PersistedQueryNotFound';\n          }) || !supportsPersistedQueries) {\n            if (subscription) subscription.unsubscribe();\n            operation.setContext({\n              http: {\n                includeQuery: true,\n                includeExtensions: supportsPersistedQueries\n              }\n            });\n\n            if (setFetchOptions) {\n              operation.setContext({\n                fetchOptions: originalFetchOptions\n              });\n            }\n\n            subscription = forward(operation).subscribe(handler);\n            return;\n          }\n        }\n\n        cb();\n      };\n\n      var handler = {\n        next: function next(response) {\n          retry({\n            response: response\n          }, function () {\n            return observer.next(response);\n          });\n        },\n        error: function error(networkError) {\n          retry({\n            networkError: networkError\n          }, function () {\n            return observer.error(networkError);\n          });\n        },\n        complete: observer.complete.bind(observer)\n      };\n      operation.setContext({\n        http: {\n          includeQuery: !supportsPersistedQueries,\n          includeExtensions: supportsPersistedQueries\n        }\n      });\n\n      if (useGETForHashedQueries && supportsPersistedQueries && operationIsQuery(operation)) {\n        operation.setContext(function (_a) {\n          var _b = _a.fetchOptions,\n              fetchOptions = _b === void 0 ? {} : _b;\n          originalFetchOptions = fetchOptions;\n          return {\n            fetchOptions: Object.assign({}, fetchOptions, {\n              method: 'GET'\n            })\n          };\n        });\n        setFetchOptions = true;\n      }\n\n      subscription = forward(operation).subscribe(handler);\n      return function () {\n        if (subscription) subscription.unsubscribe();\n      };\n    });\n  });\n};","import { getFragmentQueryDocument } from 'apollo-utilities';\n\nfunction queryFromPojo(obj) {\n  var op = {\n    kind: 'OperationDefinition',\n    operation: 'query',\n    name: {\n      kind: 'Name',\n      value: 'GeneratedClientQuery'\n    },\n    selectionSet: selectionSetFromObj(obj)\n  };\n  var out = {\n    kind: 'Document',\n    definitions: [op]\n  };\n  return out;\n}\n\nfunction fragmentFromPojo(obj, typename) {\n  var frag = {\n    kind: 'FragmentDefinition',\n    typeCondition: {\n      kind: 'NamedType',\n      name: {\n        kind: 'Name',\n        value: typename || '__FakeType'\n      }\n    },\n    name: {\n      kind: 'Name',\n      value: 'GeneratedClientQuery'\n    },\n    selectionSet: selectionSetFromObj(obj)\n  };\n  var out = {\n    kind: 'Document',\n    definitions: [frag]\n  };\n  return out;\n}\n\nfunction selectionSetFromObj(obj) {\n  if (typeof obj === 'number' || typeof obj === 'boolean' || typeof obj === 'string' || typeof obj === 'undefined' || obj === null) {\n    return null;\n  }\n\n  if (Array.isArray(obj)) {\n    return selectionSetFromObj(obj[0]);\n  }\n\n  var selections = [];\n  Object.keys(obj).forEach(function (key) {\n    var nestedSelSet = selectionSetFromObj(obj[key]);\n    var field = {\n      kind: 'Field',\n      name: {\n        kind: 'Name',\n        value: key\n      },\n      selectionSet: nestedSelSet || undefined\n    };\n    selections.push(field);\n  });\n  var selectionSet = {\n    kind: 'SelectionSet',\n    selections: selections\n  };\n  return selectionSet;\n}\n\nvar justTypenameQuery = {\n  kind: 'Document',\n  definitions: [{\n    kind: 'OperationDefinition',\n    operation: 'query',\n    name: null,\n    variableDefinitions: null,\n    directives: [],\n    selectionSet: {\n      kind: 'SelectionSet',\n      selections: [{\n        kind: 'Field',\n        alias: null,\n        name: {\n          kind: 'Name',\n          value: '__typename'\n        },\n        arguments: [],\n        directives: [],\n        selectionSet: null\n      }]\n    }\n  }]\n};\n\nvar ApolloCache = function () {\n  function ApolloCache() {}\n\n  ApolloCache.prototype.transformDocument = function (document) {\n    return document;\n  };\n\n  ApolloCache.prototype.transformForLink = function (document) {\n    return document;\n  };\n\n  ApolloCache.prototype.readQuery = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.read({\n      query: options.query,\n      variables: options.variables,\n      optimistic: optimistic\n    });\n  };\n\n  ApolloCache.prototype.readFragment = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.read({\n      query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n      variables: options.variables,\n      rootId: options.id,\n      optimistic: optimistic\n    });\n  };\n\n  ApolloCache.prototype.writeQuery = function (options) {\n    this.write({\n      dataId: 'ROOT_QUERY',\n      result: options.data,\n      query: options.query,\n      variables: options.variables\n    });\n  };\n\n  ApolloCache.prototype.writeFragment = function (options) {\n    this.write({\n      dataId: options.id,\n      result: options.data,\n      variables: options.variables,\n      query: getFragmentQueryDocument(options.fragment, options.fragmentName)\n    });\n  };\n\n  ApolloCache.prototype.writeData = function (_a) {\n    var id = _a.id,\n        data = _a.data;\n\n    if (typeof id !== 'undefined') {\n      var typenameResult = null;\n\n      try {\n        typenameResult = this.read({\n          rootId: id,\n          optimistic: false,\n          query: justTypenameQuery\n        });\n      } catch (e) {}\n\n      var __typename = typenameResult && typenameResult.__typename || '__ClientData';\n\n      var dataToWrite = Object.assign({\n        __typename: __typename\n      }, data);\n      this.writeFragment({\n        id: id,\n        fragment: fragmentFromPojo(dataToWrite, __typename),\n        data: dataToWrite\n      });\n    } else {\n      this.writeQuery({\n        query: queryFromPojo(data),\n        data: data\n      });\n    }\n  };\n\n  return ApolloCache;\n}();\n\nvar Cache;\n\n(function (Cache) {})(Cache || (Cache = {}));\n\nexport { ApolloCache, Cache };","// This currentContext variable will only be used if the makeSlotClass\n// function is called, which happens only if this is the first copy of the\n// @wry/context package to be imported.\nvar currentContext = null; // This unique internal object is used to denote the absence of a value\n// for a given Slot, and is never exposed to outside code.\n\nvar MISSING_VALUE = {};\nvar idCounter = 1; // Although we can't do anything about the cost of duplicated code from\n// accidentally bundling multiple copies of the @wry/context package, we can\n// avoid creating the Slot class more than once using makeSlotClass.\n\nvar makeSlotClass = function makeSlotClass() {\n  return (\n    /** @class */\n    function () {\n      function Slot() {\n        // If you have a Slot object, you can find out its slot.id, but you cannot\n        // guess the slot.id of a Slot you don't have access to, thanks to the\n        // randomized suffix.\n        this.id = [\"slot\", idCounter++, Date.now(), Math.random().toString(36).slice(2)].join(\":\");\n      }\n\n      Slot.prototype.hasValue = function () {\n        for (var context_1 = currentContext; context_1; context_1 = context_1.parent) {\n          // We use the Slot object iself as a key to its value, which means the\n          // value cannot be obtained without a reference to the Slot object.\n          if (this.id in context_1.slots) {\n            var value = context_1.slots[this.id];\n            if (value === MISSING_VALUE) break;\n\n            if (context_1 !== currentContext) {\n              // Cache the value in currentContext.slots so the next lookup will\n              // be faster. This caching is safe because the tree of contexts and\n              // the values of the slots are logically immutable.\n              currentContext.slots[this.id] = value;\n            }\n\n            return true;\n          }\n        }\n\n        if (currentContext) {\n          // If a value was not found for this Slot, it's never going to be found\n          // no matter how many times we look it up, so we might as well cache\n          // the absence of the value, too.\n          currentContext.slots[this.id] = MISSING_VALUE;\n        }\n\n        return false;\n      };\n\n      Slot.prototype.getValue = function () {\n        if (this.hasValue()) {\n          return currentContext.slots[this.id];\n        }\n      };\n\n      Slot.prototype.withValue = function (value, callback, // Given the prevalence of arrow functions, specifying arguments is likely\n      // to be much more common than specifying `this`, hence this ordering:\n      args, thisArg) {\n        var _a;\n\n        var slots = (_a = {\n          __proto__: null\n        }, _a[this.id] = value, _a);\n        var parent = currentContext;\n        currentContext = {\n          parent: parent,\n          slots: slots\n        };\n\n        try {\n          // Function.prototype.apply allows the arguments array argument to be\n          // omitted or undefined, so args! is fine here.\n          return callback.apply(thisArg, args);\n        } finally {\n          currentContext = parent;\n        }\n      }; // Capture the current context and wrap a callback function so that it\n      // reestablishes the captured context when called.\n\n\n      Slot.bind = function (callback) {\n        var context = currentContext;\n        return function () {\n          var saved = currentContext;\n\n          try {\n            currentContext = context;\n            return callback.apply(this, arguments);\n          } finally {\n            currentContext = saved;\n          }\n        };\n      }; // Immediately run a callback function without any captured context.\n\n\n      Slot.noContext = function (callback, // Given the prevalence of arrow functions, specifying arguments is likely\n      // to be much more common than specifying `this`, hence this ordering:\n      args, thisArg) {\n        if (currentContext) {\n          var saved = currentContext;\n\n          try {\n            currentContext = null; // Function.prototype.apply allows the arguments array argument to be\n            // omitted or undefined, so args! is fine here.\n\n            return callback.apply(thisArg, args);\n          } finally {\n            currentContext = saved;\n          }\n        } else {\n          return callback.apply(thisArg, args);\n        }\n      };\n\n      return Slot;\n    }()\n  );\n}; // We store a single global implementation of the Slot class as a permanent\n// non-enumerable symbol property of the Array constructor. This obfuscation\n// does nothing to prevent access to the Slot class, but at least it ensures\n// the implementation (i.e. currentContext) cannot be tampered with, and all\n// copies of the @wry/context package (hopefully just one) will share the\n// same Slot implementation. Since the first copy of the @wry/context package\n// to be imported wins, this technique imposes a very high cost for any\n// future breaking changes to the Slot class.\n\n\nvar globalKey = \"@wry/context:Slot\";\nvar host = Array;\n\nvar Slot = host[globalKey] || function () {\n  var Slot = makeSlotClass();\n\n  try {\n    Object.defineProperty(host, globalKey, {\n      value: host[globalKey] = Slot,\n      enumerable: false,\n      writable: false,\n      configurable: false\n    });\n  } finally {\n    return Slot;\n  }\n}();\n\nvar bind = Slot.bind,\n    noContext = Slot.noContext;\n\nfunction setTimeoutWithContext(callback, delay) {\n  return setTimeout(bind(callback), delay);\n} // Turn any generator function into an async function (using yield instead\n// of await), with context automatically preserved across yields.\n\n\nfunction asyncFromGen(genFn) {\n  return function () {\n    var gen = genFn.apply(this, arguments);\n    var boundNext = bind(gen.next);\n    var boundThrow = bind(gen.throw);\n    return new Promise(function (resolve, reject) {\n      function invoke(method, argument) {\n        try {\n          var result = method.call(gen, argument);\n        } catch (error) {\n          return reject(error);\n        }\n\n        var next = result.done ? resolve : invokeNext;\n\n        if (isPromiseLike(result.value)) {\n          result.value.then(next, result.done ? reject : invokeThrow);\n        } else {\n          next(result.value);\n        }\n      }\n\n      var invokeNext = function invokeNext(value) {\n        return invoke(boundNext, value);\n      };\n\n      var invokeThrow = function invokeThrow(error) {\n        return invoke(boundThrow, error);\n      };\n\n      invokeNext();\n    });\n  };\n}\n\nfunction isPromiseLike(value) {\n  return value && typeof value.then === \"function\";\n} // If you use the fibers npm package to implement coroutines in Node.js,\n// you should call this function at least once to ensure context management\n// remains coherent across any yields.\n\n\nvar wrappedFibers = [];\n\nfunction wrapYieldingFiberMethods(Fiber) {\n  // There can be only one implementation of Fiber per process, so this array\n  // should never grow longer than one element.\n  if (wrappedFibers.indexOf(Fiber) < 0) {\n    var wrap = function wrap(obj, method) {\n      var fn = obj[method];\n\n      obj[method] = function () {\n        return noContext(fn, arguments, this);\n      };\n    }; // These methods can yield, according to\n    // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\n\n\n    wrap(Fiber, \"yield\");\n    wrap(Fiber.prototype, \"run\");\n    wrap(Fiber.prototype, \"throwInto\");\n    wrappedFibers.push(Fiber);\n  }\n\n  return Fiber;\n}\n\nexport { Slot, asyncFromGen, bind, noContext, setTimeoutWithContext as setTimeout, wrapYieldingFiberMethods };","import { Slot } from '@wry/context';\nexport { asyncFromGen, bind as bindContext, noContext, setTimeout } from '@wry/context';\n\nfunction defaultDispose() {}\n\nvar Cache =\n/** @class */\nfunction () {\n  function Cache(max, dispose) {\n    if (max === void 0) {\n      max = Infinity;\n    }\n\n    if (dispose === void 0) {\n      dispose = defaultDispose;\n    }\n\n    this.max = max;\n    this.dispose = dispose;\n    this.map = new Map();\n    this.newest = null;\n    this.oldest = null;\n  }\n\n  Cache.prototype.has = function (key) {\n    return this.map.has(key);\n  };\n\n  Cache.prototype.get = function (key) {\n    var entry = this.getEntry(key);\n    return entry && entry.value;\n  };\n\n  Cache.prototype.getEntry = function (key) {\n    var entry = this.map.get(key);\n\n    if (entry && entry !== this.newest) {\n      var older = entry.older,\n          newer = entry.newer;\n\n      if (newer) {\n        newer.older = older;\n      }\n\n      if (older) {\n        older.newer = newer;\n      }\n\n      entry.older = this.newest;\n      entry.older.newer = entry;\n      entry.newer = null;\n      this.newest = entry;\n\n      if (entry === this.oldest) {\n        this.oldest = newer;\n      }\n    }\n\n    return entry;\n  };\n\n  Cache.prototype.set = function (key, value) {\n    var entry = this.getEntry(key);\n\n    if (entry) {\n      return entry.value = value;\n    }\n\n    entry = {\n      key: key,\n      value: value,\n      newer: null,\n      older: this.newest\n    };\n\n    if (this.newest) {\n      this.newest.newer = entry;\n    }\n\n    this.newest = entry;\n    this.oldest = this.oldest || entry;\n    this.map.set(key, entry);\n    return entry.value;\n  };\n\n  Cache.prototype.clean = function () {\n    while (this.oldest && this.map.size > this.max) {\n      this.delete(this.oldest.key);\n    }\n  };\n\n  Cache.prototype.delete = function (key) {\n    var entry = this.map.get(key);\n\n    if (entry) {\n      if (entry === this.newest) {\n        this.newest = entry.older;\n      }\n\n      if (entry === this.oldest) {\n        this.oldest = entry.newer;\n      }\n\n      if (entry.newer) {\n        entry.newer.older = entry.older;\n      }\n\n      if (entry.older) {\n        entry.older.newer = entry.newer;\n      }\n\n      this.map.delete(key);\n      this.dispose(entry.value, key);\n      return true;\n    }\n\n    return false;\n  };\n\n  return Cache;\n}();\n\nvar parentEntrySlot = new Slot();\nvar reusableEmptyArray = [];\nvar emptySetPool = [];\nvar POOL_TARGET_SIZE = 100; // Since this package might be used browsers, we should avoid using the\n// Node built-in assert module.\n\nfunction assert(condition, optionalMessage) {\n  if (!condition) {\n    throw new Error(optionalMessage || \"assertion failure\");\n  }\n}\n\nfunction valueIs(a, b) {\n  var len = a.length;\n  return (// Unknown values are not equal to each other.\n    len > 0 && // Both values must be ordinary (or both exceptional) to be equal.\n    len === b.length && // The underlying value or exception must be the same.\n    a[len - 1] === b[len - 1]\n  );\n}\n\nfunction valueGet(value) {\n  switch (value.length) {\n    case 0:\n      throw new Error(\"unknown value\");\n\n    case 1:\n      return value[0];\n\n    case 2:\n      throw value[1];\n  }\n}\n\nfunction valueCopy(value) {\n  return value.slice(0);\n}\n\nvar Entry =\n/** @class */\nfunction () {\n  function Entry(fn, args) {\n    this.fn = fn;\n    this.args = args;\n    this.parents = new Set();\n    this.childValues = new Map(); // When this Entry has children that are dirty, this property becomes\n    // a Set containing other Entry objects, borrowed from emptySetPool.\n    // When the set becomes empty, it gets recycled back to emptySetPool.\n\n    this.dirtyChildren = null;\n    this.dirty = true;\n    this.recomputing = false;\n    this.value = [];\n    ++Entry.count;\n  } // This is the most important method of the Entry API, because it\n  // determines whether the cached this.value can be returned immediately,\n  // or must be recomputed. The overall performance of the caching system\n  // depends on the truth of the following observations: (1) this.dirty is\n  // usually false, (2) this.dirtyChildren is usually null/empty, and thus\n  // (3) valueGet(this.value) is usually returned without recomputation.\n\n\n  Entry.prototype.recompute = function () {\n    assert(!this.recomputing, \"already recomputing\");\n\n    if (!rememberParent(this) && maybeReportOrphan(this)) {\n      // The recipient of the entry.reportOrphan callback decided to dispose\n      // of this orphan entry by calling entry.dispose(), so we don't need to\n      // (and should not) proceed with the recomputation.\n      return void 0;\n    }\n\n    return mightBeDirty(this) ? reallyRecompute(this) : valueGet(this.value);\n  };\n\n  Entry.prototype.setDirty = function () {\n    if (this.dirty) return;\n    this.dirty = true;\n    this.value.length = 0;\n    reportDirty(this); // We can go ahead and unsubscribe here, since any further dirty\n    // notifications we receive will be redundant, and unsubscribing may\n    // free up some resources, e.g. file watchers.\n\n    maybeUnsubscribe(this);\n  };\n\n  Entry.prototype.dispose = function () {\n    var _this = this;\n\n    forgetChildren(this).forEach(maybeReportOrphan);\n    maybeUnsubscribe(this); // Because this entry has been kicked out of the cache (in index.js),\n    // we've lost the ability to find out if/when this entry becomes dirty,\n    // whether that happens through a subscription, because of a direct call\n    // to entry.setDirty(), or because one of its children becomes dirty.\n    // Because of this loss of future information, we have to assume the\n    // worst (that this entry might have become dirty very soon), so we must\n    // immediately mark this entry's parents as dirty. Normally we could\n    // just call entry.setDirty() rather than calling parent.setDirty() for\n    // each parent, but that would leave this entry in parent.childValues\n    // and parent.dirtyChildren, which would prevent the child from being\n    // truly forgotten.\n\n    this.parents.forEach(function (parent) {\n      parent.setDirty();\n      forgetChild(parent, _this);\n    });\n  };\n\n  Entry.count = 0;\n  return Entry;\n}();\n\nfunction rememberParent(child) {\n  var parent = parentEntrySlot.getValue();\n\n  if (parent) {\n    child.parents.add(parent);\n\n    if (!parent.childValues.has(child)) {\n      parent.childValues.set(child, []);\n    }\n\n    if (mightBeDirty(child)) {\n      reportDirtyChild(parent, child);\n    } else {\n      reportCleanChild(parent, child);\n    }\n\n    return parent;\n  }\n}\n\nfunction reallyRecompute(entry) {\n  // Since this recomputation is likely to re-remember some of this\n  // entry's children, we forget our children here but do not call\n  // maybeReportOrphan until after the recomputation finishes.\n  var originalChildren = forgetChildren(entry); // Set entry as the parent entry while calling recomputeNewValue(entry).\n\n  parentEntrySlot.withValue(entry, recomputeNewValue, [entry]);\n\n  if (maybeSubscribe(entry)) {\n    // If we successfully recomputed entry.value and did not fail to\n    // (re)subscribe, then this Entry is no longer explicitly dirty.\n    setClean(entry);\n  } // Now that we've had a chance to re-remember any children that were\n  // involved in the recomputation, we can safely report any orphan\n  // children that remain.\n\n\n  originalChildren.forEach(maybeReportOrphan);\n  return valueGet(entry.value);\n}\n\nfunction recomputeNewValue(entry) {\n  entry.recomputing = true; // Set entry.value as unknown.\n\n  entry.value.length = 0;\n\n  try {\n    // If entry.fn succeeds, entry.value will become a normal Value.\n    entry.value[0] = entry.fn.apply(null, entry.args);\n  } catch (e) {\n    // If entry.fn throws, entry.value will become exceptional.\n    entry.value[1] = e;\n  } // Either way, this line is always reached.\n\n\n  entry.recomputing = false;\n}\n\nfunction mightBeDirty(entry) {\n  return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\n}\n\nfunction setClean(entry) {\n  entry.dirty = false;\n\n  if (mightBeDirty(entry)) {\n    // This Entry may still have dirty children, in which case we can't\n    // let our parents know we're clean just yet.\n    return;\n  }\n\n  reportClean(entry);\n}\n\nfunction reportDirty(child) {\n  child.parents.forEach(function (parent) {\n    return reportDirtyChild(parent, child);\n  });\n}\n\nfunction reportClean(child) {\n  child.parents.forEach(function (parent) {\n    return reportCleanChild(parent, child);\n  });\n} // Let a parent Entry know that one of its children may be dirty.\n\n\nfunction reportDirtyChild(parent, child) {\n  // Must have called rememberParent(child) before calling\n  // reportDirtyChild(parent, child).\n  assert(parent.childValues.has(child));\n  assert(mightBeDirty(child));\n\n  if (!parent.dirtyChildren) {\n    parent.dirtyChildren = emptySetPool.pop() || new Set();\n  } else if (parent.dirtyChildren.has(child)) {\n    // If we already know this child is dirty, then we must have already\n    // informed our own parents that we are dirty, so we can terminate\n    // the recursion early.\n    return;\n  }\n\n  parent.dirtyChildren.add(child);\n  reportDirty(parent);\n} // Let a parent Entry know that one of its children is no longer dirty.\n\n\nfunction reportCleanChild(parent, child) {\n  // Must have called rememberChild(child) before calling\n  // reportCleanChild(parent, child).\n  assert(parent.childValues.has(child));\n  assert(!mightBeDirty(child));\n  var childValue = parent.childValues.get(child);\n\n  if (childValue.length === 0) {\n    parent.childValues.set(child, valueCopy(child.value));\n  } else if (!valueIs(childValue, child.value)) {\n    parent.setDirty();\n  }\n\n  removeDirtyChild(parent, child);\n\n  if (mightBeDirty(parent)) {\n    return;\n  }\n\n  reportClean(parent);\n}\n\nfunction removeDirtyChild(parent, child) {\n  var dc = parent.dirtyChildren;\n\n  if (dc) {\n    dc.delete(child);\n\n    if (dc.size === 0) {\n      if (emptySetPool.length < POOL_TARGET_SIZE) {\n        emptySetPool.push(dc);\n      }\n\n      parent.dirtyChildren = null;\n    }\n  }\n} // If the given entry has a reportOrphan method, and no remaining parents,\n// call entry.reportOrphan and return true iff it returns true. The\n// reportOrphan function should return true to indicate entry.dispose()\n// has been called, and the entry has been removed from any other caches\n// (see index.js for the only current example).\n\n\nfunction maybeReportOrphan(entry) {\n  return entry.parents.size === 0 && typeof entry.reportOrphan === \"function\" && entry.reportOrphan() === true;\n} // Removes all children from this entry and returns an array of the\n// removed children.\n\n\nfunction forgetChildren(parent) {\n  var children = reusableEmptyArray;\n\n  if (parent.childValues.size > 0) {\n    children = [];\n    parent.childValues.forEach(function (_value, child) {\n      forgetChild(parent, child);\n      children.push(child);\n    });\n  } // After we forget all our children, this.dirtyChildren must be empty\n  // and therefore must have been reset to null.\n\n\n  assert(parent.dirtyChildren === null);\n  return children;\n}\n\nfunction forgetChild(parent, child) {\n  child.parents.delete(parent);\n  parent.childValues.delete(child);\n  removeDirtyChild(parent, child);\n}\n\nfunction maybeSubscribe(entry) {\n  if (typeof entry.subscribe === \"function\") {\n    try {\n      maybeUnsubscribe(entry); // Prevent double subscriptions.\n\n      entry.unsubscribe = entry.subscribe.apply(null, entry.args);\n    } catch (e) {\n      // If this Entry has a subscribe function and it threw an exception\n      // (or an unsubscribe function it previously returned now throws),\n      // return false to indicate that we were not able to subscribe (or\n      // unsubscribe), and this Entry should remain dirty.\n      entry.setDirty();\n      return false;\n    }\n  } // Returning true indicates either that there was no entry.subscribe\n  // function or that it succeeded.\n\n\n  return true;\n}\n\nfunction maybeUnsubscribe(entry) {\n  var unsubscribe = entry.unsubscribe;\n\n  if (typeof unsubscribe === \"function\") {\n    entry.unsubscribe = void 0;\n    unsubscribe();\n  }\n} // A trie data structure that holds object keys weakly, yet can also hold\n// non-object keys, unlike the native `WeakMap`.\n\n\nvar KeyTrie =\n/** @class */\nfunction () {\n  function KeyTrie(weakness) {\n    this.weakness = weakness;\n  }\n\n  KeyTrie.prototype.lookup = function () {\n    var array = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      array[_i] = arguments[_i];\n    }\n\n    return this.lookupArray(array);\n  };\n\n  KeyTrie.prototype.lookupArray = function (array) {\n    var node = this;\n    array.forEach(function (key) {\n      return node = node.getChildTrie(key);\n    });\n    return node.data || (node.data = Object.create(null));\n  };\n\n  KeyTrie.prototype.getChildTrie = function (key) {\n    var map = this.weakness && isObjRef(key) ? this.weak || (this.weak = new WeakMap()) : this.strong || (this.strong = new Map());\n    var child = map.get(key);\n    if (!child) map.set(key, child = new KeyTrie(this.weakness));\n    return child;\n  };\n\n  return KeyTrie;\n}();\n\nfunction isObjRef(value) {\n  switch (typeof value) {\n    case \"object\":\n      if (value === null) break;\n    // Fall through to return true...\n\n    case \"function\":\n      return true;\n  }\n\n  return false;\n} // The defaultMakeCacheKey function is remarkably powerful, because it gives\n// a unique object for any shallow-identical list of arguments. If you need\n// to implement a custom makeCacheKey function, you may find it helpful to\n// delegate the final work to defaultMakeCacheKey, which is why we export it\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\n// does not support WeakMap, or you have the ability to return a string key.\n// In those cases, just write your own custom makeCacheKey functions.\n\n\nvar keyTrie = new KeyTrie(typeof WeakMap === \"function\");\n\nfunction defaultMakeCacheKey() {\n  var args = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    args[_i] = arguments[_i];\n  }\n\n  return keyTrie.lookupArray(args);\n}\n\nvar caches = new Set();\n\nfunction wrap(originalFunction, options) {\n  if (options === void 0) {\n    options = Object.create(null);\n  }\n\n  var cache = new Cache(options.max || Math.pow(2, 16), function (entry) {\n    return entry.dispose();\n  });\n  var disposable = !!options.disposable;\n  var makeCacheKey = options.makeCacheKey || defaultMakeCacheKey;\n\n  function optimistic() {\n    if (disposable && !parentEntrySlot.hasValue()) {\n      // If there's no current parent computation, and this wrapped\n      // function is disposable (meaning we don't care about entry.value,\n      // just dependency tracking), then we can short-cut everything else\n      // in this function, because entry.recompute() is going to recycle\n      // the entry object without recomputing anything, anyway.\n      return void 0;\n    }\n\n    var key = makeCacheKey.apply(null, arguments);\n\n    if (key === void 0) {\n      return originalFunction.apply(null, arguments);\n    }\n\n    var args = Array.prototype.slice.call(arguments);\n    var entry = cache.get(key);\n\n    if (entry) {\n      entry.args = args;\n    } else {\n      entry = new Entry(originalFunction, args);\n      cache.set(key, entry);\n      entry.subscribe = options.subscribe;\n\n      if (disposable) {\n        entry.reportOrphan = function () {\n          return cache.delete(key);\n        };\n      }\n    }\n\n    var value = entry.recompute(); // Move this entry to the front of the least-recently used queue,\n    // since we just finished computing its value.\n\n    cache.set(key, entry);\n    caches.add(cache); // Clean up any excess entries in the cache, but only if there is no\n    // active parent entry, meaning we're not in the middle of a larger\n    // computation that might be flummoxed by the cleaning.\n\n    if (!parentEntrySlot.hasValue()) {\n      caches.forEach(function (cache) {\n        return cache.clean();\n      });\n      caches.clear();\n    } // If options.disposable is truthy, the caller of wrap is telling us\n    // they don't care about the result of entry.recompute(), so we should\n    // avoid returning the value, so it won't be accidentally used.\n\n\n    return disposable ? void 0 : value;\n  }\n\n  optimistic.dirty = function () {\n    var key = makeCacheKey.apply(null, arguments);\n    var child = key !== void 0 && cache.get(key);\n\n    if (child) {\n      child.setDirty();\n    }\n  };\n\n  return optimistic;\n}\n\nexport { KeyTrie, defaultMakeCacheKey, wrap };","import { __assign, __extends } from 'tslib';\nimport { ApolloCache } from 'apollo-cache';\nimport { isTest, getQueryDefinition, assign, getDefaultValues, isEqual, getMainDefinition, getFragmentDefinitions, createFragmentMap, shouldInclude, isField, resultKeyNameFromField, isInlineFragment, mergeDeepArray, argumentsObjectFromField, getDirectiveInfoFromField, maybeDeepFreeze, isIdValue, getStoreKeyName, toIdValue, isJsonValue, canUseWeakMap, getOperationDefinition, isProduction, storeKeyNameFromField, addTypenameToDocument } from 'apollo-utilities';\nimport { wrap, KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\nvar haveWarned = false;\n\nfunction shouldWarn() {\n  var answer = !haveWarned;\n\n  if (!isTest()) {\n    haveWarned = true;\n  }\n\n  return answer;\n}\n\nvar HeuristicFragmentMatcher = function () {\n  function HeuristicFragmentMatcher() {}\n\n  HeuristicFragmentMatcher.prototype.ensureReady = function () {\n    return Promise.resolve();\n  };\n\n  HeuristicFragmentMatcher.prototype.canBypassInit = function () {\n    return true;\n  };\n\n  HeuristicFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n    var obj = context.store.get(idValue.id);\n    var isRootQuery = idValue.id === 'ROOT_QUERY';\n\n    if (!obj) {\n      return isRootQuery;\n    }\n\n    var _a = obj.__typename,\n        __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n\n    if (!__typename) {\n      if (shouldWarn()) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"You're using fragments in your queries, but either don't have the addTypename:\\n  true option set in Apollo Client, or you are trying to write a fragment to the store without the __typename.\\n   Please turn on the addTypename option and include __typename when writing fragments so that Apollo Client\\n   can accurately match fragments.\");\n        process.env.NODE_ENV === \"production\" || invariant.warn('Could not find __typename on Fragment ', typeCondition, obj);\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"DEPRECATION WARNING: using fragments without __typename is unsupported behavior \" + \"and will be removed in future versions of Apollo client. You should fix this and set addTypename to true now.\");\n      }\n\n      return 'heuristic';\n    }\n\n    if (__typename === typeCondition) {\n      return true;\n    }\n\n    if (shouldWarn()) {\n      process.env.NODE_ENV === \"production\" || invariant.error('You are using the simple (heuristic) fragment matcher, but your ' + 'queries contain union or interface types. Apollo Client will not be ' + 'able to accurately map fragments. To make this error go away, use ' + 'the `IntrospectionFragmentMatcher` as described in the docs: ' + 'https://www.apollographql.com/docs/react/advanced/fragments.html#fragment-matcher');\n    }\n\n    return 'heuristic';\n  };\n\n  return HeuristicFragmentMatcher;\n}();\n\nvar IntrospectionFragmentMatcher = function () {\n  function IntrospectionFragmentMatcher(options) {\n    if (options && options.introspectionQueryResultData) {\n      this.possibleTypesMap = this.parseIntrospectionResult(options.introspectionQueryResultData);\n      this.isReady = true;\n    } else {\n      this.isReady = false;\n    }\n\n    this.match = this.match.bind(this);\n  }\n\n  IntrospectionFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n    process.env.NODE_ENV === \"production\" ? invariant(this.isReady, 1) : invariant(this.isReady, 'FragmentMatcher.match() was called before FragmentMatcher.init()');\n    var obj = context.store.get(idValue.id);\n    var isRootQuery = idValue.id === 'ROOT_QUERY';\n\n    if (!obj) {\n      return isRootQuery;\n    }\n\n    var _a = obj.__typename,\n        __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n\n    process.env.NODE_ENV === \"production\" ? invariant(__typename, 2) : invariant(__typename, \"Cannot match fragment because __typename property is missing: \" + JSON.stringify(obj));\n\n    if (__typename === typeCondition) {\n      return true;\n    }\n\n    var implementingTypes = this.possibleTypesMap[typeCondition];\n\n    if (__typename && implementingTypes && implementingTypes.indexOf(__typename) > -1) {\n      return true;\n    }\n\n    return false;\n  };\n\n  IntrospectionFragmentMatcher.prototype.parseIntrospectionResult = function (introspectionResultData) {\n    var typeMap = {};\n\n    introspectionResultData.__schema.types.forEach(function (type) {\n      if (type.kind === 'UNION' || type.kind === 'INTERFACE') {\n        typeMap[type.name] = type.possibleTypes.map(function (implementingType) {\n          return implementingType.name;\n        });\n      }\n    });\n\n    return typeMap;\n  };\n\n  return IntrospectionFragmentMatcher;\n}();\n\nvar hasOwn = Object.prototype.hasOwnProperty;\n\nvar DepTrackingCache = function () {\n  function DepTrackingCache(data) {\n    var _this = this;\n\n    if (data === void 0) {\n      data = Object.create(null);\n    }\n\n    this.data = data;\n    this.depend = wrap(function (dataId) {\n      return _this.data[dataId];\n    }, {\n      disposable: true,\n      makeCacheKey: function makeCacheKey(dataId) {\n        return dataId;\n      }\n    });\n  }\n\n  DepTrackingCache.prototype.toObject = function () {\n    return this.data;\n  };\n\n  DepTrackingCache.prototype.get = function (dataId) {\n    this.depend(dataId);\n    return this.data[dataId];\n  };\n\n  DepTrackingCache.prototype.set = function (dataId, value) {\n    var oldValue = this.data[dataId];\n\n    if (value !== oldValue) {\n      this.data[dataId] = value;\n      this.depend.dirty(dataId);\n    }\n  };\n\n  DepTrackingCache.prototype.delete = function (dataId) {\n    if (hasOwn.call(this.data, dataId)) {\n      delete this.data[dataId];\n      this.depend.dirty(dataId);\n    }\n  };\n\n  DepTrackingCache.prototype.clear = function () {\n    this.replace(null);\n  };\n\n  DepTrackingCache.prototype.replace = function (newData) {\n    var _this = this;\n\n    if (newData) {\n      Object.keys(newData).forEach(function (dataId) {\n        _this.set(dataId, newData[dataId]);\n      });\n      Object.keys(this.data).forEach(function (dataId) {\n        if (!hasOwn.call(newData, dataId)) {\n          _this.delete(dataId);\n        }\n      });\n    } else {\n      Object.keys(this.data).forEach(function (dataId) {\n        _this.delete(dataId);\n      });\n    }\n  };\n\n  return DepTrackingCache;\n}();\n\nfunction defaultNormalizedCacheFactory(seed) {\n  return new DepTrackingCache(seed);\n}\n\nvar StoreReader = function () {\n  function StoreReader(_a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        _c = _b.cacheKeyRoot,\n        cacheKeyRoot = _c === void 0 ? new KeyTrie(canUseWeakMap) : _c,\n        _d = _b.freezeResults,\n        freezeResults = _d === void 0 ? false : _d;\n\n    var _e = this,\n        executeStoreQuery = _e.executeStoreQuery,\n        executeSelectionSet = _e.executeSelectionSet,\n        executeSubSelectedArray = _e.executeSubSelectedArray;\n\n    this.freezeResults = freezeResults;\n    this.executeStoreQuery = wrap(function (options) {\n      return executeStoreQuery.call(_this, options);\n    }, {\n      makeCacheKey: function makeCacheKey(_a) {\n        var query = _a.query,\n            rootValue = _a.rootValue,\n            contextValue = _a.contextValue,\n            variableValues = _a.variableValues,\n            fragmentMatcher = _a.fragmentMatcher;\n\n        if (contextValue.store instanceof DepTrackingCache) {\n          return cacheKeyRoot.lookup(contextValue.store, query, fragmentMatcher, JSON.stringify(variableValues), rootValue.id);\n        }\n      }\n    });\n    this.executeSelectionSet = wrap(function (options) {\n      return executeSelectionSet.call(_this, options);\n    }, {\n      makeCacheKey: function makeCacheKey(_a) {\n        var selectionSet = _a.selectionSet,\n            rootValue = _a.rootValue,\n            execContext = _a.execContext;\n\n        if (execContext.contextValue.store instanceof DepTrackingCache) {\n          return cacheKeyRoot.lookup(execContext.contextValue.store, selectionSet, execContext.fragmentMatcher, JSON.stringify(execContext.variableValues), rootValue.id);\n        }\n      }\n    });\n    this.executeSubSelectedArray = wrap(function (options) {\n      return executeSubSelectedArray.call(_this, options);\n    }, {\n      makeCacheKey: function makeCacheKey(_a) {\n        var field = _a.field,\n            array = _a.array,\n            execContext = _a.execContext;\n\n        if (execContext.contextValue.store instanceof DepTrackingCache) {\n          return cacheKeyRoot.lookup(execContext.contextValue.store, field, array, JSON.stringify(execContext.variableValues));\n        }\n      }\n    });\n  }\n\n  StoreReader.prototype.readQueryFromStore = function (options) {\n    return this.diffQueryAgainstStore(__assign(__assign({}, options), {\n      returnPartialData: false\n    })).result;\n  };\n\n  StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n    var store = _a.store,\n        query = _a.query,\n        variables = _a.variables,\n        previousResult = _a.previousResult,\n        _b = _a.returnPartialData,\n        returnPartialData = _b === void 0 ? true : _b,\n        _c = _a.rootId,\n        rootId = _c === void 0 ? 'ROOT_QUERY' : _c,\n        fragmentMatcherFunction = _a.fragmentMatcherFunction,\n        config = _a.config;\n    var queryDefinition = getQueryDefinition(query);\n    variables = assign({}, getDefaultValues(queryDefinition), variables);\n    var context = {\n      store: store,\n      dataIdFromObject: config && config.dataIdFromObject,\n      cacheRedirects: config && config.cacheRedirects || {}\n    };\n    var execResult = this.executeStoreQuery({\n      query: query,\n      rootValue: {\n        type: 'id',\n        id: rootId,\n        generated: true,\n        typename: 'Query'\n      },\n      contextValue: context,\n      variableValues: variables,\n      fragmentMatcher: fragmentMatcherFunction\n    });\n    var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n\n    if (hasMissingFields && !returnPartialData) {\n      execResult.missing.forEach(function (info) {\n        if (info.tolerable) return;\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Can't find field \" + info.fieldName + \" on object \" + JSON.stringify(info.object, null, 2) + \".\");\n      });\n    }\n\n    if (previousResult) {\n      if (isEqual(previousResult, execResult.result)) {\n        execResult.result = previousResult;\n      }\n    }\n\n    return {\n      result: execResult.result,\n      complete: !hasMissingFields\n    };\n  };\n\n  StoreReader.prototype.executeStoreQuery = function (_a) {\n    var query = _a.query,\n        rootValue = _a.rootValue,\n        contextValue = _a.contextValue,\n        variableValues = _a.variableValues,\n        _b = _a.fragmentMatcher,\n        fragmentMatcher = _b === void 0 ? defaultFragmentMatcher : _b;\n    var mainDefinition = getMainDefinition(query);\n    var fragments = getFragmentDefinitions(query);\n    var fragmentMap = createFragmentMap(fragments);\n    var execContext = {\n      query: query,\n      fragmentMap: fragmentMap,\n      contextValue: contextValue,\n      variableValues: variableValues,\n      fragmentMatcher: fragmentMatcher\n    };\n    return this.executeSelectionSet({\n      selectionSet: mainDefinition.selectionSet,\n      rootValue: rootValue,\n      execContext: execContext\n    });\n  };\n\n  StoreReader.prototype.executeSelectionSet = function (_a) {\n    var _this = this;\n\n    var selectionSet = _a.selectionSet,\n        rootValue = _a.rootValue,\n        execContext = _a.execContext;\n    var fragmentMap = execContext.fragmentMap,\n        contextValue = execContext.contextValue,\n        variables = execContext.variableValues;\n    var finalResult = {\n      result: null\n    };\n    var objectsToMerge = [];\n    var object = contextValue.store.get(rootValue.id);\n    var typename = object && object.__typename || rootValue.id === 'ROOT_QUERY' && 'Query' || void 0;\n\n    function handleMissing(result) {\n      var _a;\n\n      if (result.missing) {\n        finalResult.missing = finalResult.missing || [];\n\n        (_a = finalResult.missing).push.apply(_a, result.missing);\n      }\n\n      return result.result;\n    }\n\n    selectionSet.selections.forEach(function (selection) {\n      var _a;\n\n      if (!shouldInclude(selection, variables)) {\n        return;\n      }\n\n      if (isField(selection)) {\n        var fieldResult = handleMissing(_this.executeField(object, typename, selection, execContext));\n\n        if (typeof fieldResult !== 'undefined') {\n          objectsToMerge.push((_a = {}, _a[resultKeyNameFromField(selection)] = fieldResult, _a));\n        }\n      } else {\n        var fragment = void 0;\n\n        if (isInlineFragment(selection)) {\n          fragment = selection;\n        } else {\n          fragment = fragmentMap[selection.name.value];\n\n          if (!fragment) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"No fragment named \" + selection.name.value);\n          }\n        }\n\n        var typeCondition = fragment.typeCondition && fragment.typeCondition.name.value;\n        var match = !typeCondition || execContext.fragmentMatcher(rootValue, typeCondition, contextValue);\n\n        if (match) {\n          var fragmentExecResult = _this.executeSelectionSet({\n            selectionSet: fragment.selectionSet,\n            rootValue: rootValue,\n            execContext: execContext\n          });\n\n          if (match === 'heuristic' && fragmentExecResult.missing) {\n            fragmentExecResult = __assign(__assign({}, fragmentExecResult), {\n              missing: fragmentExecResult.missing.map(function (info) {\n                return __assign(__assign({}, info), {\n                  tolerable: true\n                });\n              })\n            });\n          }\n\n          objectsToMerge.push(handleMissing(fragmentExecResult));\n        }\n      }\n    });\n    finalResult.result = mergeDeepArray(objectsToMerge);\n\n    if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n      Object.freeze(finalResult.result);\n    }\n\n    return finalResult;\n  };\n\n  StoreReader.prototype.executeField = function (object, typename, field, execContext) {\n    var variables = execContext.variableValues,\n        contextValue = execContext.contextValue;\n    var fieldName = field.name.value;\n    var args = argumentsObjectFromField(field, variables);\n    var info = {\n      resultKey: resultKeyNameFromField(field),\n      directives: getDirectiveInfoFromField(field, variables)\n    };\n    var readStoreResult = readStoreResolver(object, typename, fieldName, args, contextValue, info);\n\n    if (Array.isArray(readStoreResult.result)) {\n      return this.combineExecResults(readStoreResult, this.executeSubSelectedArray({\n        field: field,\n        array: readStoreResult.result,\n        execContext: execContext\n      }));\n    }\n\n    if (!field.selectionSet) {\n      assertSelectionSetForIdValue(field, readStoreResult.result);\n\n      if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n        maybeDeepFreeze(readStoreResult);\n      }\n\n      return readStoreResult;\n    }\n\n    if (readStoreResult.result == null) {\n      return readStoreResult;\n    }\n\n    return this.combineExecResults(readStoreResult, this.executeSelectionSet({\n      selectionSet: field.selectionSet,\n      rootValue: readStoreResult.result,\n      execContext: execContext\n    }));\n  };\n\n  StoreReader.prototype.combineExecResults = function () {\n    var execResults = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      execResults[_i] = arguments[_i];\n    }\n\n    var missing;\n    execResults.forEach(function (execResult) {\n      if (execResult.missing) {\n        missing = missing || [];\n        missing.push.apply(missing, execResult.missing);\n      }\n    });\n    return {\n      result: execResults.pop().result,\n      missing: missing\n    };\n  };\n\n  StoreReader.prototype.executeSubSelectedArray = function (_a) {\n    var _this = this;\n\n    var field = _a.field,\n        array = _a.array,\n        execContext = _a.execContext;\n    var missing;\n\n    function handleMissing(childResult) {\n      if (childResult.missing) {\n        missing = missing || [];\n        missing.push.apply(missing, childResult.missing);\n      }\n\n      return childResult.result;\n    }\n\n    array = array.map(function (item) {\n      if (item === null) {\n        return null;\n      }\n\n      if (Array.isArray(item)) {\n        return handleMissing(_this.executeSubSelectedArray({\n          field: field,\n          array: item,\n          execContext: execContext\n        }));\n      }\n\n      if (field.selectionSet) {\n        return handleMissing(_this.executeSelectionSet({\n          selectionSet: field.selectionSet,\n          rootValue: item,\n          execContext: execContext\n        }));\n      }\n\n      assertSelectionSetForIdValue(field, item);\n      return item;\n    });\n\n    if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n      Object.freeze(array);\n    }\n\n    return {\n      result: array,\n      missing: missing\n    };\n  };\n\n  return StoreReader;\n}();\n\nfunction assertSelectionSetForIdValue(field, value) {\n  if (!field.selectionSet && isIdValue(value)) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError(\"Missing selection set for object of type \" + value.typename + \" returned for query field \" + field.name.value);\n  }\n}\n\nfunction defaultFragmentMatcher() {\n  return true;\n}\n\nfunction assertIdValue(idValue) {\n  process.env.NODE_ENV === \"production\" ? invariant(isIdValue(idValue), 11) : invariant(isIdValue(idValue), \"Encountered a sub-selection on the query, but the store doesn't have an object reference. This should never happen during normal use unless you have custom code that is directly manipulating the store; please file an issue.\");\n}\n\nfunction readStoreResolver(object, typename, fieldName, args, context, _a) {\n  var resultKey = _a.resultKey,\n      directives = _a.directives;\n  var storeKeyName = fieldName;\n\n  if (args || directives) {\n    storeKeyName = getStoreKeyName(storeKeyName, args, directives);\n  }\n\n  var fieldValue = void 0;\n\n  if (object) {\n    fieldValue = object[storeKeyName];\n\n    if (typeof fieldValue === 'undefined' && context.cacheRedirects && typeof typename === 'string') {\n      var type = context.cacheRedirects[typename];\n\n      if (type) {\n        var resolver = type[fieldName];\n\n        if (resolver) {\n          fieldValue = resolver(object, args, {\n            getCacheKey: function getCacheKey(storeObj) {\n              var id = context.dataIdFromObject(storeObj);\n              return id && toIdValue({\n                id: id,\n                typename: storeObj.__typename\n              });\n            }\n          });\n        }\n      }\n    }\n  }\n\n  if (typeof fieldValue === 'undefined') {\n    return {\n      result: fieldValue,\n      missing: [{\n        object: object,\n        fieldName: storeKeyName,\n        tolerable: false\n      }]\n    };\n  }\n\n  if (isJsonValue(fieldValue)) {\n    fieldValue = fieldValue.json;\n  }\n\n  return {\n    result: fieldValue\n  };\n}\n\nvar ObjectCache = function () {\n  function ObjectCache(data) {\n    if (data === void 0) {\n      data = Object.create(null);\n    }\n\n    this.data = data;\n  }\n\n  ObjectCache.prototype.toObject = function () {\n    return this.data;\n  };\n\n  ObjectCache.prototype.get = function (dataId) {\n    return this.data[dataId];\n  };\n\n  ObjectCache.prototype.set = function (dataId, value) {\n    this.data[dataId] = value;\n  };\n\n  ObjectCache.prototype.delete = function (dataId) {\n    this.data[dataId] = void 0;\n  };\n\n  ObjectCache.prototype.clear = function () {\n    this.data = Object.create(null);\n  };\n\n  ObjectCache.prototype.replace = function (newData) {\n    this.data = newData || Object.create(null);\n  };\n\n  return ObjectCache;\n}();\n\nfunction defaultNormalizedCacheFactory$1(seed) {\n  return new ObjectCache(seed);\n}\n\nvar WriteError = function (_super) {\n  __extends(WriteError, _super);\n\n  function WriteError() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n\n    _this.type = 'WriteError';\n    return _this;\n  }\n\n  return WriteError;\n}(Error);\n\nfunction enhanceErrorWithDocument(error, document) {\n  var enhancedError = new WriteError(\"Error writing result to store for query:\\n \" + JSON.stringify(document));\n  enhancedError.message += '\\n' + error.message;\n  enhancedError.stack = error.stack;\n  return enhancedError;\n}\n\nvar StoreWriter = function () {\n  function StoreWriter() {}\n\n  StoreWriter.prototype.writeQueryToStore = function (_a) {\n    var query = _a.query,\n        result = _a.result,\n        _b = _a.store,\n        store = _b === void 0 ? defaultNormalizedCacheFactory() : _b,\n        variables = _a.variables,\n        dataIdFromObject = _a.dataIdFromObject,\n        fragmentMatcherFunction = _a.fragmentMatcherFunction;\n    return this.writeResultToStore({\n      dataId: 'ROOT_QUERY',\n      result: result,\n      document: query,\n      store: store,\n      variables: variables,\n      dataIdFromObject: dataIdFromObject,\n      fragmentMatcherFunction: fragmentMatcherFunction\n    });\n  };\n\n  StoreWriter.prototype.writeResultToStore = function (_a) {\n    var dataId = _a.dataId,\n        result = _a.result,\n        document = _a.document,\n        _b = _a.store,\n        store = _b === void 0 ? defaultNormalizedCacheFactory() : _b,\n        variables = _a.variables,\n        dataIdFromObject = _a.dataIdFromObject,\n        fragmentMatcherFunction = _a.fragmentMatcherFunction;\n    var operationDefinition = getOperationDefinition(document);\n\n    try {\n      return this.writeSelectionSetToStore({\n        result: result,\n        dataId: dataId,\n        selectionSet: operationDefinition.selectionSet,\n        context: {\n          store: store,\n          processedData: {},\n          variables: assign({}, getDefaultValues(operationDefinition), variables),\n          dataIdFromObject: dataIdFromObject,\n          fragmentMap: createFragmentMap(getFragmentDefinitions(document)),\n          fragmentMatcherFunction: fragmentMatcherFunction\n        }\n      });\n    } catch (e) {\n      throw enhanceErrorWithDocument(e, document);\n    }\n  };\n\n  StoreWriter.prototype.writeSelectionSetToStore = function (_a) {\n    var _this = this;\n\n    var result = _a.result,\n        dataId = _a.dataId,\n        selectionSet = _a.selectionSet,\n        context = _a.context;\n    var variables = context.variables,\n        store = context.store,\n        fragmentMap = context.fragmentMap;\n    selectionSet.selections.forEach(function (selection) {\n      var _a;\n\n      if (!shouldInclude(selection, variables)) {\n        return;\n      }\n\n      if (isField(selection)) {\n        var resultFieldKey = resultKeyNameFromField(selection);\n        var value = result[resultFieldKey];\n\n        if (typeof value !== 'undefined') {\n          _this.writeFieldToStore({\n            dataId: dataId,\n            value: value,\n            field: selection,\n            context: context\n          });\n        } else {\n          var isDefered = false;\n          var isClient = false;\n\n          if (selection.directives && selection.directives.length) {\n            isDefered = selection.directives.some(function (directive) {\n              return directive.name && directive.name.value === 'defer';\n            });\n            isClient = selection.directives.some(function (directive) {\n              return directive.name && directive.name.value === 'client';\n            });\n          }\n\n          if (!isDefered && !isClient && context.fragmentMatcherFunction) {\n            process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing field \" + resultFieldKey + \" in \" + JSON.stringify(result, null, 2).substring(0, 100));\n          }\n        }\n      } else {\n        var fragment = void 0;\n\n        if (isInlineFragment(selection)) {\n          fragment = selection;\n        } else {\n          fragment = (fragmentMap || {})[selection.name.value];\n          process.env.NODE_ENV === \"production\" ? invariant(fragment, 3) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n        }\n\n        var matches = true;\n\n        if (context.fragmentMatcherFunction && fragment.typeCondition) {\n          var id = dataId || 'self';\n          var idValue = toIdValue({\n            id: id,\n            typename: undefined\n          });\n          var fakeContext = {\n            store: new ObjectCache((_a = {}, _a[id] = result, _a)),\n            cacheRedirects: {}\n          };\n          var match = context.fragmentMatcherFunction(idValue, fragment.typeCondition.name.value, fakeContext);\n\n          if (!isProduction() && match === 'heuristic') {\n            process.env.NODE_ENV === \"production\" || invariant.error('WARNING: heuristic fragment matching going on!');\n          }\n\n          matches = !!match;\n        }\n\n        if (matches) {\n          _this.writeSelectionSetToStore({\n            result: result,\n            selectionSet: fragment.selectionSet,\n            dataId: dataId,\n            context: context\n          });\n        }\n      }\n    });\n    return store;\n  };\n\n  StoreWriter.prototype.writeFieldToStore = function (_a) {\n    var _b;\n\n    var field = _a.field,\n        value = _a.value,\n        dataId = _a.dataId,\n        context = _a.context;\n    var variables = context.variables,\n        dataIdFromObject = context.dataIdFromObject,\n        store = context.store;\n    var storeValue;\n    var storeObject;\n    var storeFieldName = storeKeyNameFromField(field, variables);\n\n    if (!field.selectionSet || value === null) {\n      storeValue = value != null && typeof value === 'object' ? {\n        type: 'json',\n        json: value\n      } : value;\n    } else if (Array.isArray(value)) {\n      var generatedId = dataId + \".\" + storeFieldName;\n      storeValue = this.processArrayValue(value, generatedId, field.selectionSet, context);\n    } else {\n      var valueDataId = dataId + \".\" + storeFieldName;\n      var generated = true;\n\n      if (!isGeneratedId(valueDataId)) {\n        valueDataId = '$' + valueDataId;\n      }\n\n      if (dataIdFromObject) {\n        var semanticId = dataIdFromObject(value);\n        process.env.NODE_ENV === \"production\" ? invariant(!semanticId || !isGeneratedId(semanticId), 4) : invariant(!semanticId || !isGeneratedId(semanticId), 'IDs returned by dataIdFromObject cannot begin with the \"$\" character.');\n\n        if (semanticId || typeof semanticId === 'number' && semanticId === 0) {\n          valueDataId = semanticId;\n          generated = false;\n        }\n      }\n\n      if (!isDataProcessed(valueDataId, field, context.processedData)) {\n        this.writeSelectionSetToStore({\n          dataId: valueDataId,\n          result: value,\n          selectionSet: field.selectionSet,\n          context: context\n        });\n      }\n\n      var typename = value.__typename;\n      storeValue = toIdValue({\n        id: valueDataId,\n        typename: typename\n      }, generated);\n      storeObject = store.get(dataId);\n      var escapedId = storeObject && storeObject[storeFieldName];\n\n      if (escapedId !== storeValue && isIdValue(escapedId)) {\n        var hadTypename = escapedId.typename !== undefined;\n        var hasTypename = typename !== undefined;\n        var typenameChanged = hadTypename && hasTypename && escapedId.typename !== typename;\n        process.env.NODE_ENV === \"production\" ? invariant(!generated || escapedId.generated || typenameChanged, 5) : invariant(!generated || escapedId.generated || typenameChanged, \"Store error: the application attempted to write an object with no provided id but the store already contains an id of \" + escapedId.id + \" for this object. The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n        process.env.NODE_ENV === \"production\" ? invariant(!hadTypename || hasTypename, 6) : invariant(!hadTypename || hasTypename, \"Store error: the application attempted to write an object with no provided typename but the store already contains an object with typename of \" + escapedId.typename + \" for the object of id \" + escapedId.id + \". The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n\n        if (escapedId.generated) {\n          if (typenameChanged) {\n            if (!generated) {\n              store.delete(escapedId.id);\n            }\n          } else {\n            mergeWithGenerated(escapedId.id, storeValue.id, store);\n          }\n        }\n      }\n    }\n\n    storeObject = store.get(dataId);\n\n    if (!storeObject || !isEqual(storeValue, storeObject[storeFieldName])) {\n      store.set(dataId, __assign(__assign({}, storeObject), (_b = {}, _b[storeFieldName] = storeValue, _b)));\n    }\n  };\n\n  StoreWriter.prototype.processArrayValue = function (value, generatedId, selectionSet, context) {\n    var _this = this;\n\n    return value.map(function (item, index) {\n      if (item === null) {\n        return null;\n      }\n\n      var itemDataId = generatedId + \".\" + index;\n\n      if (Array.isArray(item)) {\n        return _this.processArrayValue(item, itemDataId, selectionSet, context);\n      }\n\n      var generated = true;\n\n      if (context.dataIdFromObject) {\n        var semanticId = context.dataIdFromObject(item);\n\n        if (semanticId) {\n          itemDataId = semanticId;\n          generated = false;\n        }\n      }\n\n      if (!isDataProcessed(itemDataId, selectionSet, context.processedData)) {\n        _this.writeSelectionSetToStore({\n          dataId: itemDataId,\n          result: item,\n          selectionSet: selectionSet,\n          context: context\n        });\n      }\n\n      return toIdValue({\n        id: itemDataId,\n        typename: item.__typename\n      }, generated);\n    });\n  };\n\n  return StoreWriter;\n}();\n\nfunction isGeneratedId(id) {\n  return id[0] === '$';\n}\n\nfunction mergeWithGenerated(generatedKey, realKey, cache) {\n  if (generatedKey === realKey) {\n    return false;\n  }\n\n  var generated = cache.get(generatedKey);\n  var real = cache.get(realKey);\n  var madeChanges = false;\n  Object.keys(generated).forEach(function (key) {\n    var value = generated[key];\n    var realValue = real[key];\n\n    if (isIdValue(value) && isGeneratedId(value.id) && isIdValue(realValue) && !isEqual(value, realValue) && mergeWithGenerated(value.id, realValue.id, cache)) {\n      madeChanges = true;\n    }\n  });\n  cache.delete(generatedKey);\n\n  var newRealValue = __assign(__assign({}, generated), real);\n\n  if (isEqual(newRealValue, real)) {\n    return madeChanges;\n  }\n\n  cache.set(realKey, newRealValue);\n  return true;\n}\n\nfunction isDataProcessed(dataId, field, processedData) {\n  if (!processedData) {\n    return false;\n  }\n\n  if (processedData[dataId]) {\n    if (processedData[dataId].indexOf(field) >= 0) {\n      return true;\n    } else {\n      processedData[dataId].push(field);\n    }\n  } else {\n    processedData[dataId] = [field];\n  }\n\n  return false;\n}\n\nvar defaultConfig = {\n  fragmentMatcher: new HeuristicFragmentMatcher(),\n  dataIdFromObject: defaultDataIdFromObject,\n  addTypename: true,\n  resultCaching: true,\n  freezeResults: false\n};\n\nfunction defaultDataIdFromObject(result) {\n  if (result.__typename) {\n    if (result.id !== undefined) {\n      return result.__typename + \":\" + result.id;\n    }\n\n    if (result._id !== undefined) {\n      return result.__typename + \":\" + result._id;\n    }\n  }\n\n  return null;\n}\n\nvar hasOwn$1 = Object.prototype.hasOwnProperty;\n\nvar OptimisticCacheLayer = function (_super) {\n  __extends(OptimisticCacheLayer, _super);\n\n  function OptimisticCacheLayer(optimisticId, parent, transaction) {\n    var _this = _super.call(this, Object.create(null)) || this;\n\n    _this.optimisticId = optimisticId;\n    _this.parent = parent;\n    _this.transaction = transaction;\n    return _this;\n  }\n\n  OptimisticCacheLayer.prototype.toObject = function () {\n    return __assign(__assign({}, this.parent.toObject()), this.data);\n  };\n\n  OptimisticCacheLayer.prototype.get = function (dataId) {\n    return hasOwn$1.call(this.data, dataId) ? this.data[dataId] : this.parent.get(dataId);\n  };\n\n  return OptimisticCacheLayer;\n}(ObjectCache);\n\nvar InMemoryCache = function (_super) {\n  __extends(InMemoryCache, _super);\n\n  function InMemoryCache(config) {\n    if (config === void 0) {\n      config = {};\n    }\n\n    var _this = _super.call(this) || this;\n\n    _this.watches = new Set();\n    _this.typenameDocumentCache = new Map();\n    _this.cacheKeyRoot = new KeyTrie(canUseWeakMap);\n    _this.silenceBroadcast = false;\n    _this.config = __assign(__assign({}, defaultConfig), config);\n\n    if (_this.config.customResolvers) {\n      process.env.NODE_ENV === \"production\" || invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');\n      _this.config.cacheRedirects = _this.config.customResolvers;\n    }\n\n    if (_this.config.cacheResolvers) {\n      process.env.NODE_ENV === \"production\" || invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');\n      _this.config.cacheRedirects = _this.config.cacheResolvers;\n    }\n\n    _this.addTypename = !!_this.config.addTypename;\n    _this.data = _this.config.resultCaching ? new DepTrackingCache() : new ObjectCache();\n    _this.optimisticData = _this.data;\n    _this.storeWriter = new StoreWriter();\n    _this.storeReader = new StoreReader({\n      cacheKeyRoot: _this.cacheKeyRoot,\n      freezeResults: config.freezeResults\n    });\n    var cache = _this;\n    var maybeBroadcastWatch = cache.maybeBroadcastWatch;\n    _this.maybeBroadcastWatch = wrap(function (c) {\n      return maybeBroadcastWatch.call(_this, c);\n    }, {\n      makeCacheKey: function makeCacheKey(c) {\n        if (c.optimistic) {\n          return;\n        }\n\n        if (c.previousResult) {\n          return;\n        }\n\n        if (cache.data instanceof DepTrackingCache) {\n          return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));\n        }\n      }\n    });\n    return _this;\n  }\n\n  InMemoryCache.prototype.restore = function (data) {\n    if (data) this.data.replace(data);\n    return this;\n  };\n\n  InMemoryCache.prototype.extract = function (optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return (optimistic ? this.optimisticData : this.data).toObject();\n  };\n\n  InMemoryCache.prototype.read = function (options) {\n    if (typeof options.rootId === 'string' && typeof this.data.get(options.rootId) === 'undefined') {\n      return null;\n    }\n\n    var fragmentMatcher = this.config.fragmentMatcher;\n    var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n    return this.storeReader.readQueryFromStore({\n      store: options.optimistic ? this.optimisticData : this.data,\n      query: this.transformDocument(options.query),\n      variables: options.variables,\n      rootId: options.rootId,\n      fragmentMatcherFunction: fragmentMatcherFunction,\n      previousResult: options.previousResult,\n      config: this.config\n    }) || null;\n  };\n\n  InMemoryCache.prototype.write = function (write) {\n    var fragmentMatcher = this.config.fragmentMatcher;\n    var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n    this.storeWriter.writeResultToStore({\n      dataId: write.dataId,\n      result: write.result,\n      variables: write.variables,\n      document: this.transformDocument(write.query),\n      store: this.data,\n      dataIdFromObject: this.config.dataIdFromObject,\n      fragmentMatcherFunction: fragmentMatcherFunction\n    });\n    this.broadcastWatches();\n  };\n\n  InMemoryCache.prototype.diff = function (query) {\n    var fragmentMatcher = this.config.fragmentMatcher;\n    var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n    return this.storeReader.diffQueryAgainstStore({\n      store: query.optimistic ? this.optimisticData : this.data,\n      query: this.transformDocument(query.query),\n      variables: query.variables,\n      returnPartialData: query.returnPartialData,\n      previousResult: query.previousResult,\n      fragmentMatcherFunction: fragmentMatcherFunction,\n      config: this.config\n    });\n  };\n\n  InMemoryCache.prototype.watch = function (watch) {\n    var _this = this;\n\n    this.watches.add(watch);\n    return function () {\n      _this.watches.delete(watch);\n    };\n  };\n\n  InMemoryCache.prototype.evict = function (query) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(7) : new InvariantError(\"eviction is not implemented on InMemory Cache\");\n  };\n\n  InMemoryCache.prototype.reset = function () {\n    this.data.clear();\n    this.broadcastWatches();\n    return Promise.resolve();\n  };\n\n  InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n    var toReapply = [];\n    var removedCount = 0;\n    var layer = this.optimisticData;\n\n    while (layer instanceof OptimisticCacheLayer) {\n      if (layer.optimisticId === idToRemove) {\n        ++removedCount;\n      } else {\n        toReapply.push(layer);\n      }\n\n      layer = layer.parent;\n    }\n\n    if (removedCount > 0) {\n      this.optimisticData = layer;\n\n      while (toReapply.length > 0) {\n        var layer_1 = toReapply.pop();\n        this.performTransaction(layer_1.transaction, layer_1.optimisticId);\n      }\n\n      this.broadcastWatches();\n    }\n  };\n\n  InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n    var _a = this,\n        data = _a.data,\n        silenceBroadcast = _a.silenceBroadcast;\n\n    this.silenceBroadcast = true;\n\n    if (typeof optimisticId === 'string') {\n      this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);\n    }\n\n    try {\n      transaction(this);\n    } finally {\n      this.silenceBroadcast = silenceBroadcast;\n      this.data = data;\n    }\n\n    this.broadcastWatches();\n  };\n\n  InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {\n    return this.performTransaction(transaction, id);\n  };\n\n  InMemoryCache.prototype.transformDocument = function (document) {\n    if (this.addTypename) {\n      var result = this.typenameDocumentCache.get(document);\n\n      if (!result) {\n        result = addTypenameToDocument(document);\n        this.typenameDocumentCache.set(document, result);\n        this.typenameDocumentCache.set(result, result);\n      }\n\n      return result;\n    }\n\n    return document;\n  };\n\n  InMemoryCache.prototype.broadcastWatches = function () {\n    var _this = this;\n\n    if (!this.silenceBroadcast) {\n      this.watches.forEach(function (c) {\n        return _this.maybeBroadcastWatch(c);\n      });\n    }\n  };\n\n  InMemoryCache.prototype.maybeBroadcastWatch = function (c) {\n    c.callback(this.diff({\n      query: c.query,\n      variables: c.variables,\n      previousResult: c.previousResult && c.previousResult(),\n      optimistic: c.optimistic\n    }));\n  };\n\n  return InMemoryCache;\n}(ApolloCache);\n\nexport { HeuristicFragmentMatcher, InMemoryCache, IntrospectionFragmentMatcher, ObjectCache, StoreReader, StoreWriter, WriteError, assertIdValue, defaultDataIdFromObject, defaultNormalizedCacheFactory$1 as defaultNormalizedCacheFactory, enhanceErrorWithDocument };","import { __assign, __extends } from 'tslib';\nimport { Observable, ApolloLink } from 'apollo-link';\n\nvar OperationBatcher = function () {\n  function OperationBatcher(_a) {\n    var batchInterval = _a.batchInterval,\n        batchMax = _a.batchMax,\n        batchHandler = _a.batchHandler,\n        batchKey = _a.batchKey;\n    this.queuedRequests = new Map();\n    this.batchInterval = batchInterval;\n    this.batchMax = batchMax || 0;\n    this.batchHandler = batchHandler;\n\n    this.batchKey = batchKey || function () {\n      return '';\n    };\n  }\n\n  OperationBatcher.prototype.enqueueRequest = function (request) {\n    var _this = this;\n\n    var requestCopy = __assign({}, request);\n\n    var queued = false;\n    var key = this.batchKey(request.operation);\n\n    if (!requestCopy.observable) {\n      requestCopy.observable = new Observable(function (observer) {\n        if (!_this.queuedRequests.has(key)) {\n          _this.queuedRequests.set(key, []);\n        }\n\n        if (!queued) {\n          _this.queuedRequests.get(key).push(requestCopy);\n\n          queued = true;\n        }\n\n        requestCopy.next = requestCopy.next || [];\n        if (observer.next) requestCopy.next.push(observer.next.bind(observer));\n        requestCopy.error = requestCopy.error || [];\n        if (observer.error) requestCopy.error.push(observer.error.bind(observer));\n        requestCopy.complete = requestCopy.complete || [];\n        if (observer.complete) requestCopy.complete.push(observer.complete.bind(observer));\n\n        if (_this.queuedRequests.get(key).length === 1) {\n          _this.scheduleQueueConsumption(key);\n        }\n\n        if (_this.queuedRequests.get(key).length === _this.batchMax) {\n          _this.consumeQueue(key);\n        }\n      });\n    }\n\n    return requestCopy.observable;\n  };\n\n  OperationBatcher.prototype.consumeQueue = function (key) {\n    var requestKey = key || '';\n    var queuedRequests = this.queuedRequests.get(requestKey);\n\n    if (!queuedRequests) {\n      return;\n    }\n\n    this.queuedRequests.delete(requestKey);\n    var requests = queuedRequests.map(function (queuedRequest) {\n      return queuedRequest.operation;\n    });\n    var forwards = queuedRequests.map(function (queuedRequest) {\n      return queuedRequest.forward;\n    });\n    var observables = [];\n    var nexts = [];\n    var errors = [];\n    var completes = [];\n    queuedRequests.forEach(function (batchableRequest, index) {\n      observables.push(batchableRequest.observable);\n      nexts.push(batchableRequest.next);\n      errors.push(batchableRequest.error);\n      completes.push(batchableRequest.complete);\n    });\n    var batchedObservable = this.batchHandler(requests, forwards) || Observable.of();\n\n    var onError = function onError(error) {\n      errors.forEach(function (rejecters) {\n        if (rejecters) {\n          rejecters.forEach(function (e) {\n            return e(error);\n          });\n        }\n      });\n    };\n\n    batchedObservable.subscribe({\n      next: function next(results) {\n        if (!Array.isArray(results)) {\n          results = [results];\n        }\n\n        if (nexts.length !== results.length) {\n          var error = new Error(\"server returned results with length \" + results.length + \", expected length of \" + nexts.length);\n          error.result = results;\n          return onError(error);\n        }\n\n        results.forEach(function (result, index) {\n          if (nexts[index]) {\n            nexts[index].forEach(function (next) {\n              return next(result);\n            });\n          }\n        });\n      },\n      error: onError,\n      complete: function complete() {\n        completes.forEach(function (complete) {\n          if (complete) {\n            complete.forEach(function (c) {\n              return c();\n            });\n          }\n        });\n      }\n    });\n    return observables;\n  };\n\n  OperationBatcher.prototype.scheduleQueueConsumption = function (key) {\n    var _this = this;\n\n    var requestKey = key || '';\n    setTimeout(function () {\n      if (_this.queuedRequests.get(requestKey) && _this.queuedRequests.get(requestKey).length) {\n        _this.consumeQueue(requestKey);\n      }\n    }, this.batchInterval);\n  };\n\n  return OperationBatcher;\n}();\n\nvar BatchLink = function (_super) {\n  __extends(BatchLink, _super);\n\n  function BatchLink(fetchParams) {\n    var _this = _super.call(this) || this;\n\n    var _a = fetchParams || {},\n        _b = _a.batchInterval,\n        batchInterval = _b === void 0 ? 10 : _b,\n        _c = _a.batchMax,\n        batchMax = _c === void 0 ? 0 : _c,\n        _d = _a.batchHandler,\n        batchHandler = _d === void 0 ? function () {\n      return null;\n    } : _d,\n        _e = _a.batchKey,\n        batchKey = _e === void 0 ? function () {\n      return '';\n    } : _e;\n\n    _this.batcher = new OperationBatcher({\n      batchInterval: batchInterval,\n      batchMax: batchMax,\n      batchHandler: batchHandler,\n      batchKey: batchKey\n    });\n\n    if (fetchParams.batchHandler.length <= 1) {\n      _this.request = function (operation) {\n        return _this.batcher.enqueueRequest({\n          operation: operation\n        });\n      };\n    }\n\n    return _this;\n  }\n\n  BatchLink.prototype.request = function (operation, forward) {\n    return this.batcher.enqueueRequest({\n      operation: operation,\n      forward: forward\n    });\n  };\n\n  return BatchLink;\n}(ApolloLink);\n\nexport { BatchLink, OperationBatcher };","import { __extends, __rest, __assign } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, serializeFetchParameter, createSignalIfSupported, parseAndCheckHttpResponse } from 'apollo-link-http-common';\nimport { BatchLink } from 'apollo-link-batch';\n\nvar BatchHttpLink = function (_super) {\n  __extends(BatchHttpLink, _super);\n\n  function BatchHttpLink(fetchParams) {\n    var _this = _super.call(this) || this;\n\n    var _a = fetchParams || {},\n        _b = _a.uri,\n        uri = _b === void 0 ? '/graphql' : _b,\n        fetcher = _a.fetch,\n        includeExtensions = _a.includeExtensions,\n        batchInterval = _a.batchInterval,\n        batchMax = _a.batchMax,\n        batchKey = _a.batchKey,\n        requestOptions = __rest(_a, [\"uri\", \"fetch\", \"includeExtensions\", \"batchInterval\", \"batchMax\", \"batchKey\"]);\n\n    checkFetcher(fetcher);\n\n    if (!fetcher) {\n      fetcher = fetch;\n    }\n\n    var linkConfig = {\n      http: {\n        includeExtensions: includeExtensions\n      },\n      options: requestOptions.fetchOptions,\n      credentials: requestOptions.credentials,\n      headers: requestOptions.headers\n    };\n    _this.batchInterval = batchInterval || 10;\n    _this.batchMax = batchMax || 10;\n\n    var batchHandler = function batchHandler(operations) {\n      var chosenURI = selectURI(operations[0], uri);\n      var context = operations[0].getContext();\n      var clientAwarenessHeaders = {};\n\n      if (context.clientAwareness) {\n        var _a = context.clientAwareness,\n            name_1 = _a.name,\n            version = _a.version;\n\n        if (name_1) {\n          clientAwarenessHeaders['apollographql-client-name'] = name_1;\n        }\n\n        if (version) {\n          clientAwarenessHeaders['apollographql-client-version'] = version;\n        }\n      }\n\n      var contextConfig = {\n        http: context.http,\n        options: context.fetchOptions,\n        credentials: context.credentials,\n        headers: __assign({}, clientAwarenessHeaders, context.headers)\n      };\n      var optsAndBody = operations.map(function (operation) {\n        return selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig);\n      });\n      var loadedBody = optsAndBody.map(function (_a) {\n        var body = _a.body;\n        return body;\n      });\n      var options = optsAndBody[0].options;\n\n      if (options.method === 'GET') {\n        return fromError(new Error('apollo-link-batch-http does not support GET requests'));\n      }\n\n      try {\n        options.body = serializeFetchParameter(loadedBody, 'Payload');\n      } catch (parseError) {\n        return fromError(parseError);\n      }\n\n      var controller;\n\n      if (!options.signal) {\n        var _b = createSignalIfSupported(),\n            _controller = _b.controller,\n            signal = _b.signal;\n\n        controller = _controller;\n        if (controller) options.signal = signal;\n      }\n\n      return new Observable(function (observer) {\n        fetcher(chosenURI, options).then(function (response) {\n          operations.forEach(function (operation) {\n            return operation.setContext({\n              response: response\n            });\n          });\n          return response;\n        }).then(parseAndCheckHttpResponse(operations)).then(function (result) {\n          observer.next(result);\n          observer.complete();\n          return result;\n        }).catch(function (err) {\n          if (err.name === 'AbortError') return;\n\n          if (err.result && err.result.errors && err.result.data) {\n            observer.next(err.result);\n          }\n\n          observer.error(err);\n        });\n        return function () {\n          if (controller) controller.abort();\n        };\n      });\n    };\n\n    batchKey = batchKey || function (operation) {\n      var context = operation.getContext();\n      var contextConfig = {\n        http: context.http,\n        options: context.fetchOptions,\n        credentials: context.credentials,\n        headers: context.headers\n      };\n      return selectURI(operation, uri) + JSON.stringify(contextConfig);\n    };\n\n    _this.batcher = new BatchLink({\n      batchInterval: _this.batchInterval,\n      batchMax: _this.batchMax,\n      batchKey: batchKey,\n      batchHandler: batchHandler\n    });\n    return _this;\n  }\n\n  BatchHttpLink.prototype.request = function (operation) {\n    return this.batcher.request(operation);\n  };\n\n  return BatchHttpLink;\n}(ApolloLink);\n\nexport { BatchHttpLink };","import Observable from 'zen-observable-ts';\nexport { default as Observable } from 'zen-observable-ts';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { __extends, __assign } from 'tslib';\nimport { getOperationName } from 'apollo-utilities';\nexport { getOperationName } from 'apollo-utilities';\n\nfunction validateOperation(operation) {\n  var OPERATION_FIELDS = ['query', 'operationName', 'variables', 'extensions', 'context'];\n\n  for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n    var key = _a[_i];\n\n    if (OPERATION_FIELDS.indexOf(key) < 0) {\n      throw process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"illegal argument: \" + key);\n    }\n  }\n\n  return operation;\n}\n\nvar LinkError = function (_super) {\n  __extends(LinkError, _super);\n\n  function LinkError(message, link) {\n    var _this = _super.call(this, message) || this;\n\n    _this.link = link;\n    return _this;\n  }\n\n  return LinkError;\n}(Error);\n\nfunction isTerminating(link) {\n  return link.request.length <= 1;\n}\n\nfunction toPromise(observable) {\n  var completed = false;\n  return new Promise(function (resolve, reject) {\n    observable.subscribe({\n      next: function next(data) {\n        if (completed) {\n          process.env.NODE_ENV === \"production\" || invariant.warn(\"Promise Wrapper does not support multiple results from Observable\");\n        } else {\n          completed = true;\n          resolve(data);\n        }\n      },\n      error: reject\n    });\n  });\n}\n\nvar makePromise = toPromise;\n\nfunction fromPromise(promise) {\n  return new Observable(function (observer) {\n    promise.then(function (value) {\n      observer.next(value);\n      observer.complete();\n    }).catch(observer.error.bind(observer));\n  });\n}\n\nfunction fromError(errorValue) {\n  return new Observable(function (observer) {\n    observer.error(errorValue);\n  });\n}\n\nfunction transformOperation(operation) {\n  var transformedOperation = {\n    variables: operation.variables || {},\n    extensions: operation.extensions || {},\n    operationName: operation.operationName,\n    query: operation.query\n  };\n\n  if (!transformedOperation.operationName) {\n    transformedOperation.operationName = typeof transformedOperation.query !== 'string' ? getOperationName(transformedOperation.query) : '';\n  }\n\n  return transformedOperation;\n}\n\nfunction createOperation(starting, operation) {\n  var context = __assign({}, starting);\n\n  var setContext = function setContext(next) {\n    if (typeof next === 'function') {\n      context = __assign({}, context, next(context));\n    } else {\n      context = __assign({}, context, next);\n    }\n  };\n\n  var getContext = function getContext() {\n    return __assign({}, context);\n  };\n\n  Object.defineProperty(operation, 'setContext', {\n    enumerable: false,\n    value: setContext\n  });\n  Object.defineProperty(operation, 'getContext', {\n    enumerable: false,\n    value: getContext\n  });\n  Object.defineProperty(operation, 'toKey', {\n    enumerable: false,\n    value: function value() {\n      return getKey(operation);\n    }\n  });\n  return operation;\n}\n\nfunction getKey(operation) {\n  var query = operation.query,\n      variables = operation.variables,\n      operationName = operation.operationName;\n  return JSON.stringify([operationName, query, variables]);\n}\n\nfunction passthrough(op, forward) {\n  return forward ? forward(op) : Observable.of();\n}\n\nfunction toLink(handler) {\n  return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\n\nfunction empty() {\n  return new ApolloLink(function () {\n    return Observable.of();\n  });\n}\n\nfunction from(links) {\n  if (links.length === 0) return empty();\n  return links.map(toLink).reduce(function (x, y) {\n    return x.concat(y);\n  });\n}\n\nfunction split(test, left, right) {\n  var leftLink = toLink(left);\n  var rightLink = toLink(right || new ApolloLink(passthrough));\n\n  if (isTerminating(leftLink) && isTerminating(rightLink)) {\n    return new ApolloLink(function (operation) {\n      return test(operation) ? leftLink.request(operation) || Observable.of() : rightLink.request(operation) || Observable.of();\n    });\n  } else {\n    return new ApolloLink(function (operation, forward) {\n      return test(operation) ? leftLink.request(operation, forward) || Observable.of() : rightLink.request(operation, forward) || Observable.of();\n    });\n  }\n}\n\nvar concat = function concat(first, second) {\n  var firstLink = toLink(first);\n\n  if (isTerminating(firstLink)) {\n    process.env.NODE_ENV === \"production\" || invariant.warn(new LinkError(\"You are calling concat on a terminating link, which will have no effect\", firstLink));\n    return firstLink;\n  }\n\n  var nextLink = toLink(second);\n\n  if (isTerminating(nextLink)) {\n    return new ApolloLink(function (operation) {\n      return firstLink.request(operation, function (op) {\n        return nextLink.request(op) || Observable.of();\n      }) || Observable.of();\n    });\n  } else {\n    return new ApolloLink(function (operation, forward) {\n      return firstLink.request(operation, function (op) {\n        return nextLink.request(op, forward) || Observable.of();\n      }) || Observable.of();\n    });\n  }\n};\n\nvar ApolloLink = function () {\n  function ApolloLink(request) {\n    if (request) this.request = request;\n  }\n\n  ApolloLink.prototype.split = function (test, left, right) {\n    return this.concat(split(test, left, right || new ApolloLink(passthrough)));\n  };\n\n  ApolloLink.prototype.concat = function (next) {\n    return concat(this, next);\n  };\n\n  ApolloLink.prototype.request = function (operation, forward) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('request is not implemented');\n  };\n\n  ApolloLink.empty = empty;\n  ApolloLink.from = from;\n  ApolloLink.split = split;\n  ApolloLink.execute = execute;\n  return ApolloLink;\n}();\n\nfunction execute(link, operation) {\n  return link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of();\n}\n\nexport { ApolloLink, concat, createOperation, empty, execute, from, fromError, fromPromise, makePromise, split, toPromise };","import { __rest, __assign, __extends } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, createSignalIfSupported, serializeFetchParameter, parseAndCheckHttpResponse } from 'apollo-link-http-common';\n\nvar createHttpLink = function createHttpLink(linkOptions) {\n  if (linkOptions === void 0) {\n    linkOptions = {};\n  }\n\n  var _a = linkOptions.uri,\n      uri = _a === void 0 ? '/graphql' : _a,\n      fetcher = linkOptions.fetch,\n      includeExtensions = linkOptions.includeExtensions,\n      useGETForQueries = linkOptions.useGETForQueries,\n      requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"includeExtensions\", \"useGETForQueries\"]);\n\n  checkFetcher(fetcher);\n\n  if (!fetcher) {\n    fetcher = fetch;\n  }\n\n  var linkConfig = {\n    http: {\n      includeExtensions: includeExtensions\n    },\n    options: requestOptions.fetchOptions,\n    credentials: requestOptions.credentials,\n    headers: requestOptions.headers\n  };\n  return new ApolloLink(function (operation) {\n    var chosenURI = selectURI(operation, uri);\n    var context = operation.getContext();\n    var clientAwarenessHeaders = {};\n\n    if (context.clientAwareness) {\n      var _a = context.clientAwareness,\n          name_1 = _a.name,\n          version = _a.version;\n\n      if (name_1) {\n        clientAwarenessHeaders['apollographql-client-name'] = name_1;\n      }\n\n      if (version) {\n        clientAwarenessHeaders['apollographql-client-version'] = version;\n      }\n    }\n\n    var contextHeaders = __assign({}, clientAwarenessHeaders, context.headers);\n\n    var contextConfig = {\n      http: context.http,\n      options: context.fetchOptions,\n      credentials: context.credentials,\n      headers: contextHeaders\n    };\n\n    var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig),\n        options = _b.options,\n        body = _b.body;\n\n    var controller;\n\n    if (!options.signal) {\n      var _c = createSignalIfSupported(),\n          _controller = _c.controller,\n          signal = _c.signal;\n\n      controller = _controller;\n      if (controller) options.signal = signal;\n    }\n\n    var definitionIsMutation = function definitionIsMutation(d) {\n      return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n    };\n\n    if (useGETForQueries && !operation.query.definitions.some(definitionIsMutation)) {\n      options.method = 'GET';\n    }\n\n    if (options.method === 'GET') {\n      var _d = rewriteURIForGET(chosenURI, body),\n          newURI = _d.newURI,\n          parseError = _d.parseError;\n\n      if (parseError) {\n        return fromError(parseError);\n      }\n\n      chosenURI = newURI;\n    } else {\n      try {\n        options.body = serializeFetchParameter(body, 'Payload');\n      } catch (parseError) {\n        return fromError(parseError);\n      }\n    }\n\n    return new Observable(function (observer) {\n      fetcher(chosenURI, options).then(function (response) {\n        operation.setContext({\n          response: response\n        });\n        return response;\n      }).then(parseAndCheckHttpResponse(operation)).then(function (result) {\n        observer.next(result);\n        observer.complete();\n        return result;\n      }).catch(function (err) {\n        if (err.name === 'AbortError') return;\n\n        if (err.result && err.result.errors && err.result.data) {\n          observer.next(err.result);\n        }\n\n        observer.error(err);\n      });\n      return function () {\n        if (controller) controller.abort();\n      };\n    });\n  });\n};\n\nfunction rewriteURIForGET(chosenURI, body) {\n  var queryParams = [];\n\n  var addQueryParam = function addQueryParam(key, value) {\n    queryParams.push(key + \"=\" + encodeURIComponent(value));\n  };\n\n  if ('query' in body) {\n    addQueryParam('query', body.query);\n  }\n\n  if (body.operationName) {\n    addQueryParam('operationName', body.operationName);\n  }\n\n  if (body.variables) {\n    var serializedVariables = void 0;\n\n    try {\n      serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n    } catch (parseError) {\n      return {\n        parseError: parseError\n      };\n    }\n\n    addQueryParam('variables', serializedVariables);\n  }\n\n  if (body.extensions) {\n    var serializedExtensions = void 0;\n\n    try {\n      serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n    } catch (parseError) {\n      return {\n        parseError: parseError\n      };\n    }\n\n    addQueryParam('extensions', serializedExtensions);\n  }\n\n  var fragment = '',\n      preFragment = chosenURI;\n  var fragmentStart = chosenURI.indexOf('#');\n\n  if (fragmentStart !== -1) {\n    fragment = chosenURI.substr(fragmentStart);\n    preFragment = chosenURI.substr(0, fragmentStart);\n  }\n\n  var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n  var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n  return {\n    newURI: newURI\n  };\n}\n\nvar HttpLink = function (_super) {\n  __extends(HttpLink, _super);\n\n  function HttpLink(opts) {\n    return _super.call(this, createHttpLink(opts).request) || this;\n  }\n\n  return HttpLink;\n}(ApolloLink);\n\nexport { HttpLink, createHttpLink };","import { __extends } from 'tslib';\nimport { ApolloLink, Observable } from 'apollo-link';\n\nfunction onError(errorHandler) {\n  return new ApolloLink(function (operation, forward) {\n    return new Observable(function (observer) {\n      var sub;\n      var retriedSub;\n      var retriedResult;\n\n      try {\n        sub = forward(operation).subscribe({\n          next: function next(result) {\n            if (result.errors) {\n              retriedResult = errorHandler({\n                graphQLErrors: result.errors,\n                response: result,\n                operation: operation,\n                forward: forward\n              });\n\n              if (retriedResult) {\n                retriedSub = retriedResult.subscribe({\n                  next: observer.next.bind(observer),\n                  error: observer.error.bind(observer),\n                  complete: observer.complete.bind(observer)\n                });\n                return;\n              }\n            }\n\n            observer.next(result);\n          },\n          error: function error(networkError) {\n            retriedResult = errorHandler({\n              operation: operation,\n              networkError: networkError,\n              graphQLErrors: networkError && networkError.result && networkError.result.errors,\n              forward: forward\n            });\n\n            if (retriedResult) {\n              retriedSub = retriedResult.subscribe({\n                next: observer.next.bind(observer),\n                error: observer.error.bind(observer),\n                complete: observer.complete.bind(observer)\n              });\n              return;\n            }\n\n            observer.error(networkError);\n          },\n          complete: function complete() {\n            if (!retriedResult) {\n              observer.complete.bind(observer)();\n            }\n          }\n        });\n      } catch (e) {\n        errorHandler({\n          networkError: e,\n          operation: operation,\n          forward: forward\n        });\n        observer.error(e);\n      }\n\n      return function () {\n        if (sub) sub.unsubscribe();\n        if (retriedSub) sub.unsubscribe();\n      };\n    });\n  });\n}\n\nvar ErrorLink = function (_super) {\n  __extends(ErrorLink, _super);\n\n  function ErrorLink(errorHandler) {\n    var _this = _super.call(this) || this;\n\n    _this.link = onError(errorHandler);\n    return _this;\n  }\n\n  ErrorLink.prototype.request = function (operation, forward) {\n    return this.link.request(operation, forward);\n  };\n\n  return ErrorLink;\n}(ApolloLink);\n\nexport { ErrorLink, onError };","import { __extends, __awaiter, __generator } from 'tslib';\nimport { Observable, ApolloLink } from 'apollo-link';\n\nfunction buildDelayFunction(delayOptions) {\n  var _a = delayOptions || {},\n      _b = _a.initial,\n      initial = _b === void 0 ? 300 : _b,\n      _c = _a.jitter,\n      jitter = _c === void 0 ? true : _c,\n      _d = _a.max,\n      max = _d === void 0 ? Infinity : _d;\n\n  var baseDelay = jitter ? initial : initial / 2;\n  return function delayFunction(count) {\n    var delay = Math.min(max, baseDelay * Math.pow(2, count));\n\n    if (jitter) {\n      delay = Math.random() * delay;\n    }\n\n    return delay;\n  };\n}\n\nfunction buildRetryFunction(retryOptions) {\n  var _a = retryOptions || {},\n      retryIf = _a.retryIf,\n      _b = _a.max,\n      max = _b === void 0 ? 5 : _b;\n\n  return function retryFunction(count, operation, error) {\n    if (count >= max) return false;\n    return retryIf ? retryIf(error, operation) : !!error;\n  };\n}\n\nvar RetryableOperation = function () {\n  function RetryableOperation(operation, nextLink, delayFor, retryIf) {\n    var _this = this;\n\n    this.operation = operation;\n    this.nextLink = nextLink;\n    this.delayFor = delayFor;\n    this.retryIf = retryIf;\n    this.retryCount = 0;\n    this.values = [];\n    this.complete = false;\n    this.canceled = false;\n    this.observers = [];\n    this.currentSubscription = null;\n\n    this.onNext = function (value) {\n      _this.values.push(value);\n\n      for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n        var observer = _a[_i];\n        if (!observer) continue;\n        observer.next(value);\n      }\n    };\n\n    this.onComplete = function () {\n      _this.complete = true;\n\n      for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n        var observer = _a[_i];\n        if (!observer) continue;\n        observer.complete();\n      }\n    };\n\n    this.onError = function (error) {\n      return __awaiter(_this, void 0, void 0, function () {\n        var shouldRetry, _i, _a, observer;\n\n        return __generator(this, function (_b) {\n          switch (_b.label) {\n            case 0:\n              this.retryCount += 1;\n              return [4, this.retryIf(this.retryCount, this.operation, error)];\n\n            case 1:\n              shouldRetry = _b.sent();\n\n              if (shouldRetry) {\n                this.scheduleRetry(this.delayFor(this.retryCount, this.operation, error));\n                return [2];\n              }\n\n              this.error = error;\n\n              for (_i = 0, _a = this.observers; _i < _a.length; _i++) {\n                observer = _a[_i];\n                if (!observer) continue;\n                observer.error(error);\n              }\n\n              return [2];\n          }\n        });\n      });\n    };\n  }\n\n  RetryableOperation.prototype.subscribe = function (observer) {\n    if (this.canceled) {\n      throw new Error(\"Subscribing to a retryable link that was canceled is not supported\");\n    }\n\n    this.observers.push(observer);\n\n    for (var _i = 0, _a = this.values; _i < _a.length; _i++) {\n      var value = _a[_i];\n      observer.next(value);\n    }\n\n    if (this.complete) {\n      observer.complete();\n    } else if (this.error) {\n      observer.error(this.error);\n    }\n  };\n\n  RetryableOperation.prototype.unsubscribe = function (observer) {\n    var index = this.observers.indexOf(observer);\n\n    if (index < 0) {\n      throw new Error(\"RetryLink BUG! Attempting to unsubscribe unknown observer!\");\n    }\n\n    this.observers[index] = null;\n\n    if (this.observers.every(function (o) {\n      return o === null;\n    })) {\n      this.cancel();\n    }\n  };\n\n  RetryableOperation.prototype.start = function () {\n    if (this.currentSubscription) return;\n    this.try();\n  };\n\n  RetryableOperation.prototype.cancel = function () {\n    if (this.currentSubscription) {\n      this.currentSubscription.unsubscribe();\n    }\n\n    clearTimeout(this.timerId);\n    this.timerId = null;\n    this.currentSubscription = null;\n    this.canceled = true;\n  };\n\n  RetryableOperation.prototype.try = function () {\n    this.currentSubscription = this.nextLink(this.operation).subscribe({\n      next: this.onNext,\n      error: this.onError,\n      complete: this.onComplete\n    });\n  };\n\n  RetryableOperation.prototype.scheduleRetry = function (delay) {\n    var _this = this;\n\n    if (this.timerId) {\n      throw new Error(\"RetryLink BUG! Encountered overlapping retries\");\n    }\n\n    this.timerId = setTimeout(function () {\n      _this.timerId = null;\n\n      _this.try();\n    }, delay);\n  };\n\n  return RetryableOperation;\n}();\n\nvar RetryLink = function (_super) {\n  __extends(RetryLink, _super);\n\n  function RetryLink(options) {\n    var _this = _super.call(this) || this;\n\n    var _a = options || {},\n        attempts = _a.attempts,\n        delay = _a.delay;\n\n    _this.delayFor = typeof delay === 'function' ? delay : buildDelayFunction(delay);\n    _this.retryIf = typeof attempts === 'function' ? attempts : buildRetryFunction(attempts);\n    return _this;\n  }\n\n  RetryLink.prototype.request = function (operation, nextLink) {\n    var retryable = new RetryableOperation(operation, nextLink, this.delayFor, this.retryIf);\n    retryable.start();\n    return new Observable(function (observer) {\n      retryable.subscribe(observer);\n      return function () {\n        retryable.unsubscribe(observer);\n      };\n    });\n  };\n\n  return RetryLink;\n}(ApolloLink);\n\nexport { RetryLink };","var _a = Object.prototype,\n    toString = _a.toString,\n    hasOwnProperty = _a.hasOwnProperty;\nvar previousComparisons = new Map();\n/**\r\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\r\n */\n\nfunction equal(a, b) {\n  try {\n    return check(a, b);\n  } finally {\n    previousComparisons.clear();\n  }\n}\n\nfunction check(a, b) {\n  // If the two values are strictly equal, our job is easy.\n  if (a === b) {\n    return true;\n  } // Object.prototype.toString returns a representation of the runtime type of\n  // the given value that is considerably more precise than typeof.\n\n\n  var aTag = toString.call(a);\n  var bTag = toString.call(b); // If the runtime types of a and b are different, they could maybe be equal\n  // under some interpretation of equality, but for simplicity and performance\n  // we just return false instead.\n\n  if (aTag !== bTag) {\n    return false;\n  }\n\n  switch (aTag) {\n    case '[object Array]':\n      // Arrays are a lot like other objects, but we can cheaply compare their\n      // lengths as a short-cut before comparing their elements.\n      if (a.length !== b.length) return false;\n    // Fall through to object case...\n\n    case '[object Object]':\n      {\n        if (previouslyCompared(a, b)) return true;\n        var aKeys = Object.keys(a);\n        var bKeys = Object.keys(b); // If `a` and `b` have a different number of enumerable keys, they\n        // must be different.\n\n        var keyCount = aKeys.length;\n        if (keyCount !== bKeys.length) return false; // Now make sure they have the same keys.\n\n        for (var k = 0; k < keyCount; ++k) {\n          if (!hasOwnProperty.call(b, aKeys[k])) {\n            return false;\n          }\n        } // Finally, check deep equality of all child properties.\n\n\n        for (var k = 0; k < keyCount; ++k) {\n          var key = aKeys[k];\n\n          if (!check(a[key], b[key])) {\n            return false;\n          }\n        }\n\n        return true;\n      }\n\n    case '[object Error]':\n      return a.name === b.name && a.message === b.message;\n\n    case '[object Number]':\n      // Handle NaN, which is !== itself.\n      if (a !== a) return b !== b;\n    // Fall through to shared +a === +b case...\n\n    case '[object Boolean]':\n    case '[object Date]':\n      return +a === +b;\n\n    case '[object RegExp]':\n    case '[object String]':\n      return a == \"\" + b;\n\n    case '[object Map]':\n    case '[object Set]':\n      {\n        if (a.size !== b.size) return false;\n        if (previouslyCompared(a, b)) return true;\n        var aIterator = a.entries();\n        var isMap = aTag === '[object Map]';\n\n        while (true) {\n          var info = aIterator.next();\n          if (info.done) break; // If a instanceof Set, aValue === aKey.\n\n          var _a = info.value,\n              aKey = _a[0],\n              aValue = _a[1]; // So this works the same way for both Set and Map.\n\n          if (!b.has(aKey)) {\n            return false;\n          } // However, we care about deep equality of values only when dealing\n          // with Map structures.\n\n\n          if (isMap && !check(aValue, b.get(aKey))) {\n            return false;\n          }\n        }\n\n        return true;\n      }\n  } // Otherwise the values are not equal.\n\n\n  return false;\n}\n\nfunction previouslyCompared(a, b) {\n  // Though cyclic references can make an object graph appear infinite from the\n  // perspective of a depth-first traversal, the graph still contains a finite\n  // number of distinct object references. We use the previousComparisons cache\n  // to avoid comparing the same pair of object references more than once, which\n  // guarantees termination (even if we end up comparing every object in one\n  // graph to every object in the other graph, which is extremely unlikely),\n  // while still allowing weird isomorphic structures (like rings with different\n  // lengths) a chance to pass the equality test.\n  var bSet = previousComparisons.get(a);\n\n  if (bSet) {\n    // Return true here because we can be sure false will be returned somewhere\n    // else if the objects are not equivalent.\n    if (bSet.has(b)) return true;\n  } else {\n    previousComparisons.set(a, bSet = new Set());\n  }\n\n  bSet.add(b);\n  return false;\n}\n\nexport default equal;\nexport { equal };","import { __assign } from 'tslib';\nimport { print } from 'graphql/language/printer';\nimport { InvariantError } from 'ts-invariant';\nvar defaultHttpOptions = {\n  includeQuery: true,\n  includeExtensions: false\n};\nvar defaultHeaders = {\n  accept: '*/*',\n  'content-type': 'application/json'\n};\nvar defaultOptions = {\n  method: 'POST'\n};\nvar fallbackHttpConfig = {\n  http: defaultHttpOptions,\n  headers: defaultHeaders,\n  options: defaultOptions\n};\n\nvar throwServerError = function throwServerError(response, result, message) {\n  var error = new Error(message);\n  error.name = 'ServerError';\n  error.response = response;\n  error.statusCode = response.status;\n  error.result = result;\n  throw error;\n};\n\nvar parseAndCheckHttpResponse = function parseAndCheckHttpResponse(operations) {\n  return function (response) {\n    return response.text().then(function (bodyText) {\n      try {\n        return JSON.parse(bodyText);\n      } catch (err) {\n        var parseError = err;\n        parseError.name = 'ServerParseError';\n        parseError.response = response;\n        parseError.statusCode = response.status;\n        parseError.bodyText = bodyText;\n        return Promise.reject(parseError);\n      }\n    }).then(function (result) {\n      if (response.status >= 300) {\n        throwServerError(response, result, \"Response not successful: Received status code \" + response.status);\n      }\n\n      if (!Array.isArray(result) && !result.hasOwnProperty('data') && !result.hasOwnProperty('errors')) {\n        throwServerError(response, result, \"Server response was missing for query '\" + (Array.isArray(operations) ? operations.map(function (op) {\n          return op.operationName;\n        }) : operations.operationName) + \"'.\");\n      }\n\n      return result;\n    });\n  };\n};\n\nvar checkFetcher = function checkFetcher(fetcher) {\n  if (!fetcher && typeof fetch === 'undefined') {\n    var library = 'unfetch';\n    if (typeof window === 'undefined') library = 'node-fetch';\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError(\"\\nfetch is not found globally and no fetcher passed, to fix pass a fetch for\\nyour environment like https://www.npmjs.com/package/\" + library + \".\\n\\nFor example:\\nimport fetch from '\" + library + \"';\\nimport { createHttpLink } from 'apollo-link-http';\\n\\nconst link = createHttpLink({ uri: '/graphql', fetch: fetch });\");\n  }\n};\n\nvar createSignalIfSupported = function createSignalIfSupported() {\n  if (typeof AbortController === 'undefined') return {\n    controller: false,\n    signal: false\n  };\n  var controller = new AbortController();\n  var signal = controller.signal;\n  return {\n    controller: controller,\n    signal: signal\n  };\n};\n\nvar selectHttpOptionsAndBody = function selectHttpOptionsAndBody(operation, fallbackConfig) {\n  var configs = [];\n\n  for (var _i = 2; _i < arguments.length; _i++) {\n    configs[_i - 2] = arguments[_i];\n  }\n\n  var options = __assign({}, fallbackConfig.options, {\n    headers: fallbackConfig.headers,\n    credentials: fallbackConfig.credentials\n  });\n\n  var http = fallbackConfig.http;\n  configs.forEach(function (config) {\n    options = __assign({}, options, config.options, {\n      headers: __assign({}, options.headers, config.headers)\n    });\n    if (config.credentials) options.credentials = config.credentials;\n    http = __assign({}, http, config.http);\n  });\n  var operationName = operation.operationName,\n      extensions = operation.extensions,\n      variables = operation.variables,\n      query = operation.query;\n  var body = {\n    operationName: operationName,\n    variables: variables\n  };\n  if (http.includeExtensions) body.extensions = extensions;\n  if (http.includeQuery) body.query = print(query);\n  return {\n    options: options,\n    body: body\n  };\n};\n\nvar serializeFetchParameter = function serializeFetchParameter(p, label) {\n  var serialized;\n\n  try {\n    serialized = JSON.stringify(p);\n  } catch (e) {\n    var parseError = process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"Network request failed. \" + label + \" is not serializable: \" + e.message);\n    parseError.parseError = e;\n    throw parseError;\n  }\n\n  return serialized;\n};\n\nvar selectURI = function selectURI(operation, fallbackURI) {\n  var context = operation.getContext();\n  var contextURI = context.uri;\n\n  if (contextURI) {\n    return contextURI;\n  } else if (typeof fallbackURI === 'function') {\n    return fallbackURI(operation);\n  } else {\n    return fallbackURI || '/graphql';\n  }\n};\n\nexport { checkFetcher, createSignalIfSupported, fallbackHttpConfig, parseAndCheckHttpResponse, selectHttpOptionsAndBody, selectURI, serializeFetchParameter, throwServerError };","import { visit } from 'graphql/language/visitor';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { __assign, __spreadArrays } from 'tslib';\nimport stringify from 'fast-json-stable-stringify';\nexport { equal as isEqual } from '@wry/equality';\n\nfunction isScalarValue(value) {\n  return ['StringValue', 'BooleanValue', 'EnumValue'].indexOf(value.kind) > -1;\n}\n\nfunction isNumberValue(value) {\n  return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\n\nfunction isStringValue(value) {\n  return value.kind === 'StringValue';\n}\n\nfunction isBooleanValue(value) {\n  return value.kind === 'BooleanValue';\n}\n\nfunction isIntValue(value) {\n  return value.kind === 'IntValue';\n}\n\nfunction isFloatValue(value) {\n  return value.kind === 'FloatValue';\n}\n\nfunction isVariable(value) {\n  return value.kind === 'Variable';\n}\n\nfunction isObjectValue(value) {\n  return value.kind === 'ObjectValue';\n}\n\nfunction isListValue(value) {\n  return value.kind === 'ListValue';\n}\n\nfunction isEnumValue(value) {\n  return value.kind === 'EnumValue';\n}\n\nfunction isNullValue(value) {\n  return value.kind === 'NullValue';\n}\n\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n  if (isIntValue(value) || isFloatValue(value)) {\n    argObj[name.value] = Number(value.value);\n  } else if (isBooleanValue(value) || isStringValue(value)) {\n    argObj[name.value] = value.value;\n  } else if (isObjectValue(value)) {\n    var nestedArgObj_1 = {};\n    value.fields.map(function (obj) {\n      return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n    });\n    argObj[name.value] = nestedArgObj_1;\n  } else if (isVariable(value)) {\n    var variableValue = (variables || {})[value.name.value];\n    argObj[name.value] = variableValue;\n  } else if (isListValue(value)) {\n    argObj[name.value] = value.values.map(function (listValue) {\n      var nestedArgArrayObj = {};\n      valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n      return nestedArgArrayObj[name.value];\n    });\n  } else if (isEnumValue(value)) {\n    argObj[name.value] = value.value;\n  } else if (isNullValue(value)) {\n    argObj[name.value] = null;\n  } else {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(17) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" + 'is not supported. Use variables instead of inline arguments to ' + 'overcome this limitation.');\n  }\n}\n\nfunction storeKeyNameFromField(field, variables) {\n  var directivesObj = null;\n\n  if (field.directives) {\n    directivesObj = {};\n    field.directives.forEach(function (directive) {\n      directivesObj[directive.name.value] = {};\n\n      if (directive.arguments) {\n        directive.arguments.forEach(function (_a) {\n          var name = _a.name,\n              value = _a.value;\n          return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n        });\n      }\n    });\n  }\n\n  var argObj = null;\n\n  if (field.arguments && field.arguments.length) {\n    argObj = {};\n    field.arguments.forEach(function (_a) {\n      var name = _a.name,\n          value = _a.value;\n      return valueToObjectRepresentation(argObj, name, value, variables);\n    });\n  }\n\n  return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\n\nvar KNOWN_DIRECTIVES = ['connection', 'include', 'skip', 'client', 'rest', 'export'];\n\nfunction getStoreKeyName(fieldName, args, directives) {\n  if (directives && directives['connection'] && directives['connection']['key']) {\n    if (directives['connection']['filter'] && directives['connection']['filter'].length > 0) {\n      var filterKeys = directives['connection']['filter'] ? directives['connection']['filter'] : [];\n      filterKeys.sort();\n      var queryArgs_1 = args;\n      var filteredArgs_1 = {};\n      filterKeys.forEach(function (key) {\n        filteredArgs_1[key] = queryArgs_1[key];\n      });\n      return directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n    } else {\n      return directives['connection']['key'];\n    }\n  }\n\n  var completeFieldName = fieldName;\n\n  if (args) {\n    var stringifiedArgs = stringify(args);\n    completeFieldName += \"(\" + stringifiedArgs + \")\";\n  }\n\n  if (directives) {\n    Object.keys(directives).forEach(function (key) {\n      if (KNOWN_DIRECTIVES.indexOf(key) !== -1) return;\n\n      if (directives[key] && Object.keys(directives[key]).length) {\n        completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n      } else {\n        completeFieldName += \"@\" + key;\n      }\n    });\n  }\n\n  return completeFieldName;\n}\n\nfunction argumentsObjectFromField(field, variables) {\n  if (field.arguments && field.arguments.length) {\n    var argObj_1 = {};\n    field.arguments.forEach(function (_a) {\n      var name = _a.name,\n          value = _a.value;\n      return valueToObjectRepresentation(argObj_1, name, value, variables);\n    });\n    return argObj_1;\n  }\n\n  return null;\n}\n\nfunction resultKeyNameFromField(field) {\n  return field.alias ? field.alias.value : field.name.value;\n}\n\nfunction isField(selection) {\n  return selection.kind === 'Field';\n}\n\nfunction isInlineFragment(selection) {\n  return selection.kind === 'InlineFragment';\n}\n\nfunction isIdValue(idObject) {\n  return idObject && idObject.type === 'id' && typeof idObject.generated === 'boolean';\n}\n\nfunction toIdValue(idConfig, generated) {\n  if (generated === void 0) {\n    generated = false;\n  }\n\n  return __assign({\n    type: 'id',\n    generated: generated\n  }, typeof idConfig === 'string' ? {\n    id: idConfig,\n    typename: undefined\n  } : idConfig);\n}\n\nfunction isJsonValue(jsonObject) {\n  return jsonObject != null && typeof jsonObject === 'object' && jsonObject.type === 'json';\n}\n\nfunction defaultValueFromVariable(node) {\n  throw process.env.NODE_ENV === \"production\" ? new InvariantError(18) : new InvariantError(\"Variable nodes are not supported by valueFromNode\");\n}\n\nfunction valueFromNode(node, onVariable) {\n  if (onVariable === void 0) {\n    onVariable = defaultValueFromVariable;\n  }\n\n  switch (node.kind) {\n    case 'Variable':\n      return onVariable(node);\n\n    case 'NullValue':\n      return null;\n\n    case 'IntValue':\n      return parseInt(node.value, 10);\n\n    case 'FloatValue':\n      return parseFloat(node.value);\n\n    case 'ListValue':\n      return node.values.map(function (v) {\n        return valueFromNode(v, onVariable);\n      });\n\n    case 'ObjectValue':\n      {\n        var value = {};\n\n        for (var _i = 0, _a = node.fields; _i < _a.length; _i++) {\n          var field = _a[_i];\n          value[field.name.value] = valueFromNode(field.value, onVariable);\n        }\n\n        return value;\n      }\n\n    default:\n      return node.value;\n  }\n}\n\nfunction getDirectiveInfoFromField(field, variables) {\n  if (field.directives && field.directives.length) {\n    var directiveObj_1 = {};\n    field.directives.forEach(function (directive) {\n      directiveObj_1[directive.name.value] = argumentsObjectFromField(directive, variables);\n    });\n    return directiveObj_1;\n  }\n\n  return null;\n}\n\nfunction shouldInclude(selection, variables) {\n  if (variables === void 0) {\n    variables = {};\n  }\n\n  return getInclusionDirectives(selection.directives).every(function (_a) {\n    var directive = _a.directive,\n        ifArgument = _a.ifArgument;\n    var evaledValue = false;\n\n    if (ifArgument.value.kind === 'Variable') {\n      evaledValue = variables[ifArgument.value.name.value];\n      process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 13) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n    } else {\n      evaledValue = ifArgument.value.value;\n    }\n\n    return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n  });\n}\n\nfunction getDirectiveNames(doc) {\n  var names = [];\n  visit(doc, {\n    Directive: function Directive(node) {\n      names.push(node.name.value);\n    }\n  });\n  return names;\n}\n\nfunction hasDirectives(names, doc) {\n  return getDirectiveNames(doc).some(function (name) {\n    return names.indexOf(name) > -1;\n  });\n}\n\nfunction hasClientExports(document) {\n  return document && hasDirectives(['client'], document) && hasDirectives(['export'], document);\n}\n\nfunction isInclusionDirective(_a) {\n  var value = _a.name.value;\n  return value === 'skip' || value === 'include';\n}\n\nfunction getInclusionDirectives(directives) {\n  return directives ? directives.filter(isInclusionDirective).map(function (directive) {\n    var directiveArguments = directive.arguments;\n    var directiveName = directive.name.value;\n    process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 14) : invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\" + directiveName + \" directive.\");\n    var ifArgument = directiveArguments[0];\n    process.env.NODE_ENV === \"production\" ? invariant(ifArgument.name && ifArgument.name.value === 'if', 15) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n    var ifValue = ifArgument.value;\n    process.env.NODE_ENV === \"production\" ? invariant(ifValue && (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 16) : invariant(ifValue && (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n    return {\n      directive: directive,\n      ifArgument: ifArgument\n    };\n  }) : [];\n}\n\nfunction getFragmentQueryDocument(document, fragmentName) {\n  var actualFragmentName = fragmentName;\n  var fragments = [];\n  document.definitions.forEach(function (definition) {\n    if (definition.kind === 'OperationDefinition') {\n      throw process.env.NODE_ENV === \"production\" ? new InvariantError(11) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" + 'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n    }\n\n    if (definition.kind === 'FragmentDefinition') {\n      fragments.push(definition);\n    }\n  });\n\n  if (typeof actualFragmentName === 'undefined') {\n    process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 12) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n    actualFragmentName = fragments[0].name.value;\n  }\n\n  var query = __assign(__assign({}, document), {\n    definitions: __spreadArrays([{\n      kind: 'OperationDefinition',\n      operation: 'query',\n      selectionSet: {\n        kind: 'SelectionSet',\n        selections: [{\n          kind: 'FragmentSpread',\n          name: {\n            kind: 'Name',\n            value: actualFragmentName\n          }\n        }]\n      }\n    }], document.definitions)\n  });\n\n  return query;\n}\n\nfunction assign(target) {\n  var sources = [];\n\n  for (var _i = 1; _i < arguments.length; _i++) {\n    sources[_i - 1] = arguments[_i];\n  }\n\n  sources.forEach(function (source) {\n    if (typeof source === 'undefined' || source === null) {\n      return;\n    }\n\n    Object.keys(source).forEach(function (key) {\n      target[key] = source[key];\n    });\n  });\n  return target;\n}\n\nfunction getMutationDefinition(doc) {\n  checkDocument(doc);\n  var mutationDef = doc.definitions.filter(function (definition) {\n    return definition.kind === 'OperationDefinition' && definition.operation === 'mutation';\n  })[0];\n  process.env.NODE_ENV === \"production\" ? invariant(mutationDef, 1) : invariant(mutationDef, 'Must contain a mutation definition.');\n  return mutationDef;\n}\n\nfunction checkDocument(doc) {\n  process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 2) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n  var operations = doc.definitions.filter(function (d) {\n    return d.kind !== 'FragmentDefinition';\n  }).map(function (definition) {\n    if (definition.kind !== 'OperationDefinition') {\n      throw process.env.NODE_ENV === \"production\" ? new InvariantError(3) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n    }\n\n    return definition;\n  });\n  process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 4) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\n  return doc;\n}\n\nfunction getOperationDefinition(doc) {\n  checkDocument(doc);\n  return doc.definitions.filter(function (definition) {\n    return definition.kind === 'OperationDefinition';\n  })[0];\n}\n\nfunction getOperationDefinitionOrDie(document) {\n  var def = getOperationDefinition(document);\n  process.env.NODE_ENV === \"production\" ? invariant(def, 5) : invariant(def, \"GraphQL document is missing an operation\");\n  return def;\n}\n\nfunction getOperationName(doc) {\n  return doc.definitions.filter(function (definition) {\n    return definition.kind === 'OperationDefinition' && definition.name;\n  }).map(function (x) {\n    return x.name.value;\n  })[0] || null;\n}\n\nfunction getFragmentDefinitions(doc) {\n  return doc.definitions.filter(function (definition) {\n    return definition.kind === 'FragmentDefinition';\n  });\n}\n\nfunction getQueryDefinition(doc) {\n  var queryDef = getOperationDefinition(doc);\n  process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 6) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n  return queryDef;\n}\n\nfunction getFragmentDefinition(doc) {\n  process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 7) : invariant(doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n  process.env.NODE_ENV === \"production\" ? invariant(doc.definitions.length <= 1, 8) : invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.');\n  var fragmentDef = doc.definitions[0];\n  process.env.NODE_ENV === \"production\" ? invariant(fragmentDef.kind === 'FragmentDefinition', 9) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\n  return fragmentDef;\n}\n\nfunction getMainDefinition(queryDoc) {\n  checkDocument(queryDoc);\n  var fragmentDefinition;\n\n  for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n    var definition = _a[_i];\n\n    if (definition.kind === 'OperationDefinition') {\n      var operation = definition.operation;\n\n      if (operation === 'query' || operation === 'mutation' || operation === 'subscription') {\n        return definition;\n      }\n    }\n\n    if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n      fragmentDefinition = definition;\n    }\n  }\n\n  if (fragmentDefinition) {\n    return fragmentDefinition;\n  }\n\n  throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\n}\n\nfunction createFragmentMap(fragments) {\n  if (fragments === void 0) {\n    fragments = [];\n  }\n\n  var symTable = {};\n  fragments.forEach(function (fragment) {\n    symTable[fragment.name.value] = fragment;\n  });\n  return symTable;\n}\n\nfunction getDefaultValues(definition) {\n  if (definition && definition.variableDefinitions && definition.variableDefinitions.length) {\n    var defaultValues = definition.variableDefinitions.filter(function (_a) {\n      var defaultValue = _a.defaultValue;\n      return defaultValue;\n    }).map(function (_a) {\n      var variable = _a.variable,\n          defaultValue = _a.defaultValue;\n      var defaultValueObj = {};\n      valueToObjectRepresentation(defaultValueObj, variable.name, defaultValue);\n      return defaultValueObj;\n    });\n    return assign.apply(void 0, __spreadArrays([{}], defaultValues));\n  }\n\n  return {};\n}\n\nfunction variablesInOperation(operation) {\n  var names = new Set();\n\n  if (operation.variableDefinitions) {\n    for (var _i = 0, _a = operation.variableDefinitions; _i < _a.length; _i++) {\n      var definition = _a[_i];\n      names.add(definition.variable.name.value);\n    }\n  }\n\n  return names;\n}\n\nfunction filterInPlace(array, test, context) {\n  var target = 0;\n  array.forEach(function (elem, i) {\n    if (test.call(this, elem, i, array)) {\n      array[target++] = elem;\n    }\n  }, context);\n  array.length = target;\n  return array;\n}\n\nvar TYPENAME_FIELD = {\n  kind: 'Field',\n  name: {\n    kind: 'Name',\n    value: '__typename'\n  }\n};\n\nfunction isEmpty(op, fragments) {\n  return op.selectionSet.selections.every(function (selection) {\n    return selection.kind === 'FragmentSpread' && isEmpty(fragments[selection.name.value], fragments);\n  });\n}\n\nfunction nullIfDocIsEmpty(doc) {\n  return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc))) ? null : doc;\n}\n\nfunction getDirectiveMatcher(directives) {\n  return function directiveMatcher(directive) {\n    return directives.some(function (dir) {\n      return dir.name && dir.name === directive.name.value || dir.test && dir.test(directive);\n    });\n  };\n}\n\nfunction removeDirectivesFromDocument(directives, doc) {\n  var variablesInUse = Object.create(null);\n  var variablesToRemove = [];\n  var fragmentSpreadsInUse = Object.create(null);\n  var fragmentSpreadsToRemove = [];\n  var modifiedDoc = nullIfDocIsEmpty(visit(doc, {\n    Variable: {\n      enter: function enter(node, _key, parent) {\n        if (parent.kind !== 'VariableDefinition') {\n          variablesInUse[node.name.value] = true;\n        }\n      }\n    },\n    Field: {\n      enter: function enter(node) {\n        if (directives && node.directives) {\n          var shouldRemoveField = directives.some(function (directive) {\n            return directive.remove;\n          });\n\n          if (shouldRemoveField && node.directives && node.directives.some(getDirectiveMatcher(directives))) {\n            if (node.arguments) {\n              node.arguments.forEach(function (arg) {\n                if (arg.value.kind === 'Variable') {\n                  variablesToRemove.push({\n                    name: arg.value.name.value\n                  });\n                }\n              });\n            }\n\n            if (node.selectionSet) {\n              getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                fragmentSpreadsToRemove.push({\n                  name: frag.name.value\n                });\n              });\n            }\n\n            return null;\n          }\n        }\n      }\n    },\n    FragmentSpread: {\n      enter: function enter(node) {\n        fragmentSpreadsInUse[node.name.value] = true;\n      }\n    },\n    Directive: {\n      enter: function enter(node) {\n        if (getDirectiveMatcher(directives)(node)) {\n          return null;\n        }\n      }\n    }\n  }));\n\n  if (modifiedDoc && filterInPlace(variablesToRemove, function (v) {\n    return !variablesInUse[v.name];\n  }).length) {\n    modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n  }\n\n  if (modifiedDoc && filterInPlace(fragmentSpreadsToRemove, function (fs) {\n    return !fragmentSpreadsInUse[fs.name];\n  }).length) {\n    modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n  }\n\n  return modifiedDoc;\n}\n\nfunction addTypenameToDocument(doc) {\n  return visit(checkDocument(doc), {\n    SelectionSet: {\n      enter: function enter(node, _key, parent) {\n        if (parent && parent.kind === 'OperationDefinition') {\n          return;\n        }\n\n        var selections = node.selections;\n\n        if (!selections) {\n          return;\n        }\n\n        var skip = selections.some(function (selection) {\n          return isField(selection) && (selection.name.value === '__typename' || selection.name.value.lastIndexOf('__', 0) === 0);\n        });\n\n        if (skip) {\n          return;\n        }\n\n        var field = parent;\n\n        if (isField(field) && field.directives && field.directives.some(function (d) {\n          return d.name.value === 'export';\n        })) {\n          return;\n        }\n\n        return __assign(__assign({}, node), {\n          selections: __spreadArrays(selections, [TYPENAME_FIELD])\n        });\n      }\n    }\n  });\n}\n\nvar connectionRemoveConfig = {\n  test: function test(directive) {\n    var willRemove = directive.name.value === 'connection';\n\n    if (willRemove) {\n      if (!directive.arguments || !directive.arguments.some(function (arg) {\n        return arg.name.value === 'key';\n      })) {\n        process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' + 'You may want to use the key parameter to specify a store key.');\n      }\n    }\n\n    return willRemove;\n  }\n};\n\nfunction removeConnectionDirectiveFromDocument(doc) {\n  return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\n\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n  if (nestedCheck === void 0) {\n    nestedCheck = true;\n  }\n\n  return selectionSet && selectionSet.selections && selectionSet.selections.some(function (selection) {\n    return hasDirectivesInSelection(directives, selection, nestedCheck);\n  });\n}\n\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n  if (nestedCheck === void 0) {\n    nestedCheck = true;\n  }\n\n  if (!isField(selection)) {\n    return true;\n  }\n\n  if (!selection.directives) {\n    return false;\n  }\n\n  return selection.directives.some(getDirectiveMatcher(directives)) || nestedCheck && hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck);\n}\n\nfunction getDirectivesFromDocument(directives, doc) {\n  checkDocument(doc);\n  var parentPath;\n  return nullIfDocIsEmpty(visit(doc, {\n    SelectionSet: {\n      enter: function enter(node, _key, _parent, path) {\n        var currentPath = path.join('-');\n\n        if (!parentPath || currentPath === parentPath || !currentPath.startsWith(parentPath)) {\n          if (node.selections) {\n            var selectionsWithDirectives = node.selections.filter(function (selection) {\n              return hasDirectivesInSelection(directives, selection);\n            });\n\n            if (hasDirectivesInSelectionSet(directives, node, false)) {\n              parentPath = currentPath;\n            }\n\n            return __assign(__assign({}, node), {\n              selections: selectionsWithDirectives\n            });\n          } else {\n            return null;\n          }\n        }\n      }\n    }\n  }));\n}\n\nfunction getArgumentMatcher(config) {\n  return function argumentMatcher(argument) {\n    return config.some(function (aConfig) {\n      return argument.value && argument.value.kind === 'Variable' && argument.value.name && (aConfig.name === argument.value.name.value || aConfig.test && aConfig.test(argument));\n    });\n  };\n}\n\nfunction removeArgumentsFromDocument(config, doc) {\n  var argMatcher = getArgumentMatcher(config);\n  return nullIfDocIsEmpty(visit(doc, {\n    OperationDefinition: {\n      enter: function enter(node) {\n        return __assign(__assign({}, node), {\n          variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n            return !config.some(function (arg) {\n              return arg.name === varDef.variable.name.value;\n            });\n          })\n        });\n      }\n    },\n    Field: {\n      enter: function enter(node) {\n        var shouldRemoveField = config.some(function (argConfig) {\n          return argConfig.remove;\n        });\n\n        if (shouldRemoveField) {\n          var argMatchCount_1 = 0;\n          node.arguments.forEach(function (arg) {\n            if (argMatcher(arg)) {\n              argMatchCount_1 += 1;\n            }\n          });\n\n          if (argMatchCount_1 === 1) {\n            return null;\n          }\n        }\n      }\n    },\n    Argument: {\n      enter: function enter(node) {\n        if (argMatcher(node)) {\n          return null;\n        }\n      }\n    }\n  }));\n}\n\nfunction removeFragmentSpreadFromDocument(config, doc) {\n  function enter(node) {\n    if (config.some(function (def) {\n      return def.name === node.name.value;\n    })) {\n      return null;\n    }\n  }\n\n  return nullIfDocIsEmpty(visit(doc, {\n    FragmentSpread: {\n      enter: enter\n    },\n    FragmentDefinition: {\n      enter: enter\n    }\n  }));\n}\n\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n  var allFragments = [];\n  selectionSet.selections.forEach(function (selection) {\n    if ((isField(selection) || isInlineFragment(selection)) && selection.selectionSet) {\n      getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) {\n        return allFragments.push(frag);\n      });\n    } else if (selection.kind === 'FragmentSpread') {\n      allFragments.push(selection);\n    }\n  });\n  return allFragments;\n}\n\nfunction buildQueryFromSelectionSet(document) {\n  var definition = getMainDefinition(document);\n  var definitionOperation = definition.operation;\n\n  if (definitionOperation === 'query') {\n    return document;\n  }\n\n  var modifiedDoc = visit(document, {\n    OperationDefinition: {\n      enter: function enter(node) {\n        return __assign(__assign({}, node), {\n          operation: 'query'\n        });\n      }\n    }\n  });\n  return modifiedDoc;\n}\n\nfunction removeClientSetsFromDocument(document) {\n  checkDocument(document);\n  var modifiedDoc = removeDirectivesFromDocument([{\n    test: function test(directive) {\n      return directive.name.value === 'client';\n    },\n    remove: true\n  }], document);\n\n  if (modifiedDoc) {\n    modifiedDoc = visit(modifiedDoc, {\n      FragmentDefinition: {\n        enter: function enter(node) {\n          if (node.selectionSet) {\n            var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n              return isField(selection) && selection.name.value === '__typename';\n            });\n\n            if (isTypenameOnly) {\n              return null;\n            }\n          }\n        }\n      }\n    });\n  }\n\n  return modifiedDoc;\n}\n\nvar canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' && navigator.product === 'ReactNative');\nvar toString = Object.prototype.toString;\n\nfunction cloneDeep(value) {\n  return cloneDeepHelper(value, new Map());\n}\n\nfunction cloneDeepHelper(val, seen) {\n  switch (toString.call(val)) {\n    case \"[object Array]\":\n      {\n        if (seen.has(val)) return seen.get(val);\n        var copy_1 = val.slice(0);\n        seen.set(val, copy_1);\n        copy_1.forEach(function (child, i) {\n          copy_1[i] = cloneDeepHelper(child, seen);\n        });\n        return copy_1;\n      }\n\n    case \"[object Object]\":\n      {\n        if (seen.has(val)) return seen.get(val);\n        var copy_2 = Object.create(Object.getPrototypeOf(val));\n        seen.set(val, copy_2);\n        Object.keys(val).forEach(function (key) {\n          copy_2[key] = cloneDeepHelper(val[key], seen);\n        });\n        return copy_2;\n      }\n\n    default:\n      return val;\n  }\n}\n\nfunction getEnv() {\n  if (typeof process !== 'undefined' && process.env.NODE_ENV) {\n    return process.env.NODE_ENV;\n  }\n\n  return 'development';\n}\n\nfunction isEnv(env) {\n  return getEnv() === env;\n}\n\nfunction isProduction() {\n  return isEnv('production') === true;\n}\n\nfunction isDevelopment() {\n  return isEnv('development') === true;\n}\n\nfunction isTest() {\n  return isEnv('test') === true;\n}\n\nfunction tryFunctionOrLogError(f) {\n  try {\n    return f();\n  } catch (e) {\n    if (console.error) {\n      console.error(e);\n    }\n  }\n}\n\nfunction graphQLResultHasError(result) {\n  return result.errors && result.errors.length;\n}\n\nfunction deepFreeze(o) {\n  Object.freeze(o);\n  Object.getOwnPropertyNames(o).forEach(function (prop) {\n    if (o[prop] !== null && (typeof o[prop] === 'object' || typeof o[prop] === 'function') && !Object.isFrozen(o[prop])) {\n      deepFreeze(o[prop]);\n    }\n  });\n  return o;\n}\n\nfunction maybeDeepFreeze(obj) {\n  if (isDevelopment() || isTest()) {\n    var symbolIsPolyfilled = typeof Symbol === 'function' && typeof Symbol('') === 'string';\n\n    if (!symbolIsPolyfilled) {\n      return deepFreeze(obj);\n    }\n  }\n\n  return obj;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction mergeDeep() {\n  var sources = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    sources[_i] = arguments[_i];\n  }\n\n  return mergeDeepArray(sources);\n}\n\nfunction mergeDeepArray(sources) {\n  var target = sources[0] || {};\n  var count = sources.length;\n\n  if (count > 1) {\n    var pastCopies = [];\n    target = shallowCopyForMerge(target, pastCopies);\n\n    for (var i = 1; i < count; ++i) {\n      target = mergeHelper(target, sources[i], pastCopies);\n    }\n  }\n\n  return target;\n}\n\nfunction isObject(obj) {\n  return obj !== null && typeof obj === 'object';\n}\n\nfunction mergeHelper(target, source, pastCopies) {\n  if (isObject(source) && isObject(target)) {\n    if (Object.isExtensible && !Object.isExtensible(target)) {\n      target = shallowCopyForMerge(target, pastCopies);\n    }\n\n    Object.keys(source).forEach(function (sourceKey) {\n      var sourceValue = source[sourceKey];\n\n      if (hasOwnProperty.call(target, sourceKey)) {\n        var targetValue = target[sourceKey];\n\n        if (sourceValue !== targetValue) {\n          target[sourceKey] = mergeHelper(shallowCopyForMerge(targetValue, pastCopies), sourceValue, pastCopies);\n        }\n      } else {\n        target[sourceKey] = sourceValue;\n      }\n    });\n    return target;\n  }\n\n  return source;\n}\n\nfunction shallowCopyForMerge(value, pastCopies) {\n  if (value !== null && typeof value === 'object' && pastCopies.indexOf(value) < 0) {\n    if (Array.isArray(value)) {\n      value = value.slice(0);\n    } else {\n      value = __assign({\n        __proto__: Object.getPrototypeOf(value)\n      }, value);\n    }\n\n    pastCopies.push(value);\n  }\n\n  return value;\n}\n\nvar haveWarned = Object.create({});\n\nfunction warnOnceInDevelopment(msg, type) {\n  if (type === void 0) {\n    type = 'warn';\n  }\n\n  if (!isProduction() && !haveWarned[msg]) {\n    if (!isTest()) {\n      haveWarned[msg] = true;\n    }\n\n    if (type === 'error') {\n      console.error(msg);\n    } else {\n      console.warn(msg);\n    }\n  }\n}\n\nfunction stripSymbols(data) {\n  return JSON.parse(JSON.stringify(data));\n}\n\nexport { addTypenameToDocument, argumentsObjectFromField, assign, buildQueryFromSelectionSet, canUseWeakMap, checkDocument, cloneDeep, createFragmentMap, getDefaultValues, getDirectiveInfoFromField, getDirectiveNames, getDirectivesFromDocument, getEnv, getFragmentDefinition, getFragmentDefinitions, getFragmentQueryDocument, getInclusionDirectives, getMainDefinition, getMutationDefinition, getOperationDefinition, getOperationDefinitionOrDie, getOperationName, getQueryDefinition, getStoreKeyName, graphQLResultHasError, hasClientExports, hasDirectives, isDevelopment, isEnv, isField, isIdValue, isInlineFragment, isJsonValue, isNumberValue, isProduction, isScalarValue, isTest, maybeDeepFreeze, mergeDeep, mergeDeepArray, removeArgumentsFromDocument, removeClientSetsFromDocument, removeConnectionDirectiveFromDocument, removeDirectivesFromDocument, removeFragmentSpreadFromDocument, resultKeyNameFromField, shouldInclude, storeKeyNameFromField, stripSymbols, toIdValue, tryFunctionOrLogError, valueFromNode, valueToObjectRepresentation, variablesInOperation, warnOnceInDevelopment };","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';\nvar NetworkStatus;\n\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 = {}));\n\nfunction isNetworkRequestInFlight(networkStatus) {\n  return networkStatus < 7;\n}\n\nvar Observable = function (_super) {\n  __extends(Observable, _super);\n\n  function Observable() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n\n  Observable.prototype[$$observable] = function () {\n    return this;\n  };\n\n  Observable.prototype['@@observable'] = function () {\n    return this;\n  };\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}\n\nvar generateErrorMessage = function generateErrorMessage(err) {\n  var message = '';\n\n  if (isNonEmptyArray(err.graphQLErrors)) {\n    err.graphQLErrors.forEach(function (graphQLError) {\n      var errorMessage = graphQLError ? graphQLError.message : 'Error message not found.';\n      message += \"GraphQL error: \" + errorMessage + \"\\n\";\n    });\n  }\n\n  if (err.networkError) {\n    message += 'Network error: ' + err.networkError.message + '\\n';\n  }\n\n  message = message.replace(/\\n$/, '');\n  return message;\n};\n\nvar ApolloError = function (_super) {\n  __extends(ApolloError, _super);\n\n  function ApolloError(_a) {\n    var graphQLErrors = _a.graphQLErrors,\n        networkError = _a.networkError,\n        errorMessage = _a.errorMessage,\n        extraInfo = _a.extraInfo;\n\n    var _this = _super.call(this, errorMessage) || this;\n\n    _this.graphQLErrors = graphQLErrors || [];\n    _this.networkError = networkError || null;\n\n    if (!errorMessage) {\n      _this.message = generateErrorMessage(_this);\n    } else {\n      _this.message = errorMessage;\n    }\n\n    _this.extraInfo = extraInfo;\n    _this.__proto__ = ApolloError.prototype;\n    return _this;\n  }\n\n  return ApolloError;\n}(Error);\n\nvar FetchType;\n\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 hasError(storeValue, policy) {\n  if (policy === void 0) {\n    policy = 'none';\n  }\n\n  return storeValue && (storeValue.networkError || policy === 'none' && isNonEmptyArray(storeValue.graphQLErrors));\n};\n\nvar ObservableQuery = function (_super) {\n  __extends(ObservableQuery, _super);\n\n  function ObservableQuery(_a) {\n    var queryManager = _a.queryManager,\n        options = _a.options,\n        _b = _a.shouldSubscribe,\n        shouldSubscribe = _b === void 0 ? true : _b;\n\n    var _this = _super.call(this, function (observer) {\n      return _this.onSubscribe(observer);\n    }) || this;\n\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\n  ObservableQuery.prototype.result = function () {\n    var _this = this;\n\n    return new Promise(function (resolve, reject) {\n      var observer = {\n        next: function next(result) {\n          resolve(result);\n\n          _this.observers.delete(observer);\n\n          if (!_this.observers.size) {\n            _this.queryManager.removeQuery(_this.queryId);\n          }\n\n          setTimeout(function () {\n            subscription.unsubscribe();\n          }, 0);\n        },\n        error: reject\n      };\n\n      var subscription = _this.subscribe(observer);\n    });\n  };\n\n  ObservableQuery.prototype.currentResult = function () {\n    var result = this.getCurrentResult();\n\n    if (result.data === undefined) {\n      result.data = {};\n    }\n\n    return result;\n  };\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\n    var _a = this.queryManager.getCurrentQueryResult(this),\n        data = _a.data,\n        partial = _a.partial;\n\n    var queryStoreValue = this.queryManager.queryStore.get(this.queryId);\n    var result;\n    var fetchPolicy = this.options.fetchPolicy;\n    var isNetworkFetchPolicy = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n\n    if (queryStoreValue) {\n      var networkStatus = queryStoreValue.networkStatus;\n\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\n      if (queryStoreValue.variables) {\n        this.options.variables = __assign(__assign({}, this.options.variables), queryStoreValue.variables);\n        this.variables = this.options.variables;\n      }\n\n      result = {\n        data: data,\n        loading: isNetworkRequestInFlight(networkStatus),\n        networkStatus: networkStatus\n      };\n\n      if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {\n        result.errors = queryStoreValue.graphQLErrors;\n      }\n    } else {\n      var loading = isNetworkFetchPolicy || partial && fetchPolicy !== 'cache-only';\n      result = {\n        data: data,\n        loading: loading,\n        networkStatus: loading ? NetworkStatus.loading : NetworkStatus.ready\n      };\n    }\n\n    if (!partial) {\n      this.updateLastResult(__assign(__assign({}, result), {\n        stale: false\n      }));\n    }\n\n    return __assign(__assign({}, result), {\n      partial: partial\n    });\n  };\n\n  ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n    var snapshot = this.lastResultSnapshot;\n    return !(snapshot && newResult && snapshot.networkStatus === newResult.networkStatus && snapshot.stale === newResult.stale && isEqual(snapshot.data, newResult.data));\n  };\n\n  ObservableQuery.prototype.getLastResult = function () {\n    return this.lastResult;\n  };\n\n  ObservableQuery.prototype.getLastError = function () {\n    return this.lastError;\n  };\n\n  ObservableQuery.prototype.resetLastResults = function () {\n    delete this.lastResult;\n    delete this.lastResultSnapshot;\n    delete this.lastError;\n    this.isTornDown = false;\n  };\n\n  ObservableQuery.prototype.resetQueryStoreErrors = function () {\n    var queryStore = this.queryManager.queryStore.get(this.queryId);\n\n    if (queryStore) {\n      queryStore.networkError = null;\n      queryStore.graphQLErrors = [];\n    }\n  };\n\n  ObservableQuery.prototype.refetch = function (variables) {\n    var fetchPolicy = this.options.fetchPolicy;\n\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\n    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'cache-and-network') {\n      fetchPolicy = 'network-only';\n    }\n\n    if (!isEqual(this.variables, variables)) {\n      this.variables = __assign(__assign({}, this.variables), variables);\n    }\n\n    if (!isEqual(this.options.variables, this.variables)) {\n      this.options.variables = __assign(__assign({}, this.options.variables), this.variables);\n    }\n\n    return this.queryManager.fetchQuery(this.queryId, __assign(__assign({}, this.options), {\n      fetchPolicy: fetchPolicy\n    }), FetchType.refetch);\n  };\n\n  ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n    var _this = this;\n\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\n    var combinedOptions = __assign(__assign({}, fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), {\n      variables: __assign(__assign({}, this.variables), fetchMoreOptions.variables)\n    })), {\n      fetchPolicy: 'network-only'\n    });\n\n    var qid = this.queryManager.generateQueryId();\n    return this.queryManager.fetchQuery(qid, combinedOptions, FetchType.normal, this.queryId).then(function (fetchMoreResult) {\n      _this.updateQuery(function (previousResult) {\n        return fetchMoreOptions.updateQuery(previousResult, {\n          fetchMoreResult: fetchMoreResult.data,\n          variables: combinedOptions.variables\n        });\n      });\n\n      _this.queryManager.stopQuery(qid);\n\n      return fetchMoreResult;\n    }, function (error) {\n      _this.queryManager.stopQuery(qid);\n\n      throw error;\n    });\n  };\n\n  ObservableQuery.prototype.subscribeToMore = function (options) {\n    var _this = this;\n\n    var subscription = this.queryManager.startGraphQLSubscription({\n      query: options.document,\n      variables: options.variables\n    }).subscribe({\n      next: function next(subscriptionData) {\n        var updateQuery = options.updateQuery;\n\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 error(err) {\n        if (options.onError) {\n          options.onError(err);\n          return;\n        }\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\n  ObservableQuery.prototype.setOptions = function (opts) {\n    var oldFetchPolicy = this.options.fetchPolicy;\n    this.options = __assign(__assign({}, this.options), opts);\n\n    if (opts.pollInterval) {\n      this.startPolling(opts.pollInterval);\n    } else if (opts.pollInterval === 0) {\n      this.stopPolling();\n    }\n\n    var fetchPolicy = opts.fetchPolicy;\n    return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' || oldFetchPolicy === 'standby' || fetchPolicy === 'network-only'), opts.fetchResults);\n  };\n\n  ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {\n    if (tryFetch === void 0) {\n      tryFetch = false;\n    }\n\n    if (fetchResults === void 0) {\n      fetchResults = true;\n    }\n\n    this.isTornDown = false;\n    variables = variables || this.variables;\n\n    if (!tryFetch && isEqual(variables, this.variables)) {\n      return this.observers.size && fetchResults ? this.result() : Promise.resolve();\n    }\n\n    this.variables = this.options.variables = variables;\n\n    if (!this.observers.size) {\n      return Promise.resolve();\n    }\n\n    return this.queryManager.fetchQuery(this.queryId, this.options);\n  };\n\n  ObservableQuery.prototype.updateQuery = function (mapFn) {\n    var queryManager = this.queryManager;\n\n    var _a = queryManager.getQueryWithPreviousResult(this.queryId),\n        previousResult = _a.previousResult,\n        variables = _a.variables,\n        document = _a.document;\n\n    var newResult = tryFunctionOrLogError(function () {\n      return mapFn(previousResult, {\n        variables: variables\n      });\n    });\n\n    if (newResult) {\n      queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);\n      queryManager.broadcastQueries();\n    }\n  };\n\n  ObservableQuery.prototype.stopPolling = function () {\n    this.queryManager.stopPollingQuery(this.queryId);\n    this.options.pollInterval = undefined;\n  };\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\n  ObservableQuery.prototype.updateLastResult = function (newResult) {\n    var previousResult = this.lastResult;\n    this.lastResult = newResult;\n    this.lastResultSnapshot = this.queryManager.assumeImmutableResults ? newResult : cloneDeep(newResult);\n    return previousResult;\n  };\n\n  ObservableQuery.prototype.onSubscribe = function (observer) {\n    var _this = this;\n\n    try {\n      var subObserver = observer._subscription._observer;\n\n      if (subObserver && !subObserver.error) {\n        subObserver.error = defaultSubscriptionObserverErrorCallback;\n      }\n    } catch (_a) {}\n\n    var first = !this.observers.size;\n    this.observers.add(observer);\n    if (observer.next && this.lastResult) observer.next(this.lastResult);\n    if (observer.error && this.lastError) observer.error(this.lastError);\n\n    if (first) {\n      this.setUpQuery();\n    }\n\n    return function () {\n      if (_this.observers.delete(observer) && !_this.observers.size) {\n        _this.tearDownQuery();\n      }\n    };\n  };\n\n  ObservableQuery.prototype.setUpQuery = function () {\n    var _this = this;\n\n    var _a = this,\n        queryManager = _a.queryManager,\n        queryId = _a.queryId;\n\n    if (this.shouldSubscribe) {\n      queryManager.addObservableQuery(queryId, this);\n    }\n\n    if (this.options.pollInterval) {\n      assertNotCacheFirstOrOnly(this);\n      queryManager.startPollingQuery(this.options, queryId);\n    }\n\n    var onError = function onError(error) {\n      _this.updateLastResult(__assign(__assign({}, _this.lastResult), {\n        errors: error.graphQLErrors,\n        networkStatus: NetworkStatus.error,\n        loading: false\n      }));\n\n      iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n    };\n\n    queryManager.observeQuery(queryId, this.options, {\n      next: function next(result) {\n        if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n          var previousResult_1 = _this.updateLastResult(result);\n\n          var _a = _this.options,\n              query_1 = _a.query,\n              variables = _a.variables,\n              fetchPolicy_1 = _a.fetchPolicy;\n\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\n              if (!result.loading && previousResult_1 && fetchPolicy_1 !== 'cache-only' && queryManager.transform(query_1).serverQuery && !isEqual(previousVariables, variables)) {\n                _this.refetch();\n              } else {\n                iterateObserversSafely(_this.observers, 'next', result);\n              }\n            });\n          } else {\n            iterateObserversSafely(_this.observers, 'next', result);\n          }\n        }\n      },\n      error: onError\n    }).catch(onError);\n  };\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) {\n      return sub.unsubscribe();\n    });\n    this.subscriptions.clear();\n    queryManager.removeObservableQuery(this.queryId);\n    queryManager.stopQuery(this.queryId);\n    this.observers.clear();\n  };\n\n  return ObservableQuery;\n}(Observable);\n\nfunction defaultSubscriptionObserverErrorCallback(error) {\n  process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\n\nfunction iterateObserversSafely(observers, method, argument) {\n  var observersWithMethod = [];\n  observers.forEach(function (obs) {\n    return obs[method] && observersWithMethod.push(obs);\n  });\n  observersWithMethod.forEach(function (obs) {\n    return obs[method](argument);\n  });\n}\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\n  MutationStore.prototype.getStore = function () {\n    return this.store;\n  };\n\n  MutationStore.prototype.get = function (mutationId) {\n    return this.store[mutationId];\n  };\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\n  MutationStore.prototype.markMutationError = function (mutationId, error) {\n    var mutation = this.store[mutationId];\n\n    if (mutation) {\n      mutation.loading = false;\n      mutation.error = error;\n    }\n  };\n\n  MutationStore.prototype.markMutationResult = function (mutationId) {\n    var mutation = this.store[mutationId];\n\n    if (mutation) {\n      mutation.loading = false;\n      mutation.error = null;\n    }\n  };\n\n  MutationStore.prototype.reset = function () {\n    this.store = {};\n  };\n\n  return MutationStore;\n}();\n\nvar QueryStore = function () {\n  function QueryStore() {\n    this.store = {};\n  }\n\n  QueryStore.prototype.getStore = function () {\n    return this.store;\n  };\n\n  QueryStore.prototype.get = function (queryId) {\n    return this.store[queryId];\n  };\n\n  QueryStore.prototype.initQuery = function (query) {\n    var previousQuery = this.store[query.queryId];\n    process.env.NODE_ENV === \"production\" ? invariant(!previousQuery || previousQuery.document === query.document || isEqual(previousQuery.document, query.document), 19) : invariant(!previousQuery || previousQuery.document === query.document || isEqual(previousQuery.document, query.document), 'Internal Error: may not update existing query string in store');\n    var isSetVariables = false;\n    var previousVariables = null;\n\n    if (query.storePreviousVariables && previousQuery && previousQuery.networkStatus !== NetworkStatus.loading) {\n      if (!isEqual(previousQuery.variables, query.variables)) {\n        isSetVariables = true;\n        previousVariables = previousQuery.variables;\n      }\n    }\n\n    var networkStatus;\n\n    if (isSetVariables) {\n      networkStatus = NetworkStatus.setVariables;\n    } else if (query.isPoll) {\n      networkStatus = NetworkStatus.poll;\n    } else if (query.isRefetch) {\n      networkStatus = NetworkStatus.refetch;\n    } else {\n      networkStatus = NetworkStatus.loading;\n    }\n\n    var graphQLErrors = [];\n\n    if (previousQuery && previousQuery.graphQLErrors) {\n      graphQLErrors = previousQuery.graphQLErrors;\n    }\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\n    if (typeof query.fetchMoreForQueryId === 'string' && this.store[query.fetchMoreForQueryId]) {\n      this.store[query.fetchMoreForQueryId].networkStatus = NetworkStatus.fetchMore;\n    }\n  };\n\n  QueryStore.prototype.markQueryResult = function (queryId, result, fetchMoreForQueryId) {\n    if (!this.store || !this.store[queryId]) 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\n    if (typeof fetchMoreForQueryId === 'string' && this.store[fetchMoreForQueryId]) {\n      this.store[fetchMoreForQueryId].networkStatus = NetworkStatus.ready;\n    }\n  };\n\n  QueryStore.prototype.markQueryError = function (queryId, error, fetchMoreForQueryId) {\n    if (!this.store || !this.store[queryId]) return;\n    this.store[queryId].networkError = error;\n    this.store[queryId].networkStatus = NetworkStatus.error;\n\n    if (typeof fetchMoreForQueryId === 'string') {\n      this.markQueryResultClient(fetchMoreForQueryId, true);\n    }\n  };\n\n  QueryStore.prototype.markQueryResultClient = function (queryId, complete) {\n    var storeValue = this.store && this.store[queryId];\n\n    if (storeValue) {\n      storeValue.networkError = null;\n      storeValue.previousVariables = null;\n\n      if (complete) {\n        storeValue.networkStatus = NetworkStatus.ready;\n      }\n    }\n  };\n\n  QueryStore.prototype.stopQuery = function (queryId) {\n    delete this.store[queryId];\n  };\n\n  QueryStore.prototype.reset = function (observableQueryIds) {\n    var _this = this;\n\n    Object.keys(this.store).forEach(function (queryId) {\n      if (observableQueryIds.indexOf(queryId) < 0) {\n        _this.stopQuery(queryId);\n      } else {\n        _this.store[queryId].networkStatus = NetworkStatus.loading;\n      }\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,\n        client = _a.client,\n        resolvers = _a.resolvers,\n        fragmentMatcher = _a.fragmentMatcher;\n    this.cache = cache;\n\n    if (client) {\n      this.client = client;\n    }\n\n    if (resolvers) {\n      this.addResolvers(resolvers);\n    }\n\n    if (fragmentMatcher) {\n      this.setFragmentMatcher(fragmentMatcher);\n    }\n  }\n\n  LocalState.prototype.addResolvers = function (resolvers) {\n    var _this = this;\n\n    this.resolvers = this.resolvers || {};\n\n    if (Array.isArray(resolvers)) {\n      resolvers.forEach(function (resolverGroup) {\n        _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n      });\n    } else {\n      this.resolvers = mergeDeep(this.resolvers, resolvers);\n    }\n  };\n\n  LocalState.prototype.setResolvers = function (resolvers) {\n    this.resolvers = {};\n    this.addResolvers(resolvers);\n  };\n\n  LocalState.prototype.getResolvers = function () {\n    return this.resolvers || {};\n  };\n\n  LocalState.prototype.runResolvers = function (_a) {\n    var document = _a.document,\n        remoteResult = _a.remoteResult,\n        context = _a.context,\n        variables = _a.variables,\n        _b = _a.onlyRunForcedResolvers,\n        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) {\n            return __assign(__assign({}, remoteResult), {\n              data: localResult.result\n            });\n          })];\n        }\n\n        return [2, remoteResult];\n      });\n    });\n  };\n\n  LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n    this.fragmentMatcher = fragmentMatcher;\n  };\n\n  LocalState.prototype.getFragmentMatcher = function () {\n    return this.fragmentMatcher;\n  };\n\n  LocalState.prototype.clientQuery = function (document) {\n    if (hasDirectives(['client'], document)) {\n      if (this.resolvers) {\n        return document;\n      }\n\n      process.env.NODE_ENV === \"production\" || invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' + 'were specified. This means ApolloClient local resolver handling ' + 'has been disabled, and @client directives will be passed through ' + 'to your link chain.');\n    }\n\n    return null;\n  };\n\n  LocalState.prototype.serverQuery = function (document) {\n    return this.resolvers ? removeClientSetsFromDocument(document) : document;\n  };\n\n  LocalState.prototype.prepareContext = function (context) {\n    if (context === void 0) {\n      context = {};\n    }\n\n    var cache = this.cache;\n\n    var newContext = __assign(__assign({}, context), {\n      cache: cache,\n      getCacheKey: function getCacheKey(obj) {\n        if (cache.config) {\n          return cache.config.dataIdFromObject(obj);\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 ' + 'a configurable dataIdFromObject, like apollo-cache-inmemory.');\n        }\n      }\n    });\n\n    return newContext;\n  };\n\n  LocalState.prototype.addExportedVariables = function (document, variables, context) {\n    if (variables === void 0) {\n      variables = {};\n    }\n\n    if (context === void 0) {\n      context = {};\n    }\n\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) {\n            return __assign(__assign({}, variables), data.exportedVariables);\n          })];\n        }\n\n        return [2, __assign({}, variables)];\n      });\n    });\n  };\n\n  LocalState.prototype.shouldForceResolvers = function (document) {\n    var forceResolvers = false;\n    visit(document, {\n      Directive: {\n        enter: function enter(node) {\n          if (node.name.value === 'client' && node.arguments) {\n            forceResolvers = node.arguments.some(function (arg) {\n              return arg.name.value === 'always' && arg.value.kind === 'BooleanValue' && arg.value.value === true;\n            });\n\n            if (forceResolvers) {\n              return BREAK;\n            }\n          }\n        }\n      }\n    });\n    return forceResolvers;\n  };\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\n  LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n    if (context === void 0) {\n      context = {};\n    }\n\n    if (variables === void 0) {\n      variables = {};\n    }\n\n    if (fragmentMatcher === void 0) {\n      fragmentMatcher = function fragmentMatcher() {\n        return true;\n      };\n    }\n\n    if (onlyRunForcedResolvers === void 0) {\n      onlyRunForcedResolvers = false;\n    }\n\n    return __awaiter(this, void 0, void 0, function () {\n      var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n\n      return __generator(this, function (_b) {\n        mainDefinition = getMainDefinition(document);\n        fragments = getFragmentDefinitions(document);\n        fragmentMap = createFragmentMap(fragments);\n        definitionOperation = mainDefinition.operation;\n        defaultOperationType = definitionOperation ? capitalizeFirstLetter(definitionOperation) : 'Query';\n        _a = this, cache = _a.cache, client = _a.client;\n        execContext = {\n          fragmentMap: fragmentMap,\n          context: __assign(__assign({}, context), {\n            cache: cache,\n            client: client\n          }),\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) {\n          return {\n            result: result,\n            exportedVariables: execContext.exportedVariables\n          };\n        })];\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\n      var _this = this;\n\n      return __generator(this, function (_a) {\n        fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n        resultsToMerge = [rootValue];\n\n        execute = function execute(selection) {\n          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\n              if (isField(selection)) {\n                return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                  var _a;\n\n                  if (typeof fieldResult !== 'undefined') {\n                    resultsToMerge.push((_a = {}, _a[resultKeyNameFromField(selection)] = fieldResult, _a));\n                  }\n                })];\n              }\n\n              if (isInlineFragment(selection)) {\n                fragment = selection;\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\n              if (fragment && fragment.typeCondition) {\n                typeCondition = fragment.typeCondition.name.value;\n\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\n              return [2];\n            });\n          });\n        };\n\n        return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n          return mergeDeepArray(resultsToMerge);\n        })];\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\n      var _this = this;\n\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\n        if (!execContext.onlyRunForcedResolvers || this.shouldForceResolvers(field)) {\n          resolverType = rootValue.__typename || execContext.defaultOperationType;\n          resolverMap = this.resolvers && this.resolvers[resolverType];\n\n          if (resolverMap) {\n            resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n\n            if (resolve) {\n              resultPromise = Promise.resolve(resolve(rootValue, argumentsObjectFromField(field, variables), execContext.context, {\n                field: field,\n                fragmentMap: execContext.fragmentMap\n              }));\n            }\n          }\n        }\n\n        return [2, resultPromise.then(function (result) {\n          if (result === void 0) {\n            result = defaultResult;\n          }\n\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\n          if (!field.selectionSet) {\n            return result;\n          }\n\n          if (result == null) {\n            return result;\n          }\n\n          if (Array.isArray(result)) {\n            return _this.resolveSubSelectedArray(field, result, execContext);\n          }\n\n          if (field.selectionSet) {\n            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n          }\n        })];\n      });\n    });\n  };\n\n  LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n    var _this = this;\n\n    return Promise.all(result.map(function (item) {\n      if (item === null) {\n        return null;\n      }\n\n      if (Array.isArray(item)) {\n        return _this.resolveSubSelectedArray(field, item, execContext);\n      }\n\n      if (field.selectionSet) {\n        return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n      }\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 next(value) {\n        observers.forEach(function (obs) {\n          return obs.next && obs.next(value);\n        });\n      },\n      error: function error(_error) {\n        observers.forEach(function (obs) {\n          return obs.error && obs.error(_error);\n        });\n      },\n      complete: function complete() {\n        observers.forEach(function (obs) {\n          return obs.complete && obs.complete();\n        });\n      }\n    });\n    return function () {\n      if (observers.delete(observer) && !observers.size && sub) {\n        sub.unsubscribe();\n        sub = null;\n      }\n    };\n  });\n}\n\nfunction asyncMap(observable, mapFn) {\n  return new Observable(function (observer) {\n    var _next = observer.next,\n        _error2 = observer.error,\n        _complete = observer.complete;\n    var activeNextCount = 0;\n    var completed = false;\n    var handler = {\n      next: function next(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          _error2 && _error2.call(observer, e);\n        });\n      },\n      error: function error(e) {\n        _error2 && _error2.call(observer, e);\n      },\n      complete: function complete() {\n        completed = true;\n\n        if (!activeNextCount) {\n          _complete && _complete.call(observer);\n        }\n      }\n    };\n    var sub = observable.subscribe(handler);\n    return function () {\n      return sub.unsubscribe();\n    };\n  });\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar QueryManager = function () {\n  function QueryManager(_a) {\n    var link = _a.link,\n        _b = _a.queryDeduplication,\n        queryDeduplication = _b === void 0 ? false : _b,\n        store = _a.store,\n        _c = _a.onBroadcast,\n        onBroadcast = _c === void 0 ? function () {\n      return undefined;\n    } : _c,\n        _d = _a.ssrMode,\n        ssrMode = _d === void 0 ? false : _d,\n        _e = _a.clientAwareness,\n        clientAwareness = _e === void 0 ? {} : _e,\n        localState = _a.localState,\n        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({\n      cache: store.getCache()\n    });\n    this.ssrMode = ssrMode;\n    this.assumeImmutableResults = !!assumeImmutableResults;\n  }\n\n  QueryManager.prototype.stop = function () {\n    var _this = this;\n\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\n  QueryManager.prototype.mutate = function (_a) {\n    var mutation = _a.mutation,\n        variables = _a.variables,\n        optimisticResponse = _a.optimisticResponse,\n        updateQueriesByName = _a.updateQueries,\n        _b = _a.refetchQueries,\n        refetchQueries = _b === void 0 ? [] : _b,\n        _c = _a.awaitRefetchQueries,\n        awaitRefetchQueries = _c === void 0 ? false : _c,\n        updateWithProxyFn = _a.update,\n        _d = _a.errorPolicy,\n        errorPolicy = _d === void 0 ? 'none' : _d,\n        fetchPolicy = _a.fetchPolicy,\n        _e = _a.context,\n        context = _e === void 0 ? {} : _e;\n    return __awaiter(this, void 0, void 0, function () {\n      var mutationId, generateUpdateQueriesInfo, self;\n\n      var _this = this;\n\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 () {\n              return {\n                document: mutation\n              };\n            });\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\n          case 1:\n            variables = _f.sent();\n            _f.label = 2;\n\n          case 2:\n            generateUpdateQueriesInfo = function generateUpdateQueriesInfo() {\n              var ret = {};\n\n              if (updateQueriesByName) {\n                _this.queries.forEach(function (_a, queryId) {\n                  var observableQuery = _a.observableQuery;\n\n                  if (observableQuery) {\n                    var queryName = observableQuery.queryName;\n\n                    if (queryName && hasOwnProperty.call(updateQueriesByName, queryName)) {\n                      ret[queryId] = {\n                        updater: updateQueriesByName[queryName],\n                        query: _this.queryStore.get(queryId)\n                      };\n                    }\n                  }\n                });\n              }\n\n              return ret;\n            };\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), {\n                optimisticResponse: optimisticResponse\n              }), variables, false).subscribe({\n                next: function next(result) {\n                  if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                    error = new ApolloError({\n                      graphQLErrors: result.errors\n                    });\n                    return;\n                  }\n\n                  self.mutationStore.markMutationResult(mutationId);\n\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\n                  storeResult = result;\n                },\n                error: function error(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 () {\n                    return {\n                      document: null\n                    };\n                  });\n                  reject(new ApolloError({\n                    networkError: err\n                  }));\n                },\n                complete: function complete() {\n                  if (error) {\n                    self.mutationStore.markMutationError(mutationId, error);\n                  }\n\n                  self.dataStore.markMutationComplete({\n                    mutationId: mutationId,\n                    optimisticResponse: optimisticResponse\n                  });\n                  self.broadcastQueries();\n\n                  if (error) {\n                    reject(error);\n                    return;\n                  }\n\n                  if (typeof refetchQueries === 'function') {\n                    refetchQueries = refetchQueries(storeResult);\n                  }\n\n                  var refetchQueryPromises = [];\n\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\n                          if (observableQuery && observableQuery.queryName === refetchQuery) {\n                            refetchQueryPromises.push(observableQuery.refetch());\n                          }\n                        });\n                      } else {\n                        var queryOptions = {\n                          query: refetchQuery.query,\n                          variables: refetchQuery.variables,\n                          fetchPolicy: 'network-only'\n                        };\n\n                        if (refetchQuery.context) {\n                          queryOptions.context = refetchQuery.context;\n                        }\n\n                        refetchQueryPromises.push(self.query(queryOptions));\n                      }\n                    });\n                  }\n\n                  Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                    self.setQuery(mutationId, function () {\n                      return {\n                        document: null\n                      };\n                    });\n\n                    if (errorPolicy === 'ignore' && storeResult && graphQLResultHasError(storeResult)) {\n                      delete storeResult.errors;\n                    }\n\n                    resolve(storeResult);\n                  });\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\n      var _this = this;\n\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\n          case 1:\n            variables = _e.sent();\n            _e.label = 2;\n\n          case 2:\n            options = __assign(__assign({}, options), {\n              variables: variables\n            });\n            isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n            needToFetch = isNetworkOnly;\n\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\n            shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';\n            if (hasDirectives(['live'], query)) shouldFetch = true;\n            requestId = this.idCounter++;\n            cancel = fetchPolicy !== 'no-cache' ? this.updateQueryWatch(queryId, query, options) : undefined;\n            this.setQuery(queryId, function () {\n              return {\n                document: query,\n                lastRequestId: requestId,\n                invalidated: true,\n                cancel: cancel\n              };\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\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                } else {\n                  if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                    _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);\n\n                    _this.invalidate(queryId);\n\n                    _this.invalidate(fetchMoreForQueryId);\n\n                    _this.broadcastQueries();\n                  }\n\n                  throw new ApolloError({\n                    networkError: error\n                  });\n                }\n              });\n\n              if (fetchPolicy !== 'cache-and-network') {\n                return [2, networkResult];\n              }\n\n              networkResult.catch(function () {});\n            }\n\n            this.queryStore.markQueryResultClient(queryId, !shouldFetch);\n            this.invalidate(queryId);\n            this.invalidate(fetchMoreForQueryId);\n\n            if (this.transform(query).hasForcedResolvers) {\n              return [2, this.localState.runResolvers({\n                document: query,\n                remoteResult: {\n                  data: storeResult\n                },\n                context: context,\n                variables: variables,\n                onlyRunForcedResolvers: true\n              }).then(function (result) {\n                _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n\n                _this.broadcastQueries();\n\n                return result;\n              })];\n            }\n\n            this.broadcastQueries();\n            return [2, {\n              data: storeResult\n            }];\n        }\n      });\n    });\n  };\n\n  QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {\n    var fetchPolicy = _a.fetchPolicy,\n        variables = _a.variables,\n        errorPolicy = _a.errorPolicy;\n\n    if (fetchPolicy === 'no-cache') {\n      this.setQuery(queryId, function () {\n        return {\n          newData: {\n            result: result.data,\n            complete: true\n          }\n        };\n      });\n    } else {\n      this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');\n    }\n  };\n\n  QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {\n    var _this = this;\n\n    function invoke(method, argument) {\n      if (observer[method]) {\n        try {\n          observer[method](argument);\n        } catch (e) {\n          process.env.NODE_ENV === \"production\" || invariant.error(e);\n        }\n      } else if (method === 'error') {\n        process.env.NODE_ENV === \"production\" || invariant.error(argument);\n      }\n    }\n\n    return function (queryStoreValue, newData) {\n      _this.invalidate(queryId, false);\n\n      if (!queryStoreValue) return;\n\n      var _a = _this.getQuery(queryId),\n          observableQuery = _a.observableQuery,\n          document = _a.document;\n\n      var fetchPolicy = observableQuery ? observableQuery.options.fetchPolicy : options.fetchPolicy;\n      if (fetchPolicy === 'standby') return;\n      var loading = isNetworkRequestInFlight(queryStoreValue.networkStatus);\n      var lastResult = observableQuery && observableQuery.getLastResult();\n      var networkStatusChanged = !!(lastResult && lastResult.networkStatus !== queryStoreValue.networkStatus);\n      var shouldNotifyIfLoading = options.returnPartialData || !newData && queryStoreValue.previousVariables || networkStatusChanged && options.notifyOnNetworkStatusChange || fetchPolicy === 'cache-only' || fetchPolicy === 'cache-and-network';\n\n      if (loading && !shouldNotifyIfLoading) {\n        return;\n      }\n\n      var hasGraphQLErrors = isNonEmptyArray(queryStoreValue.graphQLErrors);\n      var errorPolicy = observableQuery && observableQuery.options.errorPolicy || options.errorPolicy || 'none';\n\n      if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {\n        return invoke('error', new ApolloError({\n          graphQLErrors: queryStoreValue.graphQLErrors,\n          networkError: queryStoreValue.networkError\n        }));\n      }\n\n      try {\n        var data = void 0;\n        var isMissing = void 0;\n\n        if (newData) {\n          if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {\n            _this.setQuery(queryId, function () {\n              return {\n                newData: null\n              };\n            });\n          }\n\n          data = newData.result;\n          isMissing = !newData.complete;\n        } else {\n          var lastError = observableQuery && observableQuery.getLastError();\n          var errorStatusChanged = errorPolicy !== 'none' && (lastError && lastError.graphQLErrors) !== queryStoreValue.graphQLErrors;\n\n          if (lastResult && lastResult.data && !errorStatusChanged) {\n            data = lastResult.data;\n            isMissing = false;\n          } else {\n            var diffResult = _this.dataStore.getCache().diff({\n              query: document,\n              variables: queryStoreValue.previousVariables || queryStoreValue.variables,\n              returnPartialData: true,\n              optimistic: true\n            });\n\n            data = diffResult.result;\n            isMissing = !diffResult.complete;\n          }\n        }\n\n        var stale = isMissing && !(options.returnPartialData || 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\n        if (errorPolicy === 'all' && hasGraphQLErrors) {\n          resultFromStore.errors = queryStoreValue.graphQLErrors;\n        }\n\n        invoke('next', resultFromStore);\n      } catch (networkError) {\n        invoke('error', new ApolloError({\n          networkError: networkError\n        }));\n      }\n    };\n  };\n\n  QueryManager.prototype.transform = function (document) {\n    var transformCache = this.transformCache;\n\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\n      var add = function add(doc) {\n        if (doc && !transformCache.has(doc)) {\n          transformCache.set(doc, cacheEntry_1);\n        }\n      };\n\n      add(document);\n      add(transformed);\n      add(clientQuery);\n      add(serverQuery);\n    }\n\n    return transformCache.get(document);\n  };\n\n  QueryManager.prototype.getVariables = function (document, variables) {\n    return __assign(__assign({}, this.transform(document).defaultVars), variables);\n  };\n\n  QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n    if (shouldSubscribe === void 0) {\n      shouldSubscribe = true;\n    }\n\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\n    if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n      options.notifyOnNetworkStatusChange = false;\n    }\n\n    var transformedOptions = __assign({}, options);\n\n    return new ObservableQuery({\n      queryManager: this,\n      options: transformedOptions,\n      shouldSubscribe: shouldSubscribe\n    });\n  };\n\n  QueryManager.prototype.query = function (options) {\n    var _this = this;\n\n    process.env.NODE_ENV === \"production\" ? invariant(options.query, 12) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' + '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\n      _this.fetchQueryRejectFns.set(\"query:\" + watchedQuery.queryId, reject);\n\n      watchedQuery.result().then(resolve, reject).then(function () {\n        return _this.fetchQueryRejectFns.delete(\"query:\" + watchedQuery.queryId);\n      });\n    });\n  };\n\n  QueryManager.prototype.generateQueryId = function () {\n    return String(this.idCounter++);\n  };\n\n  QueryManager.prototype.stopQueryInStore = function (queryId) {\n    this.stopQueryInStoreNoBroadcast(queryId);\n    this.broadcastQueries();\n  };\n\n  QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n    this.stopPollingQuery(queryId);\n    this.queryStore.stopQuery(queryId);\n    this.invalidate(queryId);\n  };\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 {\n        invalidated: false\n      };\n    });\n  };\n\n  QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {\n    var _this = this;\n\n    var cancel = this.getQuery(queryId).cancel;\n    if (cancel) cancel();\n\n    var previousResult = function previousResult() {\n      var previousResult = null;\n\n      var observableQuery = _this.getQuery(queryId).observableQuery;\n\n      if (observableQuery) {\n        var lastResult = observableQuery.getLastResult();\n\n        if (lastResult) {\n          previousResult = lastResult.data;\n        }\n      }\n\n      return previousResult;\n    };\n\n    return this.dataStore.getCache().watch({\n      query: document,\n      variables: options.variables,\n      optimistic: true,\n      previousResult: previousResult,\n      callback: function callback(newData) {\n        _this.setQuery(queryId, function () {\n          return {\n            invalidated: true,\n            newData: newData\n          };\n        });\n      }\n    });\n  };\n\n  QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {\n    this.setQuery(queryId, function () {\n      return {\n        observableQuery: observableQuery\n      };\n    });\n  };\n\n  QueryManager.prototype.removeObservableQuery = function (queryId) {\n    var cancel = this.getQuery(queryId).cancel;\n    this.setQuery(queryId, function () {\n      return {\n        observableQuery: null\n      };\n    });\n    if (cancel) cancel();\n  };\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) resetIds.push(queryId);\n    });\n    this.queryStore.reset(resetIds);\n    this.mutationStore.reset();\n    return this.dataStore.reset();\n  };\n\n  QueryManager.prototype.resetStore = function () {\n    var _this = this;\n\n    return this.clearStore().then(function () {\n      return _this.reFetchObservableQueries();\n    });\n  };\n\n  QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n    var _this = this;\n\n    if (includeStandby === void 0) {\n      includeStandby = false;\n    }\n\n    var observableQueryPromises = [];\n    this.queries.forEach(function (_a, queryId) {\n      var observableQuery = _a.observableQuery;\n\n      if (observableQuery) {\n        var fetchPolicy = observableQuery.options.fetchPolicy;\n        observableQuery.resetLastResults();\n\n        if (fetchPolicy !== 'cache-only' && (includeStandby || fetchPolicy !== 'standby')) {\n          observableQueryPromises.push(observableQuery.refetch());\n        }\n\n        _this.setQuery(queryId, function () {\n          return {\n            newData: null\n          };\n        });\n\n        _this.invalidate(queryId);\n      }\n    });\n    this.broadcastQueries();\n    return Promise.all(observableQueryPromises);\n  };\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\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).catch(function () {\n      return undefined;\n    });\n    return queryId;\n  };\n\n  QueryManager.prototype.startGraphQLSubscription = function (_a) {\n    var _this = this;\n\n    var query = _a.query,\n        fetchPolicy = _a.fetchPolicy,\n        variables = _a.variables;\n    query = this.transform(query).document;\n    variables = this.getVariables(query, variables);\n\n    var makeObservable = function makeObservable(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\n          _this.broadcastQueries();\n        }\n\n        if (graphQLResultHasError(result)) {\n          throw new ApolloError({\n            graphQLErrors: result.errors\n          });\n        }\n\n        return result;\n      });\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) {\n          return sub = observable.subscribe(observer);\n        }, observer.error);\n        return function () {\n          return sub && sub.unsubscribe();\n        };\n      });\n    }\n\n    return makeObservable(variables);\n  };\n\n  QueryManager.prototype.stopQuery = function (queryId) {\n    this.stopQueryNoBroadcast(queryId);\n    this.broadcastQueries();\n  };\n\n  QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n    this.stopQueryInStoreNoBroadcast(queryId);\n    this.removeQuery(queryId);\n  };\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) {\n      return x.unsubscribe();\n    });\n    this.queries.delete(queryId);\n  };\n\n  QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = true;\n    }\n\n    var _a = observableQuery.options,\n        variables = _a.variables,\n        query = _a.query,\n        fetchPolicy = _a.fetchPolicy,\n        returnPartialData = _a.returnPartialData;\n    var lastResult = observableQuery.getLastResult();\n    var newData = this.getQuery(observableQuery.queryId).newData;\n\n    if (newData && newData.complete) {\n      return {\n        data: newData.result,\n        partial: false\n      };\n    }\n\n    if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {\n      return {\n        data: undefined,\n        partial: false\n      };\n    }\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    }),\n        result = _b.result,\n        complete = _b.complete;\n\n    return {\n      data: complete || returnPartialData ? result : void 0,\n      partial: !complete\n    };\n  };\n\n  QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {\n    var observableQuery;\n\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    } else {\n      observableQuery = queryIdOrObservable;\n    }\n\n    var _a = observableQuery.options,\n        variables = _a.variables,\n        query = _a.query;\n    return {\n      previousResult: this.getCurrentQueryResult(observableQuery, false).data,\n      variables: variables,\n      document: query\n    };\n  };\n\n  QueryManager.prototype.broadcastQueries = function () {\n    var _this = this;\n\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\n  QueryManager.prototype.getLocalState = function () {\n    return this.localState;\n  };\n\n  QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n    var _this = this;\n\n    if (deduplication === void 0) {\n      deduplication = this.queryDeduplication;\n    }\n\n    var observable;\n    var serverQuery = this.transform(query).serverQuery;\n\n    if (serverQuery) {\n      var _a = this,\n          inFlightLinkObservables_1 = _a.inFlightLinkObservables,\n          link = _a.link;\n\n      var operation = {\n        query: serverQuery,\n        variables: variables,\n        operationName: getOperationName(serverQuery) || void 0,\n        context: this.prepareContext(__assign(__assign({}, context), {\n          forceFetch: !deduplication\n        }))\n      };\n      context = operation.context;\n\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\n        if (!observable) {\n          byVariables_1.set(varJson_1, observable = multiplex(execute(link, operation)));\n\n          var cleanup = function cleanup() {\n            byVariables_1.delete(varJson_1);\n            if (!byVariables_1.size) inFlightLinkObservables_1.delete(serverQuery);\n            cleanupSub_1.unsubscribe();\n          };\n\n          var cleanupSub_1 = observable.subscribe({\n            next: cleanup,\n            error: cleanup,\n            complete: cleanup\n          });\n        }\n      } else {\n        observable = multiplex(execute(link, operation));\n      }\n    } else {\n      observable = Observable.of({\n        data: {}\n      });\n      context = this.prepareContext(context);\n    }\n\n    var clientQuery = this.transform(query).clientQuery;\n\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\n    return observable;\n  };\n\n  QueryManager.prototype.fetchRequest = function (_a) {\n    var _this = this;\n\n    var requestId = _a.requestId,\n        queryId = _a.queryId,\n        document = _a.document,\n        options = _a.options,\n        fetchMoreForQueryId = _a.fetchMoreForQueryId;\n    var variables = options.variables,\n        _b = options.errorPolicy,\n        errorPolicy = _b === void 0 ? 'none' : _b,\n        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\n      var fqrfId = \"fetchRequest:\" + queryId;\n\n      _this.fetchQueryRejectFns.set(fqrfId, reject);\n\n      var cleanup = function cleanup() {\n        _this.fetchQueryRejectFns.delete(fqrfId);\n\n        _this.setQuery(queryId, function (_a) {\n          var subscriptions = _a.subscriptions;\n          subscriptions.delete(subscription);\n        });\n      };\n\n      var subscription = observable.map(function (result) {\n        if (requestId >= _this.getQuery(queryId).lastRequestId) {\n          _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n\n          _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);\n\n          _this.invalidate(queryId);\n\n          _this.invalidate(fetchMoreForQueryId);\n\n          _this.broadcastQueries();\n        }\n\n        if (errorPolicy === 'none' && isNonEmptyArray(result.errors)) {\n          return reject(new ApolloError({\n            graphQLErrors: result.errors\n          }));\n        }\n\n        if (errorPolicy === 'all') {\n          errorsFromStore = result.errors;\n        }\n\n        if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {\n          resultFromStore = result.data;\n        } else {\n          var _a = _this.dataStore.getCache().diff({\n            variables: variables,\n            query: document,\n            optimistic: false,\n            returnPartialData: true\n          }),\n              result_1 = _a.result,\n              complete = _a.complete;\n\n          if (complete || options.returnPartialData) {\n            resultFromStore = result_1;\n          }\n        }\n      }).subscribe({\n        error: function error(_error3) {\n          cleanup();\n          reject(_error3);\n        },\n        complete: function complete() {\n          cleanup();\n          resolve({\n            data: resultFromStore,\n            errors: errorsFromStore,\n            loading: false,\n            networkStatus: NetworkStatus.ready,\n            stale: false\n          });\n        }\n      });\n\n      _this.setQuery(queryId, function (_a) {\n        var subscriptions = _a.subscriptions;\n        subscriptions.add(subscription);\n      });\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\n  QueryManager.prototype.setQuery = function (queryId, updater) {\n    var prev = this.getQuery(queryId);\n\n    var newInfo = __assign(__assign({}, prev), updater(prev));\n\n    this.queries.set(queryId, newInfo);\n  };\n\n  QueryManager.prototype.invalidate = function (queryId, invalidated) {\n    if (invalidated === void 0) {\n      invalidated = true;\n    }\n\n    if (queryId) {\n      this.setQuery(queryId, function () {\n        return {\n          invalidated: invalidated\n        };\n      });\n    }\n  };\n\n  QueryManager.prototype.prepareContext = function (context) {\n    if (context === void 0) {\n      context = {};\n    }\n\n    var newContext = this.localState.prepareContext(context);\n    return __assign(__assign({}, newContext), {\n      clientAwareness: this.clientAwareness\n    });\n  };\n\n  QueryManager.prototype.checkInFlight = function (queryId) {\n    var query = this.queryStore.get(queryId);\n    return query && query.networkStatus !== NetworkStatus.ready && query.networkStatus !== NetworkStatus.error;\n  };\n\n  QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n    var _this = this;\n\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\n    if (!this.ssrMode) {\n      var info = this.pollingInfoByQueryId.get(queryId);\n\n      if (!info) {\n        this.pollingInfoByQueryId.set(queryId, info = {});\n      }\n\n      info.interval = pollInterval;\n      info.options = __assign(__assign({}, options), {\n        fetchPolicy: 'network-only'\n      });\n\n      var maybeFetch_1 = function maybeFetch_1() {\n        var info = _this.pollingInfoByQueryId.get(queryId);\n\n        if (info) {\n          if (_this.checkInFlight(queryId)) {\n            poll_1();\n          } else {\n            _this.fetchQuery(queryId, info.options, FetchType.poll).then(poll_1, poll_1);\n          }\n        }\n      };\n\n      var poll_1 = function poll_1() {\n        var info = _this.pollingInfoByQueryId.get(queryId);\n\n        if (info) {\n          clearTimeout(info.timeout);\n          info.timeout = setTimeout(maybeFetch_1, info.interval);\n        }\n      };\n\n      if (listener) {\n        this.addQueryListener(queryId, listener);\n      }\n\n      poll_1();\n    }\n\n    return queryId;\n  };\n\n  QueryManager.prototype.stopPollingQuery = function (queryId) {\n    this.pollingInfoByQueryId.delete(queryId);\n  };\n\n  return QueryManager;\n}();\n\nvar DataStore = function () {\n  function DataStore(initialCache) {\n    this.cache = initialCache;\n  }\n\n  DataStore.prototype.getCache = function () {\n    return this.cache;\n  };\n\n  DataStore.prototype.markQueryResult = function (result, document, variables, fetchMoreForQueryId, ignoreErrors) {\n    if (ignoreErrors === void 0) {\n      ignoreErrors = false;\n    }\n\n    var writeWithErrors = !graphQLResultHasError(result);\n\n    if (ignoreErrors && graphQLResultHasError(result) && result.data) {\n      writeWithErrors = true;\n    }\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\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\n  DataStore.prototype.markMutationInit = function (mutation) {\n    var _this = this;\n\n    if (mutation.optimisticResponse) {\n      var optimistic_1;\n\n      if (typeof mutation.optimisticResponse === 'function') {\n        optimistic_1 = mutation.optimisticResponse(mutation.variables);\n      } else {\n        optimistic_1 = mutation.optimisticResponse;\n      }\n\n      this.cache.recordOptimisticTransaction(function (c) {\n        var orig = _this.cache;\n        _this.cache = c;\n\n        try {\n          _this.markMutationResult({\n            mutationId: mutation.mutationId,\n            result: {\n              data: optimistic_1\n            },\n            document: mutation.document,\n            variables: mutation.variables,\n            updateQueries: mutation.updateQueries,\n            update: mutation.update\n          });\n        } finally {\n          _this.cache = orig;\n        }\n      }, mutation.mutationId);\n    }\n  };\n\n  DataStore.prototype.markMutationResult = function (mutation) {\n    var _this = this;\n\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\n      if (updateQueries_1) {\n        Object.keys(updateQueries_1).forEach(function (id) {\n          var _a = updateQueries_1[id],\n              query = _a.query,\n              updater = _a.updater;\n\n          var _b = _this.cache.diff({\n            query: query.document,\n            variables: query.variables,\n            returnPartialData: true,\n            optimistic: false\n          }),\n              currentQueryResult = _b.result,\n              complete = _b.complete;\n\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\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\n      this.cache.performTransaction(function (c) {\n        cacheWrites_1.forEach(function (write) {\n          return c.write(write);\n        });\n        var update = mutation.update;\n\n        if (update) {\n          tryFunctionOrLogError(function () {\n            return update(c, mutation.result);\n          });\n        }\n      });\n    }\n  };\n\n  DataStore.prototype.markMutationComplete = function (_a) {\n    var mutationId = _a.mutationId,\n        optimisticResponse = _a.optimisticResponse;\n\n    if (optimisticResponse) {\n      this.cache.removeOptimistic(mutationId);\n    }\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\n  DataStore.prototype.reset = function () {\n    return this.cache.reset();\n  };\n\n  return DataStore;\n}();\n\nvar version = \"2.6.10\";\nvar hasSuggestedDevtools = false;\n\nvar ApolloClient = function () {\n  function ApolloClient(options) {\n    var _this = this;\n\n    this.defaultOptions = {};\n    this.resetStoreCallbacks = [];\n    this.clearStoreCallbacks = [];\n    var cache = options.cache,\n        _a = options.ssrMode,\n        ssrMode = _a === void 0 ? false : _a,\n        _b = options.ssrForceFetchDelay,\n        ssrForceFetchDelay = _b === void 0 ? 0 : _b,\n        connectToDevTools = options.connectToDevTools,\n        _c = options.queryDeduplication,\n        queryDeduplication = _c === void 0 ? true : _c,\n        defaultOptions = options.defaultOptions,\n        _d = options.assumeImmutableResults,\n        assumeImmutableResults = _d === void 0 ? false : _d,\n        resolvers = options.resolvers,\n        typeDefs = options.typeDefs,\n        fragmentMatcher = options.fragmentMatcher,\n        clientAwarenessName = options.name,\n        clientAwarenessVersion = options.version;\n    var link = options.link;\n\n    if (!link && resolvers) {\n      link = ApolloLink.empty();\n    }\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\" + \"These options are part of the upgrade requirements when migrating from Apollo Client 1.x to Apollo Client 2.x.\\n\" + \"For more information, please visit: https://www.apollographql.com/docs/tutorial/client.html#apollo-client-setup\");\n    }\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\n    if (ssrForceFetchDelay) {\n      setTimeout(function () {\n        return _this.disableNetworkFetches = false;\n      }, ssrForceFetchDelay);\n    }\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' && typeof window !== 'undefined' && !window.__APOLLO_CLIENT__;\n\n    if (typeof connectToDevTools === 'undefined' ? defaultConnectToDevTools : connectToDevTools && typeof window !== 'undefined') {\n      window.__APOLLO_CLIENT__ = this;\n    }\n\n    if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n      hasSuggestedDevtools = true;\n\n      if (typeof window !== 'undefined' && window.document && window.top === window.self) {\n        if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n          if (window.navigator && window.navigator.userAgent && window.navigator.userAgent.indexOf('Chrome') > -1) {\n            console.debug('Download the Apollo DevTools ' + 'for a better development experience: ' + 'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n          }\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 onBroadcast() {\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\n  ApolloClient.prototype.stop = function () {\n    this.queryManager.stop();\n  };\n\n  ApolloClient.prototype.watchQuery = function (options) {\n    if (this.defaultOptions.watchQuery) {\n      options = __assign(__assign({}, this.defaultOptions.watchQuery), options);\n    }\n\n    if (this.disableNetworkFetches && (options.fetchPolicy === 'network-only' || options.fetchPolicy === 'cache-and-network')) {\n      options = __assign(__assign({}, options), {\n        fetchPolicy: 'cache-first'\n      });\n    }\n\n    return this.queryManager.watchQuery(options);\n  };\n\n  ApolloClient.prototype.query = function (options) {\n    if (this.defaultOptions.query) {\n      options = __assign(__assign({}, this.defaultOptions.query), options);\n    }\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 ' + 'client.query can only return a single result. Please use client.watchQuery ' + 'to receive multiple results from the cache and the network, or consider ' + 'using a different fetchPolicy, such as cache-first or network-only.');\n\n    if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n      options = __assign(__assign({}, options), {\n        fetchPolicy: 'cache-first'\n      });\n    }\n\n    return this.queryManager.query(options);\n  };\n\n  ApolloClient.prototype.mutate = function (options) {\n    if (this.defaultOptions.mutate) {\n      options = __assign(__assign({}, this.defaultOptions.mutate), options);\n    }\n\n    return this.queryManager.mutate(options);\n  };\n\n  ApolloClient.prototype.subscribe = function (options) {\n    return this.queryManager.startGraphQLSubscription(options);\n  };\n\n  ApolloClient.prototype.readQuery = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.cache.readQuery(options, optimistic);\n  };\n\n  ApolloClient.prototype.readFragment = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.cache.readFragment(options, optimistic);\n  };\n\n  ApolloClient.prototype.writeQuery = function (options) {\n    var result = this.cache.writeQuery(options);\n    this.queryManager.broadcastQueries();\n    return result;\n  };\n\n  ApolloClient.prototype.writeFragment = function (options) {\n    var result = this.cache.writeFragment(options);\n    this.queryManager.broadcastQueries();\n    return result;\n  };\n\n  ApolloClient.prototype.writeData = function (options) {\n    var result = this.cache.writeData(options);\n    this.queryManager.broadcastQueries();\n    return result;\n  };\n\n  ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n    this.devToolsHookCb = cb;\n  };\n\n  ApolloClient.prototype.__requestRaw = function (payload) {\n    return execute(this.link, payload);\n  };\n\n  ApolloClient.prototype.initQueryManager = function () {\n    process.env.NODE_ENV === \"production\" || invariant.warn('Calling the initQueryManager method is no longer necessary, ' + 'and it will be removed from ApolloClient in version 3.0.');\n    return this.queryManager;\n  };\n\n  ApolloClient.prototype.resetStore = function () {\n    var _this = this;\n\n    return Promise.resolve().then(function () {\n      return _this.queryManager.clearStore();\n    }).then(function () {\n      return Promise.all(_this.resetStoreCallbacks.map(function (fn) {\n        return fn();\n      }));\n    }).then(function () {\n      return _this.reFetchObservableQueries();\n    });\n  };\n\n  ApolloClient.prototype.clearStore = function () {\n    var _this = this;\n\n    return Promise.resolve().then(function () {\n      return _this.queryManager.clearStore();\n    }).then(function () {\n      return Promise.all(_this.clearStoreCallbacks.map(function (fn) {\n        return fn();\n      }));\n    });\n  };\n\n  ApolloClient.prototype.onResetStore = function (cb) {\n    var _this = this;\n\n    this.resetStoreCallbacks.push(cb);\n    return function () {\n      _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) {\n        return c !== cb;\n      });\n    };\n  };\n\n  ApolloClient.prototype.onClearStore = function (cb) {\n    var _this = this;\n\n    this.clearStoreCallbacks.push(cb);\n    return function () {\n      _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) {\n        return c !== cb;\n      });\n    };\n  };\n\n  ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n    return this.queryManager.reFetchObservableQueries(includeStandby);\n  };\n\n  ApolloClient.prototype.extract = function (optimistic) {\n    return this.cache.extract(optimistic);\n  };\n\n  ApolloClient.prototype.restore = function (serializedState) {\n    return this.cache.restore(serializedState);\n  };\n\n  ApolloClient.prototype.addResolvers = function (resolvers) {\n    this.localState.addResolvers(resolvers);\n  };\n\n  ApolloClient.prototype.setResolvers = function (resolvers) {\n    this.localState.setResolvers(resolvers);\n  };\n\n  ApolloClient.prototype.getResolvers = function () {\n    return this.localState.getResolvers();\n  };\n\n  ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n    this.localState.setFragmentMatcher(fragmentMatcher);\n  };\n\n  return ApolloClient;\n}();\n\nexport default ApolloClient;\nexport { ApolloClient, ApolloError, FetchType, NetworkStatus, ObservableQuery, isApolloError };"],"sourceRoot":""}