{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack:///./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack:///./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack:///./node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack:///./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack:///./node_modules/apollo-cache/lib/bundle.esm.js","webpack:///./node_modules/apollo-cache-inmemory/lib/bundle.esm.js","webpack:///./node_modules/apollo-boost/lib/bundle.esm.js","webpack:///./node_modules/apollo-utilities/lib/bundle.esm.js","webpack:///./node_modules/apollo-link-http-common/lib/bundle.esm.js","webpack:///./node_modules/apollo-link-http/lib/bundle.esm.js","webpack:///./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack:///./node_modules/apollo-client/bundle.esm.js","webpack:///./node_modules/@wry/context/lib/context.esm.js","webpack:///./node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js","webpack:///./node_modules/@wry/equality/lib/equality.esm.js","webpack:///./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/@socket.io/component-emitter/index.mjs","webpack:///./node_modules/apollo-link/lib/bundle.esm.js","webpack:///./node_modules/apollo-link-error/lib/bundle.esm.js"],"names":["_unsupportedIterableToArray","r","a","arrayLikeToArray","t","toString","call","slice","constructor","name","Array","from","test","asyncGeneratorStep","n","e","o","c","i","u","value","done","Promise","resolve","then","_asyncToGenerator","this","arguments","apply","_next","_throw","_arrayWithoutHoles","isArray","_iterableToArray","Symbol","iterator","_nonIterableSpread","TypeError","_toConsumableArray","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","queryFromPojo","obj","op","kind","operation","selectionSet","selectionSetFromObj","out","definitions","fragmentFromPojo","typename","frag","typeCondition","selections","Object","keys","forEach","key","nestedSelSet","field","undefined","push","Cache","justTypenameQuery","variableDefinitions","directives","alias","ApolloCache","prototype","transformDocument","document","transformForLink","readQuery","options","optimistic","read","query","variables","readFragment","fragment","fragmentName","rootId","id","writeQuery","write","dataId","result","data","writeFragment","writeData","_a","typenameResult","__typename","dataToWrite","assign","haveWarned","shouldWarn","answer","HeuristicFragmentMatcher","ensureReady","canBypassInit","match","idValue","context","store","get","isRootQuery","hasOwn","IntrospectionFragmentMatcher","introspectionQueryResultData","possibleTypesMap","parseIntrospectionResult","isReady","bind","implementingTypes","indexOf","introspectionResultData","typeMap","__schema","types","type","possibleTypes","map","implementingType","hasOwnProperty","DepTrackingCache","_this","create","depend","disposable","makeCacheKey","toObject","set","oldValue","dirty","delete","clear","replace","newData","defaultNormalizedCacheFactory","seed","StoreReader","_b","_c","cacheKeyRoot","_d","freezeResults","_e","executeStoreQuery","executeSelectionSet","executeSubSelectedArray","rootValue","contextValue","variableValues","fragmentMatcher","lookup","JSON","stringify","execContext","array","readQueryFromStore","diffQueryAgainstStore","returnPartialData","previousResult","fragmentMatcherFunction","config","queryDefinition","dataIdFromObject","cacheRedirects","execResult","generated","hasMissingFields","missing","length","info","tolerable","complete","defaultFragmentMatcher","mainDefinition","fragments","fragmentMap","finalResult","objectsToMerge","object","handleMissing","selection","fieldResult","executeField","fragmentExecResult","fieldName","args","resultKey","readStoreResult","readStoreResolver","combineExecResults","assertSelectionSetForIdValue","execResults","_i","pop","childResult","item","storeKeyName","fieldValue","resolver","getCacheKey","storeObj","json","ObjectCache","_super","WriteError","Error","enhanceErrorWithDocument","error","enhancedError","message","stack","StoreWriter","writeQueryToStore","writeResultToStore","operationDefinition","writeSelectionSetToStore","processedData","resultFieldKey","writeFieldToStore","isDefered","isClient","some","directive","matches","fakeContext","storeValue","storeObject","storeFieldName","generatedId","processArrayValue","valueDataId","isGeneratedId","semanticId","isDataProcessed","escapedId","hadTypename","hasTypename","typenameChanged","mergeWithGenerated","index","itemDataId","generatedKey","realKey","cache","real","madeChanges","realValue","newRealValue","defaultConfig","defaultDataIdFromObject","addTypename","resultCaching","_id","hasOwn$1","OptimisticCacheLayer","optimisticId","parent","transaction","InMemoryCache","watches","Set","typenameDocumentCache","Map","silenceBroadcast","customResolvers","cacheResolvers","optimisticData","storeWriter","storeReader","maybeBroadcastWatch","restore","extract","broadcastWatches","diff","watch","add","evict","reset","removeOptimistic","idToRemove","toReapply","removedCount","layer","layer_1","performTransaction","recordOptimisticTransaction","callback","PRESET_CONFIG_KEYS","DefaultClient","filter","request","uri","credentials","headers","fetch","fetchOptions","clientState","errorCallback","onError","version","resolvers","typeDefs","errorLink","graphQLErrors","networkError","locations","path","requestHandler","forward","observer","handle","oper","subscribe","next","catch","unsubscribe","httpLink","link","x","activeResolvers","activeTypeDefs","activeFragmentMatcher","defaults","isStringValue","isBooleanValue","isIntValue","isFloatValue","isVariable","isObjectValue","isListValue","isEnumValue","isNullValue","valueToObjectRepresentation","argObj","Number","nestedArgObj_1","fields","variableValue","values","listValue","nestedArgArrayObj","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","getInclusionDirectives","every","ifArgument","evaledValue","getDirectiveNames","doc","names","Directive","node","hasDirectives","hasClientExports","isInclusionDirective","directiveArguments","ifValue","getFragmentQueryDocument","actualFragmentName","definition","target","sources","source","checkDocument","operations","d","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","queryDef","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","getDefaultValues","defaultValues","defaultValue","variable","defaultValueObj","filterInPlace","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","Field","shouldRemoveField","remove","arg","getAllFragmentSpreadsFromSelectionSet","FragmentSpread","v","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","skip","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","getArgumentMatcher","argument","aConfig","argMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","def","FragmentDefinition","allFragments","buildQueryFromSelectionSet","definitionOperation","removeClientSetsFromDocument","isTypenameOnly","canUseWeakMap","WeakMap","navigator","product","cloneDeep","cloneDeepHelper","val","seen","has","copy_1","child","copy_2","getPrototypeOf","getEnv","process","isEnv","env","isProduction","isDevelopment","isTest","tryFunctionOrLogError","f","console","graphQLResultHasError","errors","deepFreeze","freeze","getOwnPropertyNames","prop","isFrozen","maybeDeepFreeze","symbolIsPolyfilled","mergeDeep","mergeDeepArray","count","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","__proto__","defaultHttpOptions","includeQuery","includeExtensions","defaultHeaders","accept","defaultOptions","method","fallbackHttpConfig","http","throwServerError","response","statusCode","status","parseAndCheckHttpResponse","text","bodyText","parse","err","parseError","reject","operationName","checkFetcher","fetcher","window","createSignalIfSupported","AbortController","controller","signal","selectHttpOptionsAndBody","fallbackConfig","configs","extensions","body","serializeFetchParameter","p","label","serialized","selectURI","fallbackURI","getContext","contextURI","createHttpLink","linkOptions","useGETForQueries","requestOptions","linkConfig","chosenURI","clientAwarenessHeaders","clientAwareness","name_1","contextHeaders","contextConfig","_controller","definitionIsMutation","rewriteURIForGET","newURI","setContext","abort","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","join","HttpLink","opts","_arrayLikeToArray","NetworkStatus","isNetworkRequestInFlight","networkStatus","Observable","isNonEmptyArray","isApolloError","FetchType","generateErrorMessage","graphQLError","errorMessage","ApolloError","extraInfo","hasError","policy","ObservableQuery","queryManager","shouldSubscribe","onSubscribe","observers","subscriptions","isTornDown","queryId","generateQueryId","opDef","queryName","size","removeQuery","setTimeout","subscription","currentResult","getCurrentResult","lastResult","lastError","loading","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","first","setUpQuery","tearDownQuery","addObservableQuery","iterateObserversSafely","observeQuery","previousResult_1","query_1","fetchPolicy_1","transform","getLocalState","addExportedVariables","previousVariables","serverQuery","sub","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","capitalizeFirstLetter","str","charAt","toUpperCase","LocalState","client","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","resolveDocument","localResult","getFragmentMatcher","clientQuery","prepareContext","newContext","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","defaultOperationType","resolveSelectionSet","resultsToMerge","execute","resolveField","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","resolveSubSelectedArray","multiplex","inner","asyncMap","observable","activeNextCount","completed","handler","QueryManager","queryDeduplication","onBroadcast","ssrMode","localState","mutationStore","idCounter","queries","fetchQueryRejectFns","transformCache","inFlightLinkObservables","pollingInfoByQueryId","getCache","stop","_info","stopQueryNoBroadcast","mutate","optimisticResponse","updateQueriesByName","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","update","generateUpdateQueriesInfo","self","_f","setQuery","getVariables","sent","ret","observableQuery","updater","markMutationInit","storeResult","getObservableFromLink","markMutationComplete","refetchQueryPromises","refetchQuery","queryOptions","fetchType","isNetworkOnly","needToFetch","shouldFetch","requestId","cancel","networkResult","updateQueryWatch","lastRequestId","invalidated","invalidate","fetchRequest","getQuery","hasForcedResolvers","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","of","errorsFromStore","fqrfId","result_1","prev","newInfo","checkInFlight","interval","maybeFetch_1","poll_1","clearTimeout","timeout","DataStore","initialCache","ignoreErrors","writeWithErrors","optimistic_1","orig","cacheWrites_1","updateQueries_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","clientAwarenessName","clientAwarenessVersion","empty","disableNetworkFetches","defaultConnectToDevTools","__APOLLO_CLIENT__","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","__actionHookForDevTools","cb","__requestRaw","payload","initQueryManager","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","currentContext","MISSING_VALUE","makeSlotClass","Slot","Date","now","Math","random","hasValue","context_1","slots","getValue","withValue","thisArg","saved","noContext","globalKey","host","defineProperty","enumerable","writable","configurable","_taggedTemplateLiteral","defineProperties","raw","previousComparisons","equal","b","check","aTag","bTag","previouslyCompared","aKeys","bKeys","keyCount","k","aIterator","entries","isMap","aKey","aValue","bSet","_typeof","toPrimitive","toPropertyKey","_defineProperty","Emitter","mixin","on","addEventListener","event","_callbacks","once","off","removeListener","removeAllListeners","removeEventListener","callbacks","splice","emit","len","emitReserved","hasListeners","validateOperation","OPERATION_FIELDS","LinkError","isTerminating","fromError","errorValue","transformOperation","transformedOperation","createOperation","starting","getKey","passthrough","toLink","ApolloLink","links","reduce","y","concat","split","left","right","leftLink","rightLink","second","firstLink","nextLink","errorHandler","retriedSub","retriedResult","ErrorLink"],"mappings":"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","file":"js/chunk-vendors~253ae210.014fd0cf.js","sourcesContent":["import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n  }\n}\nexport { _unsupportedIterableToArray as default };","function asyncGeneratorStep(n, t, e, r, o, a, c) {\n  try {\n    var i = n[a](c),\n      u = i.value;\n  } catch (n) {\n    return void e(n);\n  }\n  i.done ? t(u) : Promise.resolve(u).then(r, o);\n}\nfunction _asyncToGenerator(n) {\n  return function () {\n    var t = this,\n      e = arguments;\n    return new Promise(function (r, o) {\n      var a = n.apply(t, e);\n      function _next(n) {\n        asyncGeneratorStep(a, r, o, _next, _throw, \"next\", n);\n      }\n      function _throw(n) {\n        asyncGeneratorStep(a, r, o, _next, _throw, \"throw\", n);\n      }\n      _next(void 0);\n    });\n  };\n}\nexport { _asyncToGenerator as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n  if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _iterableToArray(r) {\n  if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n  return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import { getFragmentQueryDocument } from 'apollo-utilities';\n\nfunction queryFromPojo(obj) {\n    var op = {\n        kind: 'OperationDefinition',\n        operation: 'query',\n        name: {\n            kind: 'Name',\n            value: 'GeneratedClientQuery',\n        },\n        selectionSet: selectionSetFromObj(obj),\n    };\n    var out = {\n        kind: 'Document',\n        definitions: [op],\n    };\n    return out;\n}\nfunction fragmentFromPojo(obj, typename) {\n    var frag = {\n        kind: 'FragmentDefinition',\n        typeCondition: {\n            kind: 'NamedType',\n            name: {\n                kind: 'Name',\n                value: typename || '__FakeType',\n            },\n        },\n        name: {\n            kind: 'Name',\n            value: 'GeneratedClientQuery',\n        },\n        selectionSet: selectionSetFromObj(obj),\n    };\n    var out = {\n        kind: 'Document',\n        definitions: [frag],\n    };\n    return out;\n}\nfunction selectionSetFromObj(obj) {\n    if (typeof obj === 'number' ||\n        typeof obj === 'boolean' ||\n        typeof obj === 'string' ||\n        typeof obj === 'undefined' ||\n        obj === null) {\n        return null;\n    }\n    if (Array.isArray(obj)) {\n        return selectionSetFromObj(obj[0]);\n    }\n    var selections = [];\n    Object.keys(obj).forEach(function (key) {\n        var nestedSelSet = selectionSetFromObj(obj[key]);\n        var field = {\n            kind: 'Field',\n            name: {\n                kind: 'Name',\n                value: key,\n            },\n            selectionSet: nestedSelSet || undefined,\n        };\n        selections.push(field);\n    });\n    var selectionSet = {\n        kind: 'SelectionSet',\n        selections: selections,\n    };\n    return selectionSet;\n}\nvar justTypenameQuery = {\n    kind: 'Document',\n    definitions: [\n        {\n            kind: 'OperationDefinition',\n            operation: 'query',\n            name: null,\n            variableDefinitions: null,\n            directives: [],\n            selectionSet: {\n                kind: 'SelectionSet',\n                selections: [\n                    {\n                        kind: 'Field',\n                        alias: null,\n                        name: {\n                            kind: 'Name',\n                            value: '__typename',\n                        },\n                        arguments: [],\n                        directives: [],\n                        selectionSet: null,\n                    },\n                ],\n            },\n        },\n    ],\n};\n\nvar ApolloCache = (function () {\n    function ApolloCache() {\n    }\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: options.query,\n            variables: options.variables,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n            variables: options.variables,\n            rootId: options.id,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.writeQuery = function (options) {\n        this.write({\n            dataId: 'ROOT_QUERY',\n            result: options.data,\n            query: options.query,\n            variables: options.variables,\n        });\n    };\n    ApolloCache.prototype.writeFragment = function (options) {\n        this.write({\n            dataId: options.id,\n            result: options.data,\n            variables: options.variables,\n            query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n        });\n    };\n    ApolloCache.prototype.writeData = function (_a) {\n        var id = _a.id, data = _a.data;\n        if (typeof id !== 'undefined') {\n            var typenameResult = null;\n            try {\n                typenameResult = this.read({\n                    rootId: id,\n                    optimistic: false,\n                    query: justTypenameQuery,\n                });\n            }\n            catch (e) {\n            }\n            var __typename = (typenameResult && typenameResult.__typename) || '__ClientData';\n            var dataToWrite = Object.assign({ __typename: __typename }, data);\n            this.writeFragment({\n                id: id,\n                fragment: fragmentFromPojo(dataToWrite, __typename),\n                data: dataToWrite,\n            });\n        }\n        else {\n            this.writeQuery({ query: queryFromPojo(data), data: data });\n        }\n    };\n    return ApolloCache;\n}());\n\nvar Cache;\n(function (Cache) {\n})(Cache || (Cache = {}));\n\nexport { ApolloCache, Cache };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __assign, __extends } from 'tslib';\nimport { ApolloCache } from 'apollo-cache';\nimport { isTest, getQueryDefinition, assign, getDefaultValues, isEqual, getMainDefinition, getFragmentDefinitions, createFragmentMap, shouldInclude, isField, resultKeyNameFromField, isInlineFragment, mergeDeepArray, argumentsObjectFromField, getDirectiveInfoFromField, maybeDeepFreeze, isIdValue, getStoreKeyName, toIdValue, isJsonValue, canUseWeakMap, getOperationDefinition, isProduction, storeKeyNameFromField, addTypenameToDocument } from 'apollo-utilities';\nimport { wrap, KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\n\nvar haveWarned = false;\nfunction shouldWarn() {\n    var answer = !haveWarned;\n    if (!isTest()) {\n        haveWarned = true;\n    }\n    return answer;\n}\nvar HeuristicFragmentMatcher = (function () {\n    function HeuristicFragmentMatcher() {\n    }\n    HeuristicFragmentMatcher.prototype.ensureReady = function () {\n        return Promise.resolve();\n    };\n    HeuristicFragmentMatcher.prototype.canBypassInit = function () {\n        return true;\n    };\n    HeuristicFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        if (!__typename) {\n            if (shouldWarn()) {\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"You're using fragments in your queries, but either don't have the addTypename:\\n  true option set in Apollo Client, or you are trying to write a fragment to the store without the __typename.\\n   Please turn on the addTypename option and include __typename when writing fragments so that Apollo Client\\n   can accurately match fragments.\");\n                process.env.NODE_ENV === \"production\" || invariant.warn('Could not find __typename on Fragment ', typeCondition, obj);\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"DEPRECATION WARNING: using fragments without __typename is unsupported behavior \" +\n                    \"and will be removed in future versions of Apollo client. You should fix this and set addTypename to true now.\");\n            }\n            return 'heuristic';\n        }\n        if (__typename === typeCondition) {\n            return true;\n        }\n        if (shouldWarn()) {\n            process.env.NODE_ENV === \"production\" || invariant.error('You are using the simple (heuristic) fragment matcher, but your ' +\n                'queries contain union or interface types. Apollo Client will not be ' +\n                'able to accurately map fragments. To make this error go away, use ' +\n                'the `IntrospectionFragmentMatcher` as described in the docs: ' +\n                'https://www.apollographql.com/docs/react/advanced/fragments.html#fragment-matcher');\n        }\n        return 'heuristic';\n    };\n    return HeuristicFragmentMatcher;\n}());\nvar IntrospectionFragmentMatcher = (function () {\n    function IntrospectionFragmentMatcher(options) {\n        if (options && options.introspectionQueryResultData) {\n            this.possibleTypesMap = this.parseIntrospectionResult(options.introspectionQueryResultData);\n            this.isReady = true;\n        }\n        else {\n            this.isReady = false;\n        }\n        this.match = this.match.bind(this);\n    }\n    IntrospectionFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        process.env.NODE_ENV === \"production\" ? invariant(this.isReady, 2) : invariant(this.isReady, 'FragmentMatcher.match() was called before FragmentMatcher.init()');\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        process.env.NODE_ENV === \"production\" ? invariant(__typename, 3) : invariant(__typename, \"Cannot match fragment because __typename property is missing: \" + JSON.stringify(obj));\n        if (__typename === typeCondition) {\n            return true;\n        }\n        var implementingTypes = this.possibleTypesMap[typeCondition];\n        if (__typename &&\n            implementingTypes &&\n            implementingTypes.indexOf(__typename) > -1) {\n            return true;\n        }\n        return false;\n    };\n    IntrospectionFragmentMatcher.prototype.parseIntrospectionResult = function (introspectionResultData) {\n        var typeMap = {};\n        introspectionResultData.__schema.types.forEach(function (type) {\n            if (type.kind === 'UNION' || type.kind === 'INTERFACE') {\n                typeMap[type.name] = type.possibleTypes.map(function (implementingType) { return implementingType.name; });\n            }\n        });\n        return typeMap;\n    };\n    return IntrospectionFragmentMatcher;\n}());\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar DepTrackingCache = (function () {\n    function DepTrackingCache(data) {\n        var _this = this;\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n        this.depend = wrap(function (dataId) { return _this.data[dataId]; }, {\n            disposable: true,\n            makeCacheKey: function (dataId) {\n                return dataId;\n            },\n        });\n    }\n    DepTrackingCache.prototype.toObject = function () {\n        return this.data;\n    };\n    DepTrackingCache.prototype.get = function (dataId) {\n        this.depend(dataId);\n        return this.data[dataId];\n    };\n    DepTrackingCache.prototype.set = function (dataId, value) {\n        var oldValue = this.data[dataId];\n        if (value !== oldValue) {\n            this.data[dataId] = value;\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.delete = function (dataId) {\n        if (hasOwn.call(this.data, dataId)) {\n            delete this.data[dataId];\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.clear = function () {\n        this.replace(null);\n    };\n    DepTrackingCache.prototype.replace = function (newData) {\n        var _this = this;\n        if (newData) {\n            Object.keys(newData).forEach(function (dataId) {\n                _this.set(dataId, newData[dataId]);\n            });\n            Object.keys(this.data).forEach(function (dataId) {\n                if (!hasOwn.call(newData, dataId)) {\n                    _this.delete(dataId);\n                }\n            });\n        }\n        else {\n            Object.keys(this.data).forEach(function (dataId) {\n                _this.delete(dataId);\n            });\n        }\n    };\n    return DepTrackingCache;\n}());\nfunction defaultNormalizedCacheFactory(seed) {\n    return new DepTrackingCache(seed);\n}\n\nvar StoreReader = (function () {\n    function StoreReader(_a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.cacheKeyRoot, cacheKeyRoot = _c === void 0 ? new KeyTrie(canUseWeakMap) : _c, _d = _b.freezeResults, freezeResults = _d === void 0 ? false : _d;\n        var _e = this, executeStoreQuery = _e.executeStoreQuery, executeSelectionSet = _e.executeSelectionSet, executeSubSelectedArray = _e.executeSubSelectedArray;\n        this.freezeResults = freezeResults;\n        this.executeStoreQuery = wrap(function (options) {\n            return executeStoreQuery.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, fragmentMatcher = _a.fragmentMatcher;\n                if (contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(contextValue.store, query, fragmentMatcher, JSON.stringify(variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSelectionSet = wrap(function (options) {\n            return executeSelectionSet.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, selectionSet, execContext.fragmentMatcher, JSON.stringify(execContext.variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            return executeSubSelectedArray.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, field, array, JSON.stringify(execContext.variableValues));\n                }\n            }\n        });\n    }\n    StoreReader.prototype.readQueryFromStore = function (options) {\n        return this.diffQueryAgainstStore(__assign(__assign({}, options), { returnPartialData: false })).result;\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, variables = _a.variables, previousResult = _a.previousResult, _b = _a.returnPartialData, returnPartialData = _b === void 0 ? true : _b, _c = _a.rootId, rootId = _c === void 0 ? 'ROOT_QUERY' : _c, fragmentMatcherFunction = _a.fragmentMatcherFunction, config = _a.config;\n        var queryDefinition = getQueryDefinition(query);\n        variables = assign({}, getDefaultValues(queryDefinition), variables);\n        var context = {\n            store: store,\n            dataIdFromObject: config && config.dataIdFromObject,\n            cacheRedirects: (config && config.cacheRedirects) || {},\n        };\n        var execResult = this.executeStoreQuery({\n            query: query,\n            rootValue: {\n                type: 'id',\n                id: rootId,\n                generated: true,\n                typename: 'Query',\n            },\n            contextValue: context,\n            variableValues: variables,\n            fragmentMatcher: fragmentMatcherFunction,\n        });\n        var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n        if (hasMissingFields && !returnPartialData) {\n            execResult.missing.forEach(function (info) {\n                if (info.tolerable)\n                    return;\n                throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Can't find field \" + info.fieldName + \" on object \" + JSON.stringify(info.object, null, 2) + \".\");\n            });\n        }\n        if (previousResult) {\n            if (isEqual(previousResult, execResult.result)) {\n                execResult.result = previousResult;\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !hasMissingFields,\n        };\n    };\n    StoreReader.prototype.executeStoreQuery = function (_a) {\n        var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, _b = _a.fragmentMatcher, fragmentMatcher = _b === void 0 ? defaultFragmentMatcher : _b;\n        var mainDefinition = getMainDefinition(query);\n        var fragments = getFragmentDefinitions(query);\n        var fragmentMap = createFragmentMap(fragments);\n        var execContext = {\n            query: query,\n            fragmentMap: fragmentMap,\n            contextValue: contextValue,\n            variableValues: variableValues,\n            fragmentMatcher: fragmentMatcher,\n        };\n        return this.executeSelectionSet({\n            selectionSet: mainDefinition.selectionSet,\n            rootValue: rootValue,\n            execContext: execContext,\n        });\n    };\n    StoreReader.prototype.executeSelectionSet = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n        var fragmentMap = execContext.fragmentMap, contextValue = execContext.contextValue, variables = execContext.variableValues;\n        var finalResult = { result: null };\n        var objectsToMerge = [];\n        var object = contextValue.store.get(rootValue.id);\n        var typename = (object && object.__typename) ||\n            (rootValue.id === 'ROOT_QUERY' && 'Query') ||\n            void 0;\n        function handleMissing(result) {\n            var _a;\n            if (result.missing) {\n                finalResult.missing = finalResult.missing || [];\n                (_a = finalResult.missing).push.apply(_a, result.missing);\n            }\n            return result.result;\n        }\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var fieldResult = handleMissing(_this.executeField(object, typename, selection, execContext));\n                if (typeof fieldResult !== 'undefined') {\n                    objectsToMerge.push((_a = {},\n                        _a[resultKeyNameFromField(selection)] = fieldResult,\n                        _a));\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = fragmentMap[selection.name.value];\n                    if (!fragment) {\n                        throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"No fragment named \" + selection.name.value);\n                    }\n                }\n                var typeCondition = fragment.typeCondition && fragment.typeCondition.name.value;\n                var match = !typeCondition ||\n                    execContext.fragmentMatcher(rootValue, typeCondition, contextValue);\n                if (match) {\n                    var fragmentExecResult = _this.executeSelectionSet({\n                        selectionSet: fragment.selectionSet,\n                        rootValue: rootValue,\n                        execContext: execContext,\n                    });\n                    if (match === 'heuristic' && fragmentExecResult.missing) {\n                        fragmentExecResult = __assign(__assign({}, fragmentExecResult), { missing: fragmentExecResult.missing.map(function (info) {\n                                return __assign(__assign({}, info), { tolerable: true });\n                            }) });\n                    }\n                    objectsToMerge.push(handleMissing(fragmentExecResult));\n                }\n            }\n        });\n        finalResult.result = mergeDeepArray(objectsToMerge);\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(finalResult.result);\n        }\n        return finalResult;\n    };\n    StoreReader.prototype.executeField = function (object, typename, field, execContext) {\n        var variables = execContext.variableValues, contextValue = execContext.contextValue;\n        var fieldName = field.name.value;\n        var args = argumentsObjectFromField(field, variables);\n        var info = {\n            resultKey: resultKeyNameFromField(field),\n            directives: getDirectiveInfoFromField(field, variables),\n        };\n        var readStoreResult = readStoreResolver(object, typename, fieldName, args, contextValue, info);\n        if (Array.isArray(readStoreResult.result)) {\n            return this.combineExecResults(readStoreResult, this.executeSubSelectedArray({\n                field: field,\n                array: readStoreResult.result,\n                execContext: execContext,\n            }));\n        }\n        if (!field.selectionSet) {\n            assertSelectionSetForIdValue(field, readStoreResult.result);\n            if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n                maybeDeepFreeze(readStoreResult);\n            }\n            return readStoreResult;\n        }\n        if (readStoreResult.result == null) {\n            return readStoreResult;\n        }\n        return this.combineExecResults(readStoreResult, this.executeSelectionSet({\n            selectionSet: field.selectionSet,\n            rootValue: readStoreResult.result,\n            execContext: execContext,\n        }));\n    };\n    StoreReader.prototype.combineExecResults = function () {\n        var execResults = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            execResults[_i] = arguments[_i];\n        }\n        var missing;\n        execResults.forEach(function (execResult) {\n            if (execResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, execResult.missing);\n            }\n        });\n        return {\n            result: execResults.pop().result,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.executeSubSelectedArray = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, execContext = _a.execContext;\n        var missing;\n        function handleMissing(childResult) {\n            if (childResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, childResult.missing);\n            }\n            return childResult.result;\n        }\n        array = array.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    execContext: execContext,\n                }));\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    rootValue: item,\n                    execContext: execContext,\n                }));\n            }\n            assertSelectionSetForIdValue(field, item);\n            return item;\n        });\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(array);\n        }\n        return { result: array, missing: missing };\n    };\n    return StoreReader;\n}());\nfunction assertSelectionSetForIdValue(field, value) {\n    if (!field.selectionSet && isIdValue(value)) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError(\"Missing selection set for object of type \" + value.typename + \" returned for query field \" + field.name.value);\n    }\n}\nfunction defaultFragmentMatcher() {\n    return true;\n}\nfunction assertIdValue(idValue) {\n    process.env.NODE_ENV === \"production\" ? invariant(isIdValue(idValue), 11) : invariant(isIdValue(idValue), \"Encountered a sub-selection on the query, but the store doesn't have an object reference. This should never happen during normal use unless you have custom code that is directly manipulating the store; please file an issue.\");\n}\nfunction readStoreResolver(object, typename, fieldName, args, context, _a) {\n    var resultKey = _a.resultKey, directives = _a.directives;\n    var storeKeyName = fieldName;\n    if (args || directives) {\n        storeKeyName = getStoreKeyName(storeKeyName, args, directives);\n    }\n    var fieldValue = void 0;\n    if (object) {\n        fieldValue = object[storeKeyName];\n        if (typeof fieldValue === 'undefined' &&\n            context.cacheRedirects &&\n            typeof typename === 'string') {\n            var type = context.cacheRedirects[typename];\n            if (type) {\n                var resolver = type[fieldName];\n                if (resolver) {\n                    fieldValue = resolver(object, args, {\n                        getCacheKey: function (storeObj) {\n                            var id = context.dataIdFromObject(storeObj);\n                            return id && toIdValue({\n                                id: id,\n                                typename: storeObj.__typename,\n                            });\n                        },\n                    });\n                }\n            }\n        }\n    }\n    if (typeof fieldValue === 'undefined') {\n        return {\n            result: fieldValue,\n            missing: [{\n                    object: object,\n                    fieldName: storeKeyName,\n                    tolerable: false,\n                }],\n        };\n    }\n    if (isJsonValue(fieldValue)) {\n        fieldValue = fieldValue.json;\n    }\n    return {\n        result: fieldValue,\n    };\n}\n\nvar ObjectCache = (function () {\n    function ObjectCache(data) {\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n    }\n    ObjectCache.prototype.toObject = function () {\n        return this.data;\n    };\n    ObjectCache.prototype.get = function (dataId) {\n        return this.data[dataId];\n    };\n    ObjectCache.prototype.set = function (dataId, value) {\n        this.data[dataId] = value;\n    };\n    ObjectCache.prototype.delete = function (dataId) {\n        this.data[dataId] = void 0;\n    };\n    ObjectCache.prototype.clear = function () {\n        this.data = Object.create(null);\n    };\n    ObjectCache.prototype.replace = function (newData) {\n        this.data = newData || Object.create(null);\n    };\n    return ObjectCache;\n}());\nfunction defaultNormalizedCacheFactory$1(seed) {\n    return new ObjectCache(seed);\n}\n\nvar WriteError = (function (_super) {\n    __extends(WriteError, _super);\n    function WriteError() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = 'WriteError';\n        return _this;\n    }\n    return WriteError;\n}(Error));\nfunction enhanceErrorWithDocument(error, document) {\n    var enhancedError = new WriteError(\"Error writing result to store for query:\\n \" + JSON.stringify(document));\n    enhancedError.message += '\\n' + error.message;\n    enhancedError.stack = error.stack;\n    return enhancedError;\n}\nvar StoreWriter = (function () {\n    function StoreWriter() {\n    }\n    StoreWriter.prototype.writeQueryToStore = function (_a) {\n        var query = _a.query, result = _a.result, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        return this.writeResultToStore({\n            dataId: 'ROOT_QUERY',\n            result: result,\n            document: query,\n            store: store,\n            variables: variables,\n            dataIdFromObject: dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n    };\n    StoreWriter.prototype.writeResultToStore = function (_a) {\n        var dataId = _a.dataId, result = _a.result, document = _a.document, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        var operationDefinition = getOperationDefinition(document);\n        try {\n            return this.writeSelectionSetToStore({\n                result: result,\n                dataId: dataId,\n                selectionSet: operationDefinition.selectionSet,\n                context: {\n                    store: store,\n                    processedData: {},\n                    variables: assign({}, getDefaultValues(operationDefinition), variables),\n                    dataIdFromObject: dataIdFromObject,\n                    fragmentMap: createFragmentMap(getFragmentDefinitions(document)),\n                    fragmentMatcherFunction: fragmentMatcherFunction,\n                },\n            });\n        }\n        catch (e) {\n            throw enhanceErrorWithDocument(e, document);\n        }\n    };\n    StoreWriter.prototype.writeSelectionSetToStore = function (_a) {\n        var _this = this;\n        var result = _a.result, dataId = _a.dataId, selectionSet = _a.selectionSet, context = _a.context;\n        var variables = context.variables, store = context.store, fragmentMap = context.fragmentMap;\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var resultFieldKey = resultKeyNameFromField(selection);\n                var value = result[resultFieldKey];\n                if (typeof value !== 'undefined') {\n                    _this.writeFieldToStore({\n                        dataId: dataId,\n                        value: value,\n                        field: selection,\n                        context: context,\n                    });\n                }\n                else {\n                    var isDefered = false;\n                    var isClient = false;\n                    if (selection.directives && selection.directives.length) {\n                        isDefered = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'defer'; });\n                        isClient = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'client'; });\n                    }\n                    if (!isDefered && !isClient && context.fragmentMatcherFunction) {\n                        process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing field \" + resultFieldKey + \" in \" + JSON.stringify(result, null, 2).substring(0, 100));\n                    }\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = (fragmentMap || {})[selection.name.value];\n                    process.env.NODE_ENV === \"production\" ? invariant(fragment, 4) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n                }\n                var matches = true;\n                if (context.fragmentMatcherFunction && fragment.typeCondition) {\n                    var id = dataId || 'self';\n                    var idValue = toIdValue({ id: id, typename: undefined });\n                    var fakeContext = {\n                        store: new ObjectCache((_a = {}, _a[id] = result, _a)),\n                        cacheRedirects: {},\n                    };\n                    var match = context.fragmentMatcherFunction(idValue, fragment.typeCondition.name.value, fakeContext);\n                    if (!isProduction() && match === 'heuristic') {\n                        process.env.NODE_ENV === \"production\" || invariant.error('WARNING: heuristic fragment matching going on!');\n                    }\n                    matches = !!match;\n                }\n                if (matches) {\n                    _this.writeSelectionSetToStore({\n                        result: result,\n                        selectionSet: fragment.selectionSet,\n                        dataId: dataId,\n                        context: context,\n                    });\n                }\n            }\n        });\n        return store;\n    };\n    StoreWriter.prototype.writeFieldToStore = function (_a) {\n        var _b;\n        var field = _a.field, value = _a.value, dataId = _a.dataId, context = _a.context;\n        var variables = context.variables, dataIdFromObject = context.dataIdFromObject, store = context.store;\n        var storeValue;\n        var storeObject;\n        var storeFieldName = storeKeyNameFromField(field, variables);\n        if (!field.selectionSet || value === null) {\n            storeValue =\n                value != null && typeof value === 'object'\n                    ?\n                        { type: 'json', json: value }\n                    :\n                        value;\n        }\n        else if (Array.isArray(value)) {\n            var generatedId = dataId + \".\" + storeFieldName;\n            storeValue = this.processArrayValue(value, generatedId, field.selectionSet, context);\n        }\n        else {\n            var valueDataId = dataId + \".\" + storeFieldName;\n            var generated = true;\n            if (!isGeneratedId(valueDataId)) {\n                valueDataId = '$' + valueDataId;\n            }\n            if (dataIdFromObject) {\n                var semanticId = dataIdFromObject(value);\n                process.env.NODE_ENV === \"production\" ? invariant(!semanticId || !isGeneratedId(semanticId), 5) : invariant(!semanticId || !isGeneratedId(semanticId), 'IDs returned by dataIdFromObject cannot begin with the \"$\" character.');\n                if (semanticId ||\n                    (typeof semanticId === 'number' && semanticId === 0)) {\n                    valueDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(valueDataId, field, context.processedData)) {\n                this.writeSelectionSetToStore({\n                    dataId: valueDataId,\n                    result: value,\n                    selectionSet: field.selectionSet,\n                    context: context,\n                });\n            }\n            var typename = value.__typename;\n            storeValue = toIdValue({ id: valueDataId, typename: typename }, generated);\n            storeObject = store.get(dataId);\n            var escapedId = storeObject && storeObject[storeFieldName];\n            if (escapedId !== storeValue && isIdValue(escapedId)) {\n                var hadTypename = escapedId.typename !== undefined;\n                var hasTypename = typename !== undefined;\n                var typenameChanged = hadTypename && hasTypename && escapedId.typename !== typename;\n                process.env.NODE_ENV === \"production\" ? invariant(!generated || escapedId.generated || typenameChanged, 6) : 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, 7) : invariant(!hadTypename || hasTypename, \"Store error: the application attempted to write an object with no provided typename but the store already contains an object with typename of \" + escapedId.typename + \" for the object of id \" + escapedId.id + \". The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                if (escapedId.generated) {\n                    if (typenameChanged) {\n                        if (!generated) {\n                            store.delete(escapedId.id);\n                        }\n                    }\n                    else {\n                        mergeWithGenerated(escapedId.id, storeValue.id, store);\n                    }\n                }\n            }\n        }\n        storeObject = store.get(dataId);\n        if (!storeObject || !isEqual(storeValue, storeObject[storeFieldName])) {\n            store.set(dataId, __assign(__assign({}, storeObject), (_b = {}, _b[storeFieldName] = storeValue, _b)));\n        }\n    };\n    StoreWriter.prototype.processArrayValue = function (value, generatedId, selectionSet, context) {\n        var _this = this;\n        return value.map(function (item, index) {\n            if (item === null) {\n                return null;\n            }\n            var itemDataId = generatedId + \".\" + index;\n            if (Array.isArray(item)) {\n                return _this.processArrayValue(item, itemDataId, selectionSet, context);\n            }\n            var generated = true;\n            if (context.dataIdFromObject) {\n                var semanticId = context.dataIdFromObject(item);\n                if (semanticId) {\n                    itemDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(itemDataId, selectionSet, context.processedData)) {\n                _this.writeSelectionSetToStore({\n                    dataId: itemDataId,\n                    result: item,\n                    selectionSet: selectionSet,\n                    context: context,\n                });\n            }\n            return toIdValue({ id: itemDataId, typename: item.__typename }, generated);\n        });\n    };\n    return StoreWriter;\n}());\nfunction isGeneratedId(id) {\n    return id[0] === '$';\n}\nfunction mergeWithGenerated(generatedKey, realKey, cache) {\n    if (generatedKey === realKey) {\n        return false;\n    }\n    var generated = cache.get(generatedKey);\n    var real = cache.get(realKey);\n    var madeChanges = false;\n    Object.keys(generated).forEach(function (key) {\n        var value = generated[key];\n        var realValue = real[key];\n        if (isIdValue(value) &&\n            isGeneratedId(value.id) &&\n            isIdValue(realValue) &&\n            !isEqual(value, realValue) &&\n            mergeWithGenerated(value.id, realValue.id, cache)) {\n            madeChanges = true;\n        }\n    });\n    cache.delete(generatedKey);\n    var newRealValue = __assign(__assign({}, generated), real);\n    if (isEqual(newRealValue, real)) {\n        return madeChanges;\n    }\n    cache.set(realKey, newRealValue);\n    return true;\n}\nfunction isDataProcessed(dataId, field, processedData) {\n    if (!processedData) {\n        return false;\n    }\n    if (processedData[dataId]) {\n        if (processedData[dataId].indexOf(field) >= 0) {\n            return true;\n        }\n        else {\n            processedData[dataId].push(field);\n        }\n    }\n    else {\n        processedData[dataId] = [field];\n    }\n    return false;\n}\n\nvar defaultConfig = {\n    fragmentMatcher: new HeuristicFragmentMatcher(),\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    freezeResults: false,\n};\nfunction defaultDataIdFromObject(result) {\n    if (result.__typename) {\n        if (result.id !== undefined) {\n            return result.__typename + \":\" + result.id;\n        }\n        if (result._id !== undefined) {\n            return result.__typename + \":\" + result._id;\n        }\n    }\n    return null;\n}\nvar hasOwn$1 = Object.prototype.hasOwnProperty;\nvar OptimisticCacheLayer = (function (_super) {\n    __extends(OptimisticCacheLayer, _super);\n    function OptimisticCacheLayer(optimisticId, parent, transaction) {\n        var _this = _super.call(this, Object.create(null)) || this;\n        _this.optimisticId = optimisticId;\n        _this.parent = parent;\n        _this.transaction = transaction;\n        return _this;\n    }\n    OptimisticCacheLayer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    OptimisticCacheLayer.prototype.get = function (dataId) {\n        return hasOwn$1.call(this.data, dataId)\n            ? this.data[dataId]\n            : this.parent.get(dataId);\n    };\n    return OptimisticCacheLayer;\n}(ObjectCache));\nvar InMemoryCache = (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.typenameDocumentCache = new Map();\n        _this.cacheKeyRoot = new KeyTrie(canUseWeakMap);\n        _this.silenceBroadcast = false;\n        _this.config = __assign(__assign({}, defaultConfig), config);\n        if (_this.config.customResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.customResolvers;\n        }\n        if (_this.config.cacheResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.cacheResolvers;\n        }\n        _this.addTypename = !!_this.config.addTypename;\n        _this.data = _this.config.resultCaching\n            ? new DepTrackingCache()\n            : new ObjectCache();\n        _this.optimisticData = _this.data;\n        _this.storeWriter = new StoreWriter();\n        _this.storeReader = new StoreReader({\n            cacheKeyRoot: _this.cacheKeyRoot,\n            freezeResults: config.freezeResults,\n        });\n        var cache = _this;\n        var maybeBroadcastWatch = cache.maybeBroadcastWatch;\n        _this.maybeBroadcastWatch = wrap(function (c) {\n            return maybeBroadcastWatch.call(_this, c);\n        }, {\n            makeCacheKey: function (c) {\n                if (c.optimistic) {\n                    return;\n                }\n                if (c.previousResult) {\n                    return;\n                }\n                if (cache.data instanceof DepTrackingCache) {\n                    return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));\n                }\n            }\n        });\n        return _this;\n    }\n    InMemoryCache.prototype.restore = function (data) {\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).toObject();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        if (typeof options.rootId === 'string' &&\n            typeof this.data.get(options.rootId) === 'undefined') {\n            return null;\n        }\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.readQueryFromStore({\n            store: options.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(options.query),\n            variables: options.variables,\n            rootId: options.rootId,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            previousResult: options.previousResult,\n            config: this.config,\n        }) || null;\n    };\n    InMemoryCache.prototype.write = function (write) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        this.storeWriter.writeResultToStore({\n            dataId: write.dataId,\n            result: write.result,\n            variables: write.variables,\n            document: this.transformDocument(write.query),\n            store: this.data,\n            dataIdFromObject: this.config.dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.diff = function (query) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.diffQueryAgainstStore({\n            store: query.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(query.query),\n            variables: query.variables,\n            returnPartialData: query.returnPartialData,\n            previousResult: query.previousResult,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            config: this.config,\n        });\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        this.watches.add(watch);\n        return function () {\n            _this.watches.delete(watch);\n        };\n    };\n    InMemoryCache.prototype.evict = function (query) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError(\"eviction is not implemented on InMemory Cache\");\n    };\n    InMemoryCache.prototype.reset = function () {\n        this.data.clear();\n        this.broadcastWatches();\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var toReapply = [];\n        var removedCount = 0;\n        var layer = this.optimisticData;\n        while (layer instanceof OptimisticCacheLayer) {\n            if (layer.optimisticId === idToRemove) {\n                ++removedCount;\n            }\n            else {\n                toReapply.push(layer);\n            }\n            layer = layer.parent;\n        }\n        if (removedCount > 0) {\n            this.optimisticData = layer;\n            while (toReapply.length > 0) {\n                var layer_1 = toReapply.pop();\n                this.performTransaction(layer_1.transaction, layer_1.optimisticId);\n            }\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n        var _a = this, data = _a.data, silenceBroadcast = _a.silenceBroadcast;\n        this.silenceBroadcast = true;\n        if (typeof optimisticId === 'string') {\n            this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);\n        }\n        try {\n            transaction(this);\n        }\n        finally {\n            this.silenceBroadcast = silenceBroadcast;\n            this.data = data;\n        }\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {\n        return this.performTransaction(transaction, id);\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        if (this.addTypename) {\n            var result = this.typenameDocumentCache.get(document);\n            if (!result) {\n                result = addTypenameToDocument(document);\n                this.typenameDocumentCache.set(document, result);\n                this.typenameDocumentCache.set(result, result);\n            }\n            return result;\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function () {\n        var _this = this;\n        if (!this.silenceBroadcast) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c); });\n        }\n    };\n    InMemoryCache.prototype.maybeBroadcastWatch = function (c) {\n        c.callback(this.diff({\n            query: c.query,\n            variables: c.variables,\n            previousResult: c.previousResult && c.previousResult(),\n            optimistic: c.optimistic,\n        }));\n    };\n    return InMemoryCache;\n}(ApolloCache));\n\nexport { HeuristicFragmentMatcher, InMemoryCache, IntrospectionFragmentMatcher, ObjectCache, StoreReader, StoreWriter, WriteError, assertIdValue, defaultDataIdFromObject, defaultNormalizedCacheFactory$1 as defaultNormalizedCacheFactory, enhanceErrorWithDocument };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __extends } from 'tslib';\nimport ApolloClient__default from 'apollo-client';\nexport * from 'apollo-client';\nimport { ApolloLink, Observable } from 'apollo-link';\nexport * from 'apollo-link';\nimport { InMemoryCache } from 'apollo-cache-inmemory';\nexport * from 'apollo-cache-inmemory';\nimport { HttpLink } from 'apollo-link-http';\nexport { HttpLink } from 'apollo-link-http';\nimport { onError } from 'apollo-link-error';\nexport { default as gql } from 'graphql-tag';\nimport { invariant } from 'ts-invariant';\n\nvar PRESET_CONFIG_KEYS = [\n    'request',\n    'uri',\n    'credentials',\n    'headers',\n    'fetch',\n    'fetchOptions',\n    'clientState',\n    'onError',\n    'cacheRedirects',\n    'cache',\n    'name',\n    'version',\n    'resolvers',\n    'typeDefs',\n    'fragmentMatcher',\n];\nvar DefaultClient = (function (_super) {\n    __extends(DefaultClient, _super);\n    function DefaultClient(config) {\n        if (config === void 0) { config = {}; }\n        var _this = this;\n        if (config) {\n            var diff = Object.keys(config).filter(function (key) { return PRESET_CONFIG_KEYS.indexOf(key) === -1; });\n            if (diff.length > 0) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('ApolloBoost was initialized with unsupported options: ' +\n                    (\"\" + diff.join(' ')));\n            }\n        }\n        var request = config.request, uri = config.uri, credentials = config.credentials, headers = config.headers, fetch = config.fetch, fetchOptions = config.fetchOptions, clientState = config.clientState, cacheRedirects = config.cacheRedirects, errorCallback = config.onError, name = config.name, version = config.version, resolvers = config.resolvers, typeDefs = config.typeDefs, fragmentMatcher = config.fragmentMatcher;\n        var cache = config.cache;\n        process.env.NODE_ENV === \"production\" ? invariant(!cache || !cacheRedirects, 1) : invariant(!cache || !cacheRedirects, 'Incompatible cache configuration. When not providing `cache`, ' +\n            'configure the provided instance with `cacheRedirects` instead.');\n        if (!cache) {\n            cache = cacheRedirects\n                ? new InMemoryCache({ cacheRedirects: cacheRedirects })\n                : new InMemoryCache();\n        }\n        var errorLink = errorCallback\n            ? onError(errorCallback)\n            : onError(function (_a) {\n                var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError;\n                if (graphQLErrors) {\n                    graphQLErrors.forEach(function (_a) {\n                        var message = _a.message, locations = _a.locations, path = _a.path;\n                        return process.env.NODE_ENV === \"production\" || invariant.warn(\"[GraphQL error]: Message: \" + message + \", Location: \" +\n                            (locations + \", Path: \" + path));\n                    });\n                }\n                if (networkError) {\n                    process.env.NODE_ENV === \"production\" || invariant.warn(\"[Network error]: \" + networkError);\n                }\n            });\n        var requestHandler = request\n            ? new ApolloLink(function (operation, forward) {\n                return new Observable(function (observer) {\n                    var handle;\n                    Promise.resolve(operation)\n                        .then(function (oper) { return request(oper); })\n                        .then(function () {\n                        handle = forward(operation).subscribe({\n                            next: observer.next.bind(observer),\n                            error: observer.error.bind(observer),\n                            complete: observer.complete.bind(observer),\n                        });\n                    })\n                        .catch(observer.error.bind(observer));\n                    return function () {\n                        if (handle) {\n                            handle.unsubscribe();\n                        }\n                    };\n                });\n            })\n            : false;\n        var httpLink = new HttpLink({\n            uri: uri || '/graphql',\n            fetch: fetch,\n            fetchOptions: fetchOptions || {},\n            credentials: credentials || 'same-origin',\n            headers: headers || {},\n        });\n        var link = ApolloLink.from([errorLink, requestHandler, httpLink].filter(function (x) { return !!x; }));\n        var activeResolvers = resolvers;\n        var activeTypeDefs = typeDefs;\n        var activeFragmentMatcher = fragmentMatcher;\n        if (clientState) {\n            if (clientState.defaults) {\n                cache.writeData({\n                    data: clientState.defaults,\n                });\n            }\n            activeResolvers = clientState.resolvers;\n            activeTypeDefs = clientState.typeDefs;\n            activeFragmentMatcher = clientState.fragmentMatcher;\n        }\n        _this = _super.call(this, {\n            cache: cache,\n            link: link,\n            name: name,\n            version: version,\n            resolvers: activeResolvers,\n            typeDefs: activeTypeDefs,\n            fragmentMatcher: activeFragmentMatcher,\n        }) || this;\n        return _this;\n    }\n    return DefaultClient;\n}(ApolloClient__default));\n\nexport default DefaultClient;\n//# sourceMappingURL=bundle.esm.js.map\n","import { visit } from 'graphql/language/visitor';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { __assign, __spreadArrays } from 'tslib';\nimport stringify from 'fast-json-stable-stringify';\nexport { equal as isEqual } from '@wry/equality';\n\nfunction isScalarValue(value) {\n    return ['StringValue', 'BooleanValue', 'EnumValue'].indexOf(value.kind) > -1;\n}\nfunction isNumberValue(value) {\n    return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\nfunction isStringValue(value) {\n    return value.kind === 'StringValue';\n}\nfunction isBooleanValue(value) {\n    return value.kind === 'BooleanValue';\n}\nfunction isIntValue(value) {\n    return value.kind === 'IntValue';\n}\nfunction isFloatValue(value) {\n    return value.kind === 'FloatValue';\n}\nfunction isVariable(value) {\n    return value.kind === 'Variable';\n}\nfunction isObjectValue(value) {\n    return value.kind === 'ObjectValue';\n}\nfunction isListValue(value) {\n    return value.kind === 'ListValue';\n}\nfunction isEnumValue(value) {\n    return value.kind === 'EnumValue';\n}\nfunction isNullValue(value) {\n    return value.kind === 'NullValue';\n}\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(17) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.');\n    }\n}\nfunction storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    'connection',\n    'include',\n    'skip',\n    'client',\n    'rest',\n    'export',\n];\nfunction getStoreKeyName(fieldName, args, directives) {\n    if (directives &&\n        directives['connection'] &&\n        directives['connection']['key']) {\n        if (directives['connection']['filter'] &&\n            directives['connection']['filter'].length > 0) {\n            var filterKeys = directives['connection']['filter']\n                ? directives['connection']['filter']\n                : [];\n            filterKeys.sort();\n            var queryArgs_1 = args;\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = queryArgs_1[key];\n            });\n            return directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n        }\n        else {\n            return directives['connection']['key'];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\" + stringifiedArgs + \")\";\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n            }\n            else {\n                completeFieldName += \"@\" + key;\n            }\n        });\n    }\n    return completeFieldName;\n}\nfunction argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nfunction resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nfunction isField(selection) {\n    return selection.kind === 'Field';\n}\nfunction isInlineFragment(selection) {\n    return selection.kind === 'InlineFragment';\n}\nfunction isIdValue(idObject) {\n    return idObject &&\n        idObject.type === 'id' &&\n        typeof idObject.generated === 'boolean';\n}\nfunction toIdValue(idConfig, generated) {\n    if (generated === void 0) { generated = false; }\n    return __assign({ type: 'id', generated: generated }, (typeof idConfig === 'string'\n        ? { id: idConfig, typename: undefined }\n        : idConfig));\n}\nfunction isJsonValue(jsonObject) {\n    return (jsonObject != null &&\n        typeof jsonObject === 'object' &&\n        jsonObject.type === 'json');\n}\nfunction defaultValueFromVariable(node) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(18) : new InvariantError(\"Variable nodes are not supported by valueFromNode\");\n}\nfunction valueFromNode(node, onVariable) {\n    if (onVariable === void 0) { onVariable = defaultValueFromVariable; }\n    switch (node.kind) {\n        case 'Variable':\n            return onVariable(node);\n        case 'NullValue':\n            return null;\n        case 'IntValue':\n            return parseInt(node.value, 10);\n        case 'FloatValue':\n            return parseFloat(node.value);\n        case 'ListValue':\n            return node.values.map(function (v) { return valueFromNode(v, onVariable); });\n        case 'ObjectValue': {\n            var value = {};\n            for (var _i = 0, _a = node.fields; _i < _a.length; _i++) {\n                var field = _a[_i];\n                value[field.name.value] = valueFromNode(field.value, onVariable);\n            }\n            return value;\n        }\n        default:\n            return node.value;\n    }\n}\n\nfunction getDirectiveInfoFromField(field, variables) {\n    if (field.directives && field.directives.length) {\n        var directiveObj_1 = {};\n        field.directives.forEach(function (directive) {\n            directiveObj_1[directive.name.value] = argumentsObjectFromField(directive, variables);\n        });\n        return directiveObj_1;\n    }\n    return null;\n}\nfunction shouldInclude(selection, variables) {\n    if (variables === void 0) { variables = {}; }\n    return getInclusionDirectives(selection.directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === 'Variable') {\n            evaledValue = variables[ifArgument.value.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 1) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\nfunction getDirectiveNames(doc) {\n    var names = [];\n    visit(doc, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nfunction hasDirectives(names, doc) {\n    return getDirectiveNames(doc).some(function (name) { return names.indexOf(name) > -1; });\n}\nfunction hasClientExports(document) {\n    return (document &&\n        hasDirectives(['client'], document) &&\n        hasDirectives(['export'], document));\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\nfunction getInclusionDirectives(directives) {\n    return directives ? directives.filter(isInclusionDirective).map(function (directive) {\n        var directiveArguments = directive.arguments;\n        var directiveName = directive.name.value;\n        process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 2) : 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', 3) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n        var ifValue = ifArgument.value;\n        process.env.NODE_ENV === \"production\" ? invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 4) : invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n        return { directive: directive, ifArgument: ifArgument };\n    }) : [];\n}\n\nfunction getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(5) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 6) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArrays([\n            {\n                kind: 'OperationDefinition',\n                operation: 'query',\n                selectionSet: {\n                    kind: 'SelectionSet',\n                    selections: [\n                        {\n                            kind: 'FragmentSpread',\n                            name: {\n                                kind: 'Name',\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions) });\n    return query;\n}\n\nfunction assign(target) {\n    var sources = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        sources[_i - 1] = arguments[_i];\n    }\n    sources.forEach(function (source) {\n        if (typeof source === 'undefined' || source === null) {\n            return;\n        }\n        Object.keys(source).forEach(function (key) {\n            target[key] = source[key];\n        });\n    });\n    return target;\n}\n\nfunction getMutationDefinition(doc) {\n    checkDocument(doc);\n    var mutationDef = doc.definitions.filter(function (definition) {\n        return definition.kind === 'OperationDefinition' &&\n            definition.operation === 'mutation';\n    })[0];\n    process.env.NODE_ENV === \"production\" ? invariant(mutationDef, 7) : invariant(mutationDef, 'Must contain a mutation definition.');\n    return mutationDef;\n}\nfunction checkDocument(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 8) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n        }\n        return definition;\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 10) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\n    return doc;\n}\nfunction getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];\n}\nfunction getOperationDefinitionOrDie(document) {\n    var def = getOperationDefinition(document);\n    process.env.NODE_ENV === \"production\" ? invariant(def, 11) : invariant(def, \"GraphQL document is missing an operation\");\n    return def;\n}\nfunction getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === 'OperationDefinition' && definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\nfunction getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });\n}\nfunction getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 12) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n    return queryDef;\n}\nfunction getFragmentDefinition(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 13) : 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, 14) : 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', 15) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\n    return fragmentDef;\n}\nfunction getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === 'OperationDefinition') {\n            var operation = definition.operation;\n            if (operation === 'query' ||\n                operation === 'mutation' ||\n                operation === 'subscription') {\n                return definition;\n            }\n        }\n        if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(16) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\n}\nfunction createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nfunction getDefaultValues(definition) {\n    if (definition &&\n        definition.variableDefinitions &&\n        definition.variableDefinitions.length) {\n        var defaultValues = definition.variableDefinitions\n            .filter(function (_a) {\n            var defaultValue = _a.defaultValue;\n            return defaultValue;\n        })\n            .map(function (_a) {\n            var variable = _a.variable, defaultValue = _a.defaultValue;\n            var defaultValueObj = {};\n            valueToObjectRepresentation(defaultValueObj, variable.name, defaultValue);\n            return defaultValueObj;\n        });\n        return assign.apply(void 0, __spreadArrays([{}], defaultValues));\n    }\n    return {};\n}\nfunction variablesInOperation(operation) {\n    var names = new Set();\n    if (operation.variableDefinitions) {\n        for (var _i = 0, _a = operation.variableDefinitions; _i < _a.length; _i++) {\n            var definition = _a[_i];\n            names.add(definition.variable.name.value);\n        }\n    }\n    return names;\n}\n\nfunction filterInPlace(array, test, context) {\n    var target = 0;\n    array.forEach(function (elem, i) {\n        if (test.call(this, elem, i, array)) {\n            array[target++] = elem;\n        }\n    }, context);\n    array.length = target;\n    return array;\n}\n\nvar TYPENAME_FIELD = {\n    kind: 'Field',\n    name: {\n        kind: 'Name',\n        value: '__typename',\n    },\n};\nfunction isEmpty(op, fragments) {\n    return op.selectionSet.selections.every(function (selection) {\n        return selection.kind === 'FragmentSpread' &&\n            isEmpty(fragments[selection.name.value], fragments);\n    });\n}\nfunction nullIfDocIsEmpty(doc) {\n    return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))\n        ? null\n        : doc;\n}\nfunction getDirectiveMatcher(directives) {\n    return function directiveMatcher(directive) {\n        return directives.some(function (dir) {\n            return (dir.name && dir.name === directive.name.value) ||\n                (dir.test && dir.test(directive));\n        });\n    };\n}\nfunction removeDirectivesFromDocument(directives, doc) {\n    var variablesInUse = Object.create(null);\n    var variablesToRemove = [];\n    var fragmentSpreadsInUse = Object.create(null);\n    var fragmentSpreadsToRemove = [];\n    var modifiedDoc = nullIfDocIsEmpty(visit(doc, {\n        Variable: {\n            enter: function (node, _key, parent) {\n                if (parent.kind !== 'VariableDefinition') {\n                    variablesInUse[node.name.value] = true;\n                }\n            },\n        },\n        Field: {\n            enter: function (node) {\n                if (directives && node.directives) {\n                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });\n                    if (shouldRemoveField &&\n                        node.directives &&\n                        node.directives.some(getDirectiveMatcher(directives))) {\n                        if (node.arguments) {\n                            node.arguments.forEach(function (arg) {\n                                if (arg.value.kind === 'Variable') {\n                                    variablesToRemove.push({\n                                        name: arg.value.name.value,\n                                    });\n                                }\n                            });\n                        }\n                        if (node.selectionSet) {\n                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                                fragmentSpreadsToRemove.push({\n                                    name: frag.name.value,\n                                });\n                            });\n                        }\n                        return null;\n                    }\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node) {\n                fragmentSpreadsInUse[node.name.value] = true;\n            },\n        },\n        Directive: {\n            enter: function (node) {\n                if (getDirectiveMatcher(directives)(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n    if (modifiedDoc &&\n        filterInPlace(variablesToRemove, function (v) { return !variablesInUse[v.name]; }).length) {\n        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n    }\n    if (modifiedDoc &&\n        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !fragmentSpreadsInUse[fs.name]; })\n            .length) {\n        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n    }\n    return modifiedDoc;\n}\nfunction addTypenameToDocument(doc) {\n    return visit(checkDocument(doc), {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind === 'OperationDefinition') {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === '__typename' ||\n                            selection.name.value.lastIndexOf('__', 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === 'export'; })) {\n                    return;\n                }\n                return __assign(__assign({}, node), { selections: __spreadArrays(selections, [TYPENAME_FIELD]) });\n            },\n        },\n    });\n}\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === 'connection';\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' +\n                    'You may want to use the key parameter to specify a store key.');\n            }\n        }\n        return willRemove;\n    },\n};\nfunction removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    var parentPath;\n    return nullIfDocIsEmpty(visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, _parent, path) {\n                var currentPath = path.join('-');\n                if (!parentPath ||\n                    currentPath === parentPath ||\n                    !currentPath.startsWith(parentPath)) {\n                    if (node.selections) {\n                        var selectionsWithDirectives = node.selections.filter(function (selection) { return hasDirectivesInSelection(directives, selection); });\n                        if (hasDirectivesInSelectionSet(directives, node, false)) {\n                            parentPath = currentPath;\n                        }\n                        return __assign(__assign({}, node), { selections: selectionsWithDirectives });\n                    }\n                    else {\n                        return null;\n                    }\n                }\n            },\n        },\n    }));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === 'Variable' &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nfunction removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                    }) });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    node.arguments.forEach(function (arg) {\n                        if (argMatcher(arg)) {\n                            argMatchCount_1 += 1;\n                        }\n                    });\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nfunction removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n    var allFragments = [];\n    selectionSet.selections.forEach(function (selection) {\n        if ((isField(selection) || isInlineFragment(selection)) &&\n            selection.selectionSet) {\n            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });\n        }\n        else if (selection.kind === 'FragmentSpread') {\n            allFragments.push(selection);\n        }\n    });\n    return allFragments;\n}\nfunction buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === 'query') {\n        return document;\n    }\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: 'query' });\n            },\n        },\n    });\n    return modifiedDoc;\n}\nfunction removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === 'client'; },\n            remove: true,\n        },\n    ], document);\n    if (modifiedDoc) {\n        modifiedDoc = visit(modifiedDoc, {\n            FragmentDefinition: {\n                enter: function (node) {\n                    if (node.selectionSet) {\n                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n                            return isField(selection) && selection.name.value === '__typename';\n                        });\n                        if (isTypenameOnly) {\n                            return null;\n                        }\n                    }\n                },\n            },\n        });\n    }\n    return modifiedDoc;\n}\n\nvar canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&\n    navigator.product === 'ReactNative');\n\nvar toString = Object.prototype.toString;\nfunction cloneDeep(value) {\n    return cloneDeepHelper(value, new Map());\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n\nfunction getEnv() {\n    if (typeof process !== 'undefined' && process.env.NODE_ENV) {\n        return process.env.NODE_ENV;\n    }\n    return 'development';\n}\nfunction isEnv(env) {\n    return getEnv() === env;\n}\nfunction isProduction() {\n    return isEnv('production') === true;\n}\nfunction isDevelopment() {\n    return isEnv('development') === true;\n}\nfunction isTest() {\n    return isEnv('test') === true;\n}\n\nfunction tryFunctionOrLogError(f) {\n    try {\n        return f();\n    }\n    catch (e) {\n        if (console.error) {\n            console.error(e);\n        }\n    }\n}\nfunction graphQLResultHasError(result) {\n    return result.errors && result.errors.length;\n}\n\nfunction deepFreeze(o) {\n    Object.freeze(o);\n    Object.getOwnPropertyNames(o).forEach(function (prop) {\n        if (o[prop] !== null &&\n            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n            !Object.isFrozen(o[prop])) {\n            deepFreeze(o[prop]);\n        }\n    });\n    return o;\n}\nfunction maybeDeepFreeze(obj) {\n    if (isDevelopment() || isTest()) {\n        var symbolIsPolyfilled = typeof Symbol === 'function' && typeof Symbol('') === 'string';\n        if (!symbolIsPolyfilled) {\n            return deepFreeze(obj);\n        }\n    }\n    return obj;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nfunction mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var pastCopies = [];\n        target = shallowCopyForMerge(target, pastCopies);\n        for (var i = 1; i < count; ++i) {\n            target = mergeHelper(target, sources[i], pastCopies);\n        }\n    }\n    return target;\n}\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\nfunction mergeHelper(target, source, pastCopies) {\n    if (isObject(source) && isObject(target)) {\n        if (Object.isExtensible && !Object.isExtensible(target)) {\n            target = shallowCopyForMerge(target, pastCopies);\n        }\n        Object.keys(source).forEach(function (sourceKey) {\n            var sourceValue = source[sourceKey];\n            if (hasOwnProperty.call(target, sourceKey)) {\n                var targetValue = target[sourceKey];\n                if (sourceValue !== targetValue) {\n                    target[sourceKey] = mergeHelper(shallowCopyForMerge(targetValue, pastCopies), sourceValue, pastCopies);\n                }\n            }\n            else {\n                target[sourceKey] = sourceValue;\n            }\n        });\n        return target;\n    }\n    return source;\n}\nfunction shallowCopyForMerge(value, pastCopies) {\n    if (value !== null &&\n        typeof value === 'object' &&\n        pastCopies.indexOf(value) < 0) {\n        if (Array.isArray(value)) {\n            value = value.slice(0);\n        }\n        else {\n            value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n        }\n        pastCopies.push(value);\n    }\n    return value;\n}\n\nvar haveWarned = Object.create({});\nfunction warnOnceInDevelopment(msg, type) {\n    if (type === void 0) { type = 'warn'; }\n    if (!isProduction() && !haveWarned[msg]) {\n        if (!isTest()) {\n            haveWarned[msg] = true;\n        }\n        if (type === 'error') {\n            console.error(msg);\n        }\n        else {\n            console.warn(msg);\n        }\n    }\n}\n\nfunction stripSymbols(data) {\n    return JSON.parse(JSON.stringify(data));\n}\n\nexport { addTypenameToDocument, argumentsObjectFromField, assign, buildQueryFromSelectionSet, canUseWeakMap, checkDocument, cloneDeep, createFragmentMap, getDefaultValues, getDirectiveInfoFromField, getDirectiveNames, getDirectivesFromDocument, getEnv, getFragmentDefinition, getFragmentDefinitions, getFragmentQueryDocument, getInclusionDirectives, getMainDefinition, getMutationDefinition, getOperationDefinition, getOperationDefinitionOrDie, getOperationName, getQueryDefinition, getStoreKeyName, graphQLResultHasError, hasClientExports, hasDirectives, isDevelopment, isEnv, isField, isIdValue, isInlineFragment, isJsonValue, isNumberValue, isProduction, isScalarValue, isTest, maybeDeepFreeze, mergeDeep, mergeDeepArray, removeArgumentsFromDocument, removeClientSetsFromDocument, removeConnectionDirectiveFromDocument, removeDirectivesFromDocument, removeFragmentSpreadFromDocument, resultKeyNameFromField, shouldInclude, storeKeyNameFromField, stripSymbols, toIdValue, tryFunctionOrLogError, valueFromNode, valueToObjectRepresentation, variablesInOperation, warnOnceInDevelopment };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __assign } from 'tslib';\nimport { print } from 'graphql/language/printer';\nimport { InvariantError } from 'ts-invariant';\n\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n};\nvar defaultHeaders = {\n    accept: '*/*',\n    'content-type': 'application/json',\n};\nvar defaultOptions = {\n    method: 'POST',\n};\nvar fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nvar throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = 'ServerError';\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\nvar parseAndCheckHttpResponse = function (operations) { return function (response) {\n    return (response\n        .text()\n        .then(function (bodyText) {\n        try {\n            return JSON.parse(bodyText);\n        }\n        catch (err) {\n            var parseError = err;\n            parseError.name = 'ServerParseError';\n            parseError.response = response;\n            parseError.statusCode = response.status;\n            parseError.bodyText = bodyText;\n            return Promise.reject(parseError);\n        }\n    })\n        .then(function (result) {\n        if (response.status >= 300) {\n            throwServerError(response, result, \"Response not successful: Received status code \" + response.status);\n        }\n        if (!Array.isArray(result) &&\n            !result.hasOwnProperty('data') &&\n            !result.hasOwnProperty('errors')) {\n            throwServerError(response, result, \"Server response was missing for query '\" + (Array.isArray(operations)\n                ? operations.map(function (op) { return op.operationName; })\n                : operations.operationName) + \"'.\");\n        }\n        return result;\n    }));\n}; };\nvar checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === 'undefined') {\n        var library = 'unfetch';\n        if (typeof window === 'undefined')\n            library = 'node-fetch';\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError(\"\\nfetch is not found globally and no fetcher passed, to fix pass a fetch for\\nyour environment like https://www.npmjs.com/package/\" + library + \".\\n\\nFor example:\\nimport fetch from '\" + library + \"';\\nimport { createHttpLink } from 'apollo-link-http';\\n\\nconst link = createHttpLink({ uri: '/graphql', fetch: fetch });\");\n    }\n};\nvar createSignalIfSupported = function () {\n    if (typeof AbortController === 'undefined')\n        return { controller: false, signal: false };\n    var controller = new AbortController();\n    var signal = controller.signal;\n    return { controller: controller, signal: signal };\n};\nvar selectHttpOptionsAndBody = function (operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = __assign({}, fallbackConfig.options, { headers: fallbackConfig.headers, credentials: fallbackConfig.credentials });\n    var http = fallbackConfig.http;\n    configs.forEach(function (config) {\n        options = __assign({}, options, config.options, { headers: __assign({}, options.headers, config.headers) });\n        if (config.credentials)\n            options.credentials = config.credentials;\n        http = __assign({}, http, config.http);\n    });\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    if (http.includeQuery)\n        body.query = print(query);\n    return {\n        options: options,\n        body: body,\n    };\n};\nvar serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"Network request failed. \" + label + \" is not serializable: \" + e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\nvar selectURI = function (operation, fallbackURI) {\n    var context = operation.getContext();\n    var contextURI = context.uri;\n    if (contextURI) {\n        return contextURI;\n    }\n    else if (typeof fallbackURI === 'function') {\n        return fallbackURI(operation);\n    }\n    else {\n        return fallbackURI || '/graphql';\n    }\n};\n\nexport { checkFetcher, createSignalIfSupported, fallbackHttpConfig, parseAndCheckHttpResponse, selectHttpOptionsAndBody, selectURI, serializeFetchParameter, throwServerError };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __rest, __assign, __extends } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, createSignalIfSupported, serializeFetchParameter, parseAndCheckHttpResponse } from 'apollo-link-http-common';\n\nvar createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, fetcher = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"includeExtensions\", \"useGETForQueries\"]);\n    checkFetcher(fetcher);\n    if (!fetcher) {\n        fetcher = fetch;\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders['apollographql-client-name'] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders['apollographql-client-version'] = version;\n            }\n        }\n        var contextHeaders = __assign({}, clientAwarenessHeaders, context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        var controller;\n        if (!options.signal) {\n            var _c = createSignalIfSupported(), _controller = _c.controller, signal = _c.signal;\n            controller = _controller;\n            if (controller)\n                options.signal = signal;\n        }\n        var definitionIsMutation = function (d) {\n            return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n        };\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = 'GET';\n        }\n        if (options.method === 'GET') {\n            var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, 'Payload');\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            fetcher(chosenURI, options)\n                .then(function (response) {\n                operation.setContext({ response: response });\n                return response;\n            })\n                .then(parseAndCheckHttpResponse(operation))\n                .then(function (result) {\n                observer.next(result);\n                observer.complete();\n                return result;\n            })\n                .catch(function (err) {\n                if (err.name === 'AbortError')\n                    return;\n                if (err.result && err.result.errors && err.result.data) {\n                    observer.next(err.result);\n                }\n                observer.error(err);\n            });\n            return function () {\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\nfunction rewriteURIForGET(chosenURI, body) {\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(key + \"=\" + encodeURIComponent(value));\n    };\n    if ('query' in body) {\n        addQueryParam('query', body.query);\n    }\n    if (body.operationName) {\n        addQueryParam('operationName', body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('variables', serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('extensions', serializedExtensions);\n    }\n    var fragment = '', preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf('#');\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n    var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n    return { newURI: newURI };\n}\nvar HttpLink = (function (_super) {\n    __extends(HttpLink, _super);\n    function HttpLink(opts) {\n        return _super.call(this, createHttpLink(opts).request) || this;\n    }\n    return HttpLink;\n}(ApolloLink));\n\nexport { HttpLink, createHttpLink };\n//# sourceMappingURL=bundle.esm.js.map\n","function _arrayLikeToArray(r, a) {\n  (null == a || a > r.length) && (a = r.length);\n  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n  return n;\n}\nexport { _arrayLikeToArray as default };","import { __extends, __assign, __awaiter, __generator } from 'tslib';\nimport { getOperationDefinition, isEqual, tryFunctionOrLogError, cloneDeep, mergeDeep, hasDirectives, removeClientSetsFromDocument, buildQueryFromSelectionSet, getMainDefinition, getFragmentDefinitions, createFragmentMap, mergeDeepArray, resultKeyNameFromField, argumentsObjectFromField, shouldInclude, isField, isInlineFragment, canUseWeakMap, graphQLResultHasError, removeConnectionDirectiveFromDocument, hasClientExports, getDefaultValues, getOperationName } from 'apollo-utilities';\nimport { Observable as Observable$1, execute, ApolloLink } from 'apollo-link';\nimport $$observable from 'symbol-observable';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { visit, BREAK } from 'graphql/language/visitor';\n\nvar NetworkStatus;\n(function (NetworkStatus) {\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\nfunction isNetworkRequestInFlight(networkStatus) {\n    return networkStatus < 7;\n}\n\nvar Observable = (function (_super) {\n    __extends(Observable, _super);\n    function Observable() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Observable.prototype[$$observable] = function () {\n        return this;\n    };\n    Observable.prototype['@@observable'] = function () {\n        return this;\n    };\n    return Observable;\n}(Observable$1));\n\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n\nfunction isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (isNonEmptyArray(err.graphQLErrors)) {\n        err.graphQLErrors.forEach(function (graphQLError) {\n            var errorMessage = graphQLError\n                ? graphQLError.message\n                : 'Error message not found.';\n            message += \"GraphQL error: \" + errorMessage + \"\\n\";\n        });\n    }\n    if (err.networkError) {\n        message += 'Network error: ' + err.networkError.message + '\\n';\n    }\n    message = message.replace(/\\n$/, '');\n    return message;\n};\nvar ApolloError = (function (_super) {\n    __extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.networkError = networkError || null;\n        if (!errorMessage) {\n            _this.message = generateErrorMessage(_this);\n        }\n        else {\n            _this.message = errorMessage;\n        }\n        _this.extraInfo = extraInfo;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\n\nvar FetchType;\n(function (FetchType) {\n    FetchType[FetchType[\"normal\"] = 1] = \"normal\";\n    FetchType[FetchType[\"refetch\"] = 2] = \"refetch\";\n    FetchType[FetchType[\"poll\"] = 3] = \"poll\";\n})(FetchType || (FetchType = {}));\n\nvar hasError = function (storeValue, policy) {\n    if (policy === void 0) { policy = 'none'; }\n    return storeValue && (storeValue.networkError ||\n        (policy === 'none' && isNonEmptyArray(storeValue.graphQLErrors)));\n};\nvar ObservableQuery = (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, options = _a.options, _b = _a.shouldSubscribe, shouldSubscribe = _b === void 0 ? true : _b;\n        var _this = _super.call(this, function (observer) {\n            return _this.onSubscribe(observer);\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.isTornDown = false;\n        _this.options = options;\n        _this.variables = options.variables || {};\n        _this.queryId = queryManager.generateQueryId();\n        _this.shouldSubscribe = shouldSubscribe;\n        var opDef = getOperationDefinition(options.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        _this.queryManager = queryManager;\n        return _this;\n    }\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    ObservableQuery.prototype.currentResult = function () {\n        var result = this.getCurrentResult();\n        if (result.data === undefined) {\n            result.data = {};\n        }\n        return result;\n    };\n    ObservableQuery.prototype.getCurrentResult = function () {\n        if (this.isTornDown) {\n            var lastResult = this.lastResult;\n            return {\n                data: !this.lastError && lastResult && lastResult.data || void 0,\n                error: this.lastError,\n                loading: false,\n                networkStatus: NetworkStatus.error,\n            };\n        }\n        var _a = this.queryManager.getCurrentQueryResult(this), data = _a.data, partial = _a.partial;\n        var queryStoreValue = this.queryManager.queryStore.get(this.queryId);\n        var result;\n        var fetchPolicy = this.options.fetchPolicy;\n        var isNetworkFetchPolicy = fetchPolicy === 'network-only' ||\n            fetchPolicy === 'no-cache';\n        if (queryStoreValue) {\n            var networkStatus = queryStoreValue.networkStatus;\n            if (hasError(queryStoreValue, this.options.errorPolicy)) {\n                return {\n                    data: void 0,\n                    loading: false,\n                    networkStatus: networkStatus,\n                    error: new ApolloError({\n                        graphQLErrors: queryStoreValue.graphQLErrors,\n                        networkError: queryStoreValue.networkError,\n                    }),\n                };\n            }\n            if (queryStoreValue.variables) {\n                this.options.variables = __assign(__assign({}, this.options.variables), queryStoreValue.variables);\n                this.variables = this.options.variables;\n            }\n            result = {\n                data: data,\n                loading: isNetworkRequestInFlight(networkStatus),\n                networkStatus: networkStatus,\n            };\n            if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {\n                result.errors = queryStoreValue.graphQLErrors;\n            }\n        }\n        else {\n            var loading = isNetworkFetchPolicy ||\n                (partial && fetchPolicy !== 'cache-only');\n            result = {\n                data: data,\n                loading: loading,\n                networkStatus: loading ? NetworkStatus.loading : NetworkStatus.ready,\n            };\n        }\n        if (!partial) {\n            this.updateLastResult(__assign(__assign({}, result), { stale: false }));\n        }\n        return __assign(__assign({}, result), { partial: partial });\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        var snapshot = this.lastResultSnapshot;\n        return !(snapshot &&\n            newResult &&\n            snapshot.networkStatus === newResult.networkStatus &&\n            snapshot.stale === newResult.stale &&\n            isEqual(snapshot.data, newResult.data));\n    };\n    ObservableQuery.prototype.getLastResult = function () {\n        return this.lastResult;\n    };\n    ObservableQuery.prototype.getLastError = function () {\n        return this.lastError;\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.lastResult;\n        delete this.lastResultSnapshot;\n        delete this.lastError;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        var queryStore = this.queryManager.queryStore.get(this.queryId);\n        if (queryStore) {\n            queryStore.networkError = null;\n            queryStore.graphQLErrors = [];\n        }\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === 'cache-only') {\n            return Promise.reject(process.env.NODE_ENV === \"production\" ? new InvariantError(3) : new InvariantError('cache-only fetchPolicy option should not be used together with query refetch.'));\n        }\n        if (fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'cache-and-network') {\n            fetchPolicy = 'network-only';\n        }\n        if (!isEqual(this.variables, variables)) {\n            this.variables = __assign(__assign({}, this.variables), variables);\n        }\n        if (!isEqual(this.options.variables, this.variables)) {\n            this.options.variables = __assign(__assign({}, this.options.variables), this.variables);\n        }\n        return this.queryManager.fetchQuery(this.queryId, __assign(__assign({}, this.options), { fetchPolicy: fetchPolicy }), FetchType.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(fetchMoreOptions.updateQuery, 4) : invariant(fetchMoreOptions.updateQuery, 'updateQuery option is required. This function defines how to update the query data with the new results.');\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), { variables: __assign(__assign({}, this.variables), fetchMoreOptions.variables) }))), { fetchPolicy: 'network-only' });\n        var qid = this.queryManager.generateQueryId();\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, FetchType.normal, this.queryId)\n            .then(function (fetchMoreResult) {\n            _this.updateQuery(function (previousResult) {\n                return fetchMoreOptions.updateQuery(previousResult, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n            });\n            _this.queryManager.stopQuery(qid);\n            return fetchMoreResult;\n        }, function (error) {\n            _this.queryManager.stopQuery(qid);\n            throw error;\n        });\n    };\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                process.env.NODE_ENV === \"production\" || invariant.error('Unhandled GraphQL subscription error', err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (opts) {\n        var oldFetchPolicy = this.options.fetchPolicy;\n        this.options = __assign(__assign({}, this.options), opts);\n        if (opts.pollInterval) {\n            this.startPolling(opts.pollInterval);\n        }\n        else if (opts.pollInterval === 0) {\n            this.stopPolling();\n        }\n        var fetchPolicy = opts.fetchPolicy;\n        return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' ||\n            oldFetchPolicy === 'standby' ||\n            fetchPolicy === 'network-only'), opts.fetchResults);\n    };\n    ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {\n        if (tryFetch === void 0) { tryFetch = false; }\n        if (fetchResults === void 0) { fetchResults = true; }\n        this.isTornDown = false;\n        variables = variables || this.variables;\n        if (!tryFetch && isEqual(variables, this.variables)) {\n            return this.observers.size && fetchResults\n                ? this.result()\n                : Promise.resolve();\n        }\n        this.variables = this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.queryManager.fetchQuery(this.queryId, this.options);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var _a = queryManager.getQueryWithPreviousResult(this.queryId), previousResult = _a.previousResult, variables = _a.variables, document = _a.document;\n        var newResult = tryFunctionOrLogError(function () {\n            return mapFn(previousResult, { variables: variables });\n        });\n        if (newResult) {\n            queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.queryManager.stopPollingQuery(this.queryId);\n        this.options.pollInterval = undefined;\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        assertNotCacheFirstOrOnly(this);\n        this.options.pollInterval = pollInterval;\n        this.queryManager.startPollingQuery(this.options, this.queryId);\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult) {\n        var previousResult = this.lastResult;\n        this.lastResult = newResult;\n        this.lastResultSnapshot = this.queryManager.assumeImmutableResults\n            ? newResult\n            : cloneDeep(newResult);\n        return previousResult;\n    };\n    ObservableQuery.prototype.onSubscribe = function (observer) {\n        var _this = this;\n        try {\n            var subObserver = observer._subscription._observer;\n            if (subObserver && !subObserver.error) {\n                subObserver.error = defaultSubscriptionObserverErrorCallback;\n            }\n        }\n        catch (_a) { }\n        var first = !this.observers.size;\n        this.observers.add(observer);\n        if (observer.next && this.lastResult)\n            observer.next(this.lastResult);\n        if (observer.error && this.lastError)\n            observer.error(this.lastError);\n        if (first) {\n            this.setUpQuery();\n        }\n        return function () {\n            if (_this.observers.delete(observer) && !_this.observers.size) {\n                _this.tearDownQuery();\n            }\n        };\n    };\n    ObservableQuery.prototype.setUpQuery = function () {\n        var _this = this;\n        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;\n        if (this.shouldSubscribe) {\n            queryManager.addObservableQuery(queryId, this);\n        }\n        if (this.options.pollInterval) {\n            assertNotCacheFirstOrOnly(this);\n            queryManager.startPollingQuery(this.options, queryId);\n        }\n        var onError = function (error) {\n            _this.updateLastResult(__assign(__assign({}, _this.lastResult), { errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false }));\n            iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n        };\n        queryManager.observeQuery(queryId, this.options, {\n            next: function (result) {\n                if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n                    var previousResult_1 = _this.updateLastResult(result);\n                    var _a = _this.options, query_1 = _a.query, variables = _a.variables, fetchPolicy_1 = _a.fetchPolicy;\n                    if (queryManager.transform(query_1).hasClientExports) {\n                        queryManager.getLocalState().addExportedVariables(query_1, variables).then(function (variables) {\n                            var previousVariables = _this.variables;\n                            _this.variables = _this.options.variables = variables;\n                            if (!result.loading &&\n                                previousResult_1 &&\n                                fetchPolicy_1 !== 'cache-only' &&\n                                queryManager.transform(query_1).serverQuery &&\n                                !isEqual(previousVariables, variables)) {\n                                _this.refetch();\n                            }\n                            else {\n                                iterateObserversSafely(_this.observers, 'next', result);\n                            }\n                        });\n                    }\n                    else {\n                        iterateObserversSafely(_this.observers, 'next', result);\n                    }\n                }\n            },\n            error: onError,\n        }).catch(onError);\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        var queryManager = this.queryManager;\n        this.isTornDown = true;\n        queryManager.stopPollingQuery(this.queryId);\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        queryManager.removeObservableQuery(this.queryId);\n        queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n    };\n    return ObservableQuery;\n}(Observable));\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\nfunction iterateObserversSafely(observers, method, argument) {\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\nfunction assertNotCacheFirstOrOnly(obsQuery) {\n    var fetchPolicy = obsQuery.options.fetchPolicy;\n    process.env.NODE_ENV === \"production\" ? invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 5) : invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 'Queries that specify the cache-first and cache-only fetchPolicies cannot also be polling queries.');\n}\n\nvar MutationStore = (function () {\n    function MutationStore() {\n        this.store = {};\n    }\n    MutationStore.prototype.getStore = function () {\n        return this.store;\n    };\n    MutationStore.prototype.get = function (mutationId) {\n        return this.store[mutationId];\n    };\n    MutationStore.prototype.initMutation = function (mutationId, mutation, variables) {\n        this.store[mutationId] = {\n            mutation: mutation,\n            variables: variables || {},\n            loading: true,\n            error: null,\n        };\n    };\n    MutationStore.prototype.markMutationError = function (mutationId, error) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = error;\n        }\n    };\n    MutationStore.prototype.markMutationResult = function (mutationId) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = null;\n        }\n    };\n    MutationStore.prototype.reset = function () {\n        this.store = {};\n    };\n    return MutationStore;\n}());\n\nvar QueryStore = (function () {\n    function QueryStore() {\n        this.store = {};\n    }\n    QueryStore.prototype.getStore = function () {\n        return this.store;\n    };\n    QueryStore.prototype.get = function (queryId) {\n        return this.store[queryId];\n    };\n    QueryStore.prototype.initQuery = function (query) {\n        var previousQuery = this.store[query.queryId];\n        process.env.NODE_ENV === \"production\" ? invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 19) : invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 'Internal Error: may not update existing query string in store');\n        var isSetVariables = false;\n        var previousVariables = null;\n        if (query.storePreviousVariables &&\n            previousQuery &&\n            previousQuery.networkStatus !== NetworkStatus.loading) {\n            if (!isEqual(previousQuery.variables, query.variables)) {\n                isSetVariables = true;\n                previousVariables = previousQuery.variables;\n            }\n        }\n        var networkStatus;\n        if (isSetVariables) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        else if (query.isPoll) {\n            networkStatus = NetworkStatus.poll;\n        }\n        else if (query.isRefetch) {\n            networkStatus = NetworkStatus.refetch;\n        }\n        else {\n            networkStatus = NetworkStatus.loading;\n        }\n        var graphQLErrors = [];\n        if (previousQuery && previousQuery.graphQLErrors) {\n            graphQLErrors = previousQuery.graphQLErrors;\n        }\n        this.store[query.queryId] = {\n            document: query.document,\n            variables: query.variables,\n            previousVariables: previousVariables,\n            networkError: null,\n            graphQLErrors: graphQLErrors,\n            networkStatus: networkStatus,\n            metadata: query.metadata,\n        };\n        if (typeof query.fetchMoreForQueryId === 'string' &&\n            this.store[query.fetchMoreForQueryId]) {\n            this.store[query.fetchMoreForQueryId].networkStatus =\n                NetworkStatus.fetchMore;\n        }\n    };\n    QueryStore.prototype.markQueryResult = function (queryId, result, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = null;\n        this.store[queryId].graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];\n        this.store[queryId].previousVariables = null;\n        this.store[queryId].networkStatus = NetworkStatus.ready;\n        if (typeof fetchMoreForQueryId === 'string' &&\n            this.store[fetchMoreForQueryId]) {\n            this.store[fetchMoreForQueryId].networkStatus = NetworkStatus.ready;\n        }\n    };\n    QueryStore.prototype.markQueryError = function (queryId, error, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = error;\n        this.store[queryId].networkStatus = NetworkStatus.error;\n        if (typeof fetchMoreForQueryId === 'string') {\n            this.markQueryResultClient(fetchMoreForQueryId, true);\n        }\n    };\n    QueryStore.prototype.markQueryResultClient = function (queryId, complete) {\n        var storeValue = this.store && this.store[queryId];\n        if (storeValue) {\n            storeValue.networkError = null;\n            storeValue.previousVariables = null;\n            if (complete) {\n                storeValue.networkStatus = NetworkStatus.ready;\n            }\n        }\n    };\n    QueryStore.prototype.stopQuery = function (queryId) {\n        delete this.store[queryId];\n    };\n    QueryStore.prototype.reset = function (observableQueryIds) {\n        var _this = this;\n        Object.keys(this.store).forEach(function (queryId) {\n            if (observableQueryIds.indexOf(queryId) < 0) {\n                _this.stopQuery(queryId);\n            }\n            else {\n                _this.store[queryId].networkStatus = NetworkStatus.loading;\n            }\n        });\n    };\n    return QueryStore;\n}());\n\nfunction capitalizeFirstLetter(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nvar LocalState = (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    LocalState.prototype.runResolvers = function (_a) {\n        var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_c) {\n                if (document) {\n                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives(['client'], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n            process.env.NODE_ENV === \"production\" || invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' +\n                'were specified. This means ApolloClient local resolver handling ' +\n                'has been disabled, and @client directives will be passed through ' +\n                'to your link chain.');\n        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return this.resolvers ? removeClientSetsFromDocument(document) : document;\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var cache = this.cache;\n        var newContext = __assign(__assign({}, context), { cache: cache, getCacheKey: function (obj) {\n                if (cache.config) {\n                    return cache.config.dataIdFromObject(obj);\n                }\n                else {\n                    process.env.NODE_ENV === \"production\" ? invariant(false, 6) : invariant(false, 'To use context.getCacheKey, you need to use a cache that has ' +\n                        'a configurable dataIdFromObject, like apollo-cache-inmemory.');\n                }\n            } });\n        return newContext;\n    };\n    LocalState.prototype.addExportedVariables = function (document, variables, context) {\n        if (variables === void 0) { variables = {}; }\n        if (context === void 0) { context = {}; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === 'client' && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === 'always' &&\n                                arg.value.kind === 'BooleanValue' &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n        if (context === void 0) { context = {}; }\n        if (variables === void 0) { variables = {}; }\n        if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n        if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n        return __awaiter(this, void 0, void 0, function () {\n            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                definitionOperation = mainDefinition\n                    .operation;\n                defaultOperationType = definitionOperation\n                    ? capitalizeFirstLetter(definitionOperation)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache,\n                        client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (isField(selection)) {\n                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== 'undefined') {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            process.env.NODE_ENV === \"production\" ? invariant(fragment, 7) : invariant(fragment, \"No fragment named \" + selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2];\n                    });\n                }); };\n                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(resolve(rootValue, argumentsObjectFromField(field, variables), execContext.context, { field: field, fragmentMap: execContext.fragmentMap }));\n                        }\n                    }\n                }\n                return [2, resultPromise.then(function (result) {\n                        if (result === void 0) { result = defaultResult; }\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === 'export' && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        if (result == null) {\n                            return result;\n                        }\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, result, execContext);\n                        }\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, item, execContext);\n            }\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n            }\n        }));\n    };\n    return LocalState;\n}());\n\nfunction multiplex(inner) {\n    var observers = new Set();\n    var sub = null;\n    return new Observable(function (observer) {\n        observers.add(observer);\n        sub = sub || inner.subscribe({\n            next: function (value) {\n                observers.forEach(function (obs) { return obs.next && obs.next(value); });\n            },\n            error: function (error) {\n                observers.forEach(function (obs) { return obs.error && obs.error(error); });\n            },\n            complete: function () {\n                observers.forEach(function (obs) { return obs.complete && obs.complete(); });\n            },\n        });\n        return function () {\n            if (observers.delete(observer) && !observers.size && sub) {\n                sub.unsubscribe();\n                sub = null;\n            }\n        };\n    });\n}\nfunction asyncMap(observable, mapFn) {\n    return new Observable(function (observer) {\n        var next = observer.next, error = observer.error, complete = observer.complete;\n        var activeNextCount = 0;\n        var completed = false;\n        var handler = {\n            next: function (value) {\n                ++activeNextCount;\n                new Promise(function (resolve) {\n                    resolve(mapFn(value));\n                }).then(function (result) {\n                    --activeNextCount;\n                    next && next.call(observer, result);\n                    completed && handler.complete();\n                }, function (e) {\n                    --activeNextCount;\n                    error && error.call(observer, e);\n                });\n            },\n            error: function (e) {\n                error && error.call(observer, e);\n            },\n            complete: function () {\n                completed = true;\n                if (!activeNextCount) {\n                    complete && complete.call(observer);\n                }\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = (function () {\n    function QueryManager(_a) {\n        var link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, store = _a.store, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;\n        this.mutationStore = new MutationStore();\n        this.queryStore = new QueryStore();\n        this.clientAwareness = {};\n        this.idCounter = 1;\n        this.queries = new Map();\n        this.fetchQueryRejectFns = new Map();\n        this.transformCache = new (canUseWeakMap ? WeakMap : Map)();\n        this.inFlightLinkObservables = new Map();\n        this.pollingInfoByQueryId = new Map();\n        this.link = link;\n        this.queryDeduplication = queryDeduplication;\n        this.dataStore = store;\n        this.onBroadcast = onBroadcast;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: store.getCache() });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = !!assumeImmutableResults;\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError('QueryManager stopped while query was in flight'));\n        });\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, generateUpdateQueriesInfo, self;\n            var _this = this;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        process.env.NODE_ENV === \"production\" ? invariant(mutation, 9) : invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        process.env.NODE_ENV === \"production\" ? invariant(!fetchPolicy || fetchPolicy === 'no-cache', 10) : invariant(!fetchPolicy || fetchPolicy === 'no-cache', \"Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.\");\n                        mutationId = this.generateQueryId();\n                        mutation = this.transform(mutation).document;\n                        this.setQuery(mutationId, function () { return ({ document: mutation }); });\n                        variables = this.getVariables(mutation, variables);\n                        if (!this.transform(mutation).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = _f.sent();\n                        _f.label = 2;\n                    case 2:\n                        generateUpdateQueriesInfo = function () {\n                            var ret = {};\n                            if (updateQueriesByName) {\n                                _this.queries.forEach(function (_a, queryId) {\n                                    var observableQuery = _a.observableQuery;\n                                    if (observableQuery) {\n                                        var queryName = observableQuery.queryName;\n                                        if (queryName &&\n                                            hasOwnProperty.call(updateQueriesByName, queryName)) {\n                                            ret[queryId] = {\n                                                updater: updateQueriesByName[queryName],\n                                                query: _this.queryStore.get(queryId),\n                                            };\n                                        }\n                                    }\n                                });\n                            }\n                            return ret;\n                        };\n                        this.mutationStore.initMutation(mutationId, mutation, variables);\n                        this.dataStore.markMutationInit({\n                            mutationId: mutationId,\n                            document: mutation,\n                            variables: variables,\n                            updateQueries: generateUpdateQueriesInfo(),\n                            update: updateWithProxyFn,\n                            optimisticResponse: optimisticResponse,\n                        });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                var storeResult;\n                                var error;\n                                self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError({\n                                                graphQLErrors: result.errors,\n                                            });\n                                            return;\n                                        }\n                                        self.mutationStore.markMutationResult(mutationId);\n                                        if (fetchPolicy !== 'no-cache') {\n                                            self.dataStore.markMutationResult({\n                                                mutationId: mutationId,\n                                                result: result,\n                                                document: mutation,\n                                                variables: variables,\n                                                updateQueries: generateUpdateQueriesInfo(),\n                                                update: updateWithProxyFn,\n                                            });\n                                        }\n                                        storeResult = result;\n                                    },\n                                    error: function (err) {\n                                        self.mutationStore.markMutationError(mutationId, err);\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        self.setQuery(mutationId, function () { return ({ document: null }); });\n                                        reject(new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                    complete: function () {\n                                        if (error) {\n                                            self.mutationStore.markMutationError(mutationId, error);\n                                        }\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        if (error) {\n                                            reject(error);\n                                            return;\n                                        }\n                                        if (typeof refetchQueries === 'function') {\n                                            refetchQueries = refetchQueries(storeResult);\n                                        }\n                                        var refetchQueryPromises = [];\n                                        if (isNonEmptyArray(refetchQueries)) {\n                                            refetchQueries.forEach(function (refetchQuery) {\n                                                if (typeof refetchQuery === 'string') {\n                                                    self.queries.forEach(function (_a) {\n                                                        var observableQuery = _a.observableQuery;\n                                                        if (observableQuery &&\n                                                            observableQuery.queryName === refetchQuery) {\n                                                            refetchQueryPromises.push(observableQuery.refetch());\n                                                        }\n                                                    });\n                                                }\n                                                else {\n                                                    var queryOptions = {\n                                                        query: refetchQuery.query,\n                                                        variables: refetchQuery.variables,\n                                                        fetchPolicy: 'network-only',\n                                                    };\n                                                    if (refetchQuery.context) {\n                                                        queryOptions.context = refetchQuery.context;\n                                                    }\n                                                    refetchQueryPromises.push(self.query(queryOptions));\n                                                }\n                                            });\n                                        }\n                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                                            self.setQuery(mutationId, function () { return ({ document: null }); });\n                                            if (errorPolicy === 'ignore' &&\n                                                storeResult &&\n                                                graphQLResultHasError(storeResult)) {\n                                                delete storeResult.errors;\n                                            }\n                                            resolve(storeResult);\n                                        });\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, fetchType, fetchMoreForQueryId) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, metadata, _b, fetchPolicy, _c, context, query, variables, storeResult, isNetworkOnly, needToFetch, _d, complete, result, shouldFetch, requestId, cancel, networkResult;\n            var _this = this;\n            return __generator(this, function (_e) {\n                switch (_e.label) {\n                    case 0:\n                        _a = options.metadata, metadata = _a === void 0 ? null : _a, _b = options.fetchPolicy, fetchPolicy = _b === void 0 ? 'cache-first' : _b, _c = options.context, context = _c === void 0 ? {} : _c;\n                        query = this.transform(options.query).document;\n                        variables = this.getVariables(query, options.variables);\n                        if (!this.transform(query).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(query, variables, context)];\n                    case 1:\n                        variables = _e.sent();\n                        _e.label = 2;\n                    case 2:\n                        options = __assign(__assign({}, options), { variables: variables });\n                        isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n                        needToFetch = isNetworkOnly;\n                        if (!isNetworkOnly) {\n                            _d = this.dataStore.getCache().diff({\n                                query: query,\n                                variables: variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }), complete = _d.complete, result = _d.result;\n                            needToFetch = !complete || fetchPolicy === 'cache-and-network';\n                            storeResult = result;\n                        }\n                        shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';\n                        if (hasDirectives(['live'], query))\n                            shouldFetch = true;\n                        requestId = this.idCounter++;\n                        cancel = fetchPolicy !== 'no-cache'\n                            ? this.updateQueryWatch(queryId, query, options)\n                            : undefined;\n                        this.setQuery(queryId, function () { return ({\n                            document: query,\n                            lastRequestId: requestId,\n                            invalidated: true,\n                            cancel: cancel,\n                        }); });\n                        this.invalidate(fetchMoreForQueryId);\n                        this.queryStore.initQuery({\n                            queryId: queryId,\n                            document: query,\n                            storePreviousVariables: shouldFetch,\n                            variables: variables,\n                            isPoll: fetchType === FetchType.poll,\n                            isRefetch: fetchType === FetchType.refetch,\n                            metadata: metadata,\n                            fetchMoreForQueryId: fetchMoreForQueryId,\n                        });\n                        this.broadcastQueries();\n                        if (shouldFetch) {\n                            networkResult = this.fetchRequest({\n                                requestId: requestId,\n                                queryId: queryId,\n                                document: query,\n                                options: options,\n                                fetchMoreForQueryId: fetchMoreForQueryId,\n                            }).catch(function (error) {\n                                if (isApolloError(error)) {\n                                    throw error;\n                                }\n                                else {\n                                    if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                                        _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);\n                                        _this.invalidate(queryId);\n                                        _this.invalidate(fetchMoreForQueryId);\n                                        _this.broadcastQueries();\n                                    }\n                                    throw new ApolloError({ networkError: error });\n                                }\n                            });\n                            if (fetchPolicy !== 'cache-and-network') {\n                                return [2, networkResult];\n                            }\n                            networkResult.catch(function () { });\n                        }\n                        this.queryStore.markQueryResultClient(queryId, !shouldFetch);\n                        this.invalidate(queryId);\n                        this.invalidate(fetchMoreForQueryId);\n                        if (this.transform(query).hasForcedResolvers) {\n                            return [2, this.localState.runResolvers({\n                                    document: query,\n                                    remoteResult: { data: storeResult },\n                                    context: context,\n                                    variables: variables,\n                                    onlyRunForcedResolvers: true,\n                                }).then(function (result) {\n                                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                                    _this.broadcastQueries();\n                                    return result;\n                                })];\n                        }\n                        this.broadcastQueries();\n                        return [2, { data: storeResult }];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {\n        var fetchPolicy = _a.fetchPolicy, variables = _a.variables, errorPolicy = _a.errorPolicy;\n        if (fetchPolicy === 'no-cache') {\n            this.setQuery(queryId, function () { return ({\n                newData: { result: result.data, complete: true },\n            }); });\n        }\n        else {\n            this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');\n        }\n    };\n    QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {\n        var _this = this;\n        function invoke(method, argument) {\n            if (observer[method]) {\n                try {\n                    observer[method](argument);\n                }\n                catch (e) {\n                    process.env.NODE_ENV === \"production\" || invariant.error(e);\n                }\n            }\n            else if (method === 'error') {\n                process.env.NODE_ENV === \"production\" || invariant.error(argument);\n            }\n        }\n        return function (queryStoreValue, newData) {\n            _this.invalidate(queryId, false);\n            if (!queryStoreValue)\n                return;\n            var _a = _this.getQuery(queryId), observableQuery = _a.observableQuery, document = _a.document;\n            var fetchPolicy = observableQuery\n                ? observableQuery.options.fetchPolicy\n                : options.fetchPolicy;\n            if (fetchPolicy === 'standby')\n                return;\n            var loading = isNetworkRequestInFlight(queryStoreValue.networkStatus);\n            var lastResult = observableQuery && observableQuery.getLastResult();\n            var networkStatusChanged = !!(lastResult &&\n                lastResult.networkStatus !== queryStoreValue.networkStatus);\n            var shouldNotifyIfLoading = options.returnPartialData ||\n                (!newData && queryStoreValue.previousVariables) ||\n                (networkStatusChanged && options.notifyOnNetworkStatusChange) ||\n                fetchPolicy === 'cache-only' ||\n                fetchPolicy === 'cache-and-network';\n            if (loading && !shouldNotifyIfLoading) {\n                return;\n            }\n            var hasGraphQLErrors = isNonEmptyArray(queryStoreValue.graphQLErrors);\n            var errorPolicy = observableQuery\n                && observableQuery.options.errorPolicy\n                || options.errorPolicy\n                || 'none';\n            if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {\n                return invoke('error', new ApolloError({\n                    graphQLErrors: queryStoreValue.graphQLErrors,\n                    networkError: queryStoreValue.networkError,\n                }));\n            }\n            try {\n                var data = void 0;\n                var isMissing = void 0;\n                if (newData) {\n                    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {\n                        _this.setQuery(queryId, function () { return ({ newData: null }); });\n                    }\n                    data = newData.result;\n                    isMissing = !newData.complete;\n                }\n                else {\n                    var lastError = observableQuery && observableQuery.getLastError();\n                    var errorStatusChanged = errorPolicy !== 'none' &&\n                        (lastError && lastError.graphQLErrors) !==\n                            queryStoreValue.graphQLErrors;\n                    if (lastResult && lastResult.data && !errorStatusChanged) {\n                        data = lastResult.data;\n                        isMissing = false;\n                    }\n                    else {\n                        var diffResult = _this.dataStore.getCache().diff({\n                            query: document,\n                            variables: queryStoreValue.previousVariables ||\n                                queryStoreValue.variables,\n                            returnPartialData: true,\n                            optimistic: true,\n                        });\n                        data = diffResult.result;\n                        isMissing = !diffResult.complete;\n                    }\n                }\n                var stale = isMissing && !(options.returnPartialData ||\n                    fetchPolicy === 'cache-only');\n                var resultFromStore = {\n                    data: stale ? lastResult && lastResult.data : data,\n                    loading: loading,\n                    networkStatus: queryStoreValue.networkStatus,\n                    stale: stale,\n                };\n                if (errorPolicy === 'all' && hasGraphQLErrors) {\n                    resultFromStore.errors = queryStoreValue.graphQLErrors;\n                }\n                invoke('next', resultFromStore);\n            }\n            catch (networkError) {\n                invoke('error', new ApolloError({ networkError: networkError }));\n            }\n        };\n    };\n    QueryManager.prototype.transform = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cache = this.dataStore.getCache();\n            var transformed = cache.transformDocument(document);\n            var forLink = removeConnectionDirectiveFromDocument(cache.transformForLink(transformed));\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = this.localState.serverQuery(forLink);\n            var cacheEntry_1 = {\n                document: transformed,\n                hasClientExports: hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: getDefaultValues(getOperationDefinition(transformed)),\n            };\n            var add = function (doc) {\n                if (doc && !transformCache.has(doc)) {\n                    transformCache.set(doc, cacheEntry_1);\n                }\n            };\n            add(document);\n            add(transformed);\n            add(clientQuery);\n            add(serverQuery);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n        if (shouldSubscribe === void 0) { shouldSubscribe = true; }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'standby', 11) : invariant(options.fetchPolicy !== 'standby', 'client.watchQuery cannot be called with fetchPolicy set to \"standby\"');\n        options.variables = this.getVariables(options.query, options.variables);\n        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var transformedOptions = __assign({}, options);\n        return new ObservableQuery({\n            queryManager: this,\n            options: transformedOptions,\n            shouldSubscribe: shouldSubscribe,\n        });\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(options.query, 12) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        process.env.NODE_ENV === \"production\" ? invariant(options.query.kind === 'Document', 13) : invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.returnPartialData, 14) : invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.pollInterval, 15) : invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');\n        return new Promise(function (resolve, reject) {\n            var watchedQuery = _this.watchQuery(options, false);\n            _this.fetchQueryRejectFns.set(\"query:\" + watchedQuery.queryId, reject);\n            watchedQuery\n                .result()\n                .then(resolve, reject)\n                .then(function () {\n                return _this.fetchQueryRejectFns.delete(\"query:\" + watchedQuery.queryId);\n            });\n        });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.idCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        this.stopPollingQuery(queryId);\n        this.queryStore.stopQuery(queryId);\n        this.invalidate(queryId);\n    };\n    QueryManager.prototype.addQueryListener = function (queryId, listener) {\n        this.setQuery(queryId, function (_a) {\n            var listeners = _a.listeners;\n            listeners.add(listener);\n            return { invalidated: false };\n        });\n    };\n    QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {\n        var _this = this;\n        var cancel = this.getQuery(queryId).cancel;\n        if (cancel)\n            cancel();\n        var previousResult = function () {\n            var previousResult = null;\n            var observableQuery = _this.getQuery(queryId).observableQuery;\n            if (observableQuery) {\n                var lastResult = observableQuery.getLastResult();\n                if (lastResult) {\n                    previousResult = lastResult.data;\n                }\n            }\n            return previousResult;\n        };\n        return this.dataStore.getCache().watch({\n            query: document,\n            variables: options.variables,\n            optimistic: true,\n            previousResult: previousResult,\n            callback: function (newData) {\n                _this.setQuery(queryId, function () { return ({ invalidated: true, newData: newData }); });\n            },\n        });\n    };\n    QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {\n        this.setQuery(queryId, function () { return ({ observableQuery: observableQuery }); });\n    };\n    QueryManager.prototype.removeObservableQuery = function (queryId) {\n        var cancel = this.getQuery(queryId).cancel;\n        this.setQuery(queryId, function () { return ({ observableQuery: null }); });\n        if (cancel)\n            cancel();\n    };\n    QueryManager.prototype.clearStore = function () {\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(16) : new InvariantError('Store reset while query was in flight (not completed in link chain)'));\n        });\n        var resetIds = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery)\n                resetIds.push(queryId);\n        });\n        this.queryStore.reset(resetIds);\n        this.mutationStore.reset();\n        return this.dataStore.reset();\n    };\n    QueryManager.prototype.resetStore = function () {\n        var _this = this;\n        return this.clearStore().then(function () {\n            return _this.reFetchObservableQueries();\n        });\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery) {\n                var fetchPolicy = observableQuery.options.fetchPolicy;\n                observableQuery.resetLastResults();\n                if (fetchPolicy !== 'cache-only' &&\n                    (includeStandby || fetchPolicy !== 'standby')) {\n                    observableQueryPromises.push(observableQuery.refetch());\n                }\n                _this.setQuery(queryId, function () { return ({ newData: null }); });\n                _this.invalidate(queryId);\n            }\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.observeQuery = function (queryId, options, observer) {\n        this.addQueryListener(queryId, this.queryListenerForObserver(queryId, options, observer));\n        return this.fetchQuery(queryId, options);\n    };\n    QueryManager.prototype.startQuery = function (queryId, options, listener) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"The QueryManager.startQuery method has been deprecated\");\n        this.addQueryListener(queryId, listener);\n        this.fetchQuery(queryId, options)\n            .catch(function () { return undefined; });\n        return queryId;\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables;\n        query = this.transform(query).document;\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, {}, variables, false).map(function (result) {\n                if (!fetchPolicy || fetchPolicy !== 'no-cache') {\n                    _this.dataStore.markSubscriptionResult(result, query, variables);\n                    _this.broadcastQueries();\n                }\n                if (graphQLResultHasError(result)) {\n                    throw new ApolloError({\n                        graphQLErrors: result.errors,\n                    });\n                }\n                return result;\n            });\n        };\n        if (this.transform(query).hasClientExports) {\n            var observablePromise_1 = this.localState.addExportedVariables(query, variables).then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        this.fetchQueryRejectFns.delete(\"query:\" + queryId);\n        this.fetchQueryRejectFns.delete(\"fetchRequest:\" + queryId);\n        this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });\n        this.queries.delete(queryId);\n    };\n    QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {\n        if (optimistic === void 0) { optimistic = true; }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query, fetchPolicy = _a.fetchPolicy, returnPartialData = _a.returnPartialData;\n        var lastResult = observableQuery.getLastResult();\n        var newData = this.getQuery(observableQuery.queryId).newData;\n        if (newData && newData.complete) {\n            return { data: newData.result, partial: false };\n        }\n        if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {\n            return { data: undefined, partial: false };\n        }\n        var _b = this.dataStore.getCache().diff({\n            query: query,\n            variables: variables,\n            previousResult: lastResult ? lastResult.data : undefined,\n            returnPartialData: true,\n            optimistic: optimistic,\n        }), result = _b.result, complete = _b.complete;\n        return {\n            data: (complete || returnPartialData) ? result : void 0,\n            partial: !complete,\n        };\n    };\n    QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {\n        var observableQuery;\n        if (typeof queryIdOrObservable === 'string') {\n            var foundObserveableQuery = this.getQuery(queryIdOrObservable).observableQuery;\n            process.env.NODE_ENV === \"production\" ? invariant(foundObserveableQuery, 17) : invariant(foundObserveableQuery, \"ObservableQuery with this id doesn't exist: \" + queryIdOrObservable);\n            observableQuery = foundObserveableQuery;\n        }\n        else {\n            observableQuery = queryIdOrObservable;\n        }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query;\n        return {\n            previousResult: this.getCurrentQueryResult(observableQuery, false).data,\n            variables: variables,\n            document: query,\n        };\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        var _this = this;\n        this.onBroadcast();\n        this.queries.forEach(function (info, id) {\n            if (info.invalidated) {\n                info.listeners.forEach(function (listener) {\n                    if (listener) {\n                        listener(_this.queryStore.get(id), info.newData);\n                    }\n                });\n            }\n        });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n        var _this = this;\n        if (deduplication === void 0) { deduplication = this.queryDeduplication; }\n        var observable;\n        var serverQuery = this.transform(query).serverQuery;\n        if (serverQuery) {\n            var _a = this, inFlightLinkObservables_1 = _a.inFlightLinkObservables, link = _a.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n            };\n            context = operation.context;\n            if (deduplication) {\n                var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();\n                inFlightLinkObservables_1.set(serverQuery, byVariables_1);\n                var varJson_1 = JSON.stringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    byVariables_1.set(varJson_1, observable = multiplex(execute(link, operation)));\n                    var cleanup = function () {\n                        byVariables_1.delete(varJson_1);\n                        if (!byVariables_1.size)\n                            inFlightLinkObservables_1.delete(serverQuery);\n                        cleanupSub_1.unsubscribe();\n                    };\n                    var cleanupSub_1 = observable.subscribe({\n                        next: cleanup,\n                        error: cleanup,\n                        complete: cleanup,\n                    });\n                }\n            }\n            else {\n                observable = multiplex(execute(link, operation));\n            }\n        }\n        else {\n            observable = Observable.of({ data: {} });\n            context = this.prepareContext(context);\n        }\n        var clientQuery = this.transform(query).clientQuery;\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.fetchRequest = function (_a) {\n        var _this = this;\n        var requestId = _a.requestId, queryId = _a.queryId, document = _a.document, options = _a.options, fetchMoreForQueryId = _a.fetchMoreForQueryId;\n        var variables = options.variables, _b = options.errorPolicy, errorPolicy = _b === void 0 ? 'none' : _b, fetchPolicy = options.fetchPolicy;\n        var resultFromStore;\n        var errorsFromStore;\n        return new Promise(function (resolve, reject) {\n            var observable = _this.getObservableFromLink(document, options.context, variables);\n            var fqrfId = \"fetchRequest:\" + queryId;\n            _this.fetchQueryRejectFns.set(fqrfId, reject);\n            var cleanup = function () {\n                _this.fetchQueryRejectFns.delete(fqrfId);\n                _this.setQuery(queryId, function (_a) {\n                    var subscriptions = _a.subscriptions;\n                    subscriptions.delete(subscription);\n                });\n            };\n            var subscription = observable.map(function (result) {\n                if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                    _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);\n                    _this.invalidate(queryId);\n                    _this.invalidate(fetchMoreForQueryId);\n                    _this.broadcastQueries();\n                }\n                if (errorPolicy === 'none' && isNonEmptyArray(result.errors)) {\n                    return reject(new ApolloError({\n                        graphQLErrors: result.errors,\n                    }));\n                }\n                if (errorPolicy === 'all') {\n                    errorsFromStore = result.errors;\n                }\n                if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {\n                    resultFromStore = result.data;\n                }\n                else {\n                    var _a = _this.dataStore.getCache().diff({\n                        variables: variables,\n                        query: document,\n                        optimistic: false,\n                        returnPartialData: true,\n                    }), result_1 = _a.result, complete = _a.complete;\n                    if (complete || options.returnPartialData) {\n                        resultFromStore = result_1;\n                    }\n                }\n            }).subscribe({\n                error: function (error) {\n                    cleanup();\n                    reject(error);\n                },\n                complete: function () {\n                    cleanup();\n                    resolve({\n                        data: resultFromStore,\n                        errors: errorsFromStore,\n                        loading: false,\n                        networkStatus: NetworkStatus.ready,\n                        stale: false,\n                    });\n                },\n            });\n            _this.setQuery(queryId, function (_a) {\n                var subscriptions = _a.subscriptions;\n                subscriptions.add(subscription);\n            });\n        });\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        return (this.queries.get(queryId) || {\n            listeners: new Set(),\n            invalidated: false,\n            document: null,\n            newData: null,\n            lastRequestId: 1,\n            observableQuery: null,\n            subscriptions: new Set(),\n        });\n    };\n    QueryManager.prototype.setQuery = function (queryId, updater) {\n        var prev = this.getQuery(queryId);\n        var newInfo = __assign(__assign({}, prev), updater(prev));\n        this.queries.set(queryId, newInfo);\n    };\n    QueryManager.prototype.invalidate = function (queryId, invalidated) {\n        if (invalidated === void 0) { invalidated = true; }\n        if (queryId) {\n            this.setQuery(queryId, function () { return ({ invalidated: invalidated }); });\n        }\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign({}, newContext), { clientAwareness: this.clientAwareness });\n    };\n    QueryManager.prototype.checkInFlight = function (queryId) {\n        var query = this.queryStore.get(queryId);\n        return (query &&\n            query.networkStatus !== NetworkStatus.ready &&\n            query.networkStatus !== NetworkStatus.error);\n    };\n    QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n        var _this = this;\n        var pollInterval = options.pollInterval;\n        process.env.NODE_ENV === \"production\" ? invariant(pollInterval, 18) : invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');\n        if (!this.ssrMode) {\n            var info = this.pollingInfoByQueryId.get(queryId);\n            if (!info) {\n                this.pollingInfoByQueryId.set(queryId, (info = {}));\n            }\n            info.interval = pollInterval;\n            info.options = __assign(__assign({}, options), { fetchPolicy: 'network-only' });\n            var maybeFetch_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    if (_this.checkInFlight(queryId)) {\n                        poll_1();\n                    }\n                    else {\n                        _this.fetchQuery(queryId, info.options, FetchType.poll).then(poll_1, poll_1);\n                    }\n                }\n            };\n            var poll_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    clearTimeout(info.timeout);\n                    info.timeout = setTimeout(maybeFetch_1, info.interval);\n                }\n            };\n            if (listener) {\n                this.addQueryListener(queryId, listener);\n            }\n            poll_1();\n        }\n        return queryId;\n    };\n    QueryManager.prototype.stopPollingQuery = function (queryId) {\n        this.pollingInfoByQueryId.delete(queryId);\n    };\n    return QueryManager;\n}());\n\nvar DataStore = (function () {\n    function DataStore(initialCache) {\n        this.cache = initialCache;\n    }\n    DataStore.prototype.getCache = function () {\n        return this.cache;\n    };\n    DataStore.prototype.markQueryResult = function (result, document, variables, fetchMoreForQueryId, ignoreErrors) {\n        if (ignoreErrors === void 0) { ignoreErrors = false; }\n        var writeWithErrors = !graphQLResultHasError(result);\n        if (ignoreErrors && graphQLResultHasError(result) && result.data) {\n            writeWithErrors = true;\n        }\n        if (!fetchMoreForQueryId && writeWithErrors) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_QUERY',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markSubscriptionResult = function (result, document, variables) {\n        if (!graphQLResultHasError(result)) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_SUBSCRIPTION',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markMutationInit = function (mutation) {\n        var _this = this;\n        if (mutation.optimisticResponse) {\n            var optimistic_1;\n            if (typeof mutation.optimisticResponse === 'function') {\n                optimistic_1 = mutation.optimisticResponse(mutation.variables);\n            }\n            else {\n                optimistic_1 = mutation.optimisticResponse;\n            }\n            this.cache.recordOptimisticTransaction(function (c) {\n                var orig = _this.cache;\n                _this.cache = c;\n                try {\n                    _this.markMutationResult({\n                        mutationId: mutation.mutationId,\n                        result: { data: optimistic_1 },\n                        document: mutation.document,\n                        variables: mutation.variables,\n                        updateQueries: mutation.updateQueries,\n                        update: mutation.update,\n                    });\n                }\n                finally {\n                    _this.cache = orig;\n                }\n            }, mutation.mutationId);\n        }\n    };\n    DataStore.prototype.markMutationResult = function (mutation) {\n        var _this = this;\n        if (!graphQLResultHasError(mutation.result)) {\n            var cacheWrites_1 = [{\n                    result: mutation.result.data,\n                    dataId: 'ROOT_MUTATION',\n                    query: mutation.document,\n                    variables: mutation.variables,\n                }];\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                Object.keys(updateQueries_1).forEach(function (id) {\n                    var _a = updateQueries_1[id], query = _a.query, updater = _a.updater;\n                    var _b = _this.cache.diff({\n                        query: query.document,\n                        variables: query.variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _b.result, complete = _b.complete;\n                    if (complete) {\n                        var nextQueryResult = tryFunctionOrLogError(function () {\n                            return updater(currentQueryResult, {\n                                mutationResult: mutation.result,\n                                queryName: getOperationName(query.document) || undefined,\n                                queryVariables: query.variables,\n                            });\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites_1.push({\n                                result: nextQueryResult,\n                                dataId: 'ROOT_QUERY',\n                                query: query.document,\n                                variables: query.variables,\n                            });\n                        }\n                    }\n                });\n            }\n            this.cache.performTransaction(function (c) {\n                cacheWrites_1.forEach(function (write) { return c.write(write); });\n                var update = mutation.update;\n                if (update) {\n                    tryFunctionOrLogError(function () { return update(c, mutation.result); });\n                }\n            });\n        }\n    };\n    DataStore.prototype.markMutationComplete = function (_a) {\n        var mutationId = _a.mutationId, optimisticResponse = _a.optimisticResponse;\n        if (optimisticResponse) {\n            this.cache.removeOptimistic(mutationId);\n        }\n    };\n    DataStore.prototype.markUpdateQueryResult = function (document, variables, newResult) {\n        this.cache.write({\n            result: newResult,\n            dataId: 'ROOT_QUERY',\n            variables: variables,\n            query: document,\n        });\n    };\n    DataStore.prototype.reset = function () {\n        return this.cache.reset();\n    };\n    return DataStore;\n}());\n\nvar version = \"2.6.8\";\n\nvar hasSuggestedDevtools = false;\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.defaultOptions = {};\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        var cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? false : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;\n        var link = options.link;\n        if (!link && resolvers) {\n            link = ApolloLink.empty();\n        }\n        if (!link || !cache) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError(\"In order to initialize Apollo Client, you must specify 'link' and 'cache' properties in the options object.\\n\" +\n                \"These options are part of the upgrade requirements when migrating from Apollo Client 1.x to Apollo Client 2.x.\\n\" +\n                \"For more information, please visit: https://www.apollographql.com/docs/tutorial/client.html#apollo-client-setup\");\n        }\n        this.link = link;\n        this.cache = cache;\n        this.store = new DataStore(cache);\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || {};\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        var defaultConnectToDevTools = process.env.NODE_ENV !== 'production' &&\n            typeof window !== 'undefined' &&\n            !window.__APOLLO_CLIENT__;\n        if (typeof connectToDevTools === 'undefined'\n            ? defaultConnectToDevTools\n            : connectToDevTools && typeof window !== 'undefined') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self) {\n                if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n                    if (window.navigator &&\n                        window.navigator.userAgent &&\n                        window.navigator.userAgent.indexOf('Chrome') > -1) {\n                        console.debug('Download the Apollo DevTools ' +\n                            'for a better development experience: ' +\n                            'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n                    }\n                }\n            }\n        }\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            link: this.link,\n            store: this.store,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: function () {\n                if (_this.devToolsHookCb) {\n                    _this.devToolsHookCb({\n                        action: {},\n                        state: {\n                            queries: _this.queryManager.queryStore.getStore(),\n                            mutations: _this.queryManager.mutationStore.getStore(),\n                        },\n                        dataWithOptimisticResults: _this.cache.extract(true),\n                    });\n                }\n            },\n        });\n    }\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = __assign(__assign({}, this.defaultOptions.watchQuery), options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = __assign(__assign({}, this.defaultOptions.query), options);\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'cache-and-network', 2) : invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +\n            'client.query can only return a single result. Please use client.watchQuery ' +\n            'to receive multiple results from the cache and the network, or consider ' +\n            'using a different fetchPolicy, such as cache-first or network-only.');\n        if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = __assign(__assign({}, this.defaultOptions.mutate), options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    ApolloClient.prototype.writeQuery = function (options) {\n        var result = this.cache.writeQuery(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        var result = this.cache.writeFragment(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeData = function (options) {\n        var result = this.cache.writeData(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    ApolloClient.prototype.initQueryManager = function () {\n        process.env.NODE_ENV === \"production\" || invariant.warn('Calling the initQueryManager method is no longer necessary, ' +\n            'and it will be removed from ApolloClient in version 3.0.');\n        return this.queryManager;\n    };\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    return ApolloClient;\n}());\n\nexport default ApolloClient;\nexport { ApolloClient, ApolloError, FetchType, NetworkStatus, ObservableQuery, isApolloError };\n//# sourceMappingURL=bundle.esm.js.map\n","// This currentContext variable will only be used if the makeSlotClass\r\n// function is called, which happens only if this is the first copy of the\r\n// @wry/context package to be imported.\r\nvar currentContext = null;\r\n// This unique internal object is used to denote the absence of a value\r\n// for a given Slot, and is never exposed to outside code.\r\nvar MISSING_VALUE = {};\r\nvar idCounter = 1;\r\n// Although we can't do anything about the cost of duplicated code from\r\n// accidentally bundling multiple copies of the @wry/context package, we can\r\n// avoid creating the Slot class more than once using makeSlotClass.\r\nvar makeSlotClass = function () { return /** @class */ (function () {\r\n    function Slot() {\r\n        // If you have a Slot object, you can find out its slot.id, but you cannot\r\n        // guess the slot.id of a Slot you don't have access to, thanks to the\r\n        // randomized suffix.\r\n        this.id = [\r\n            \"slot\",\r\n            idCounter++,\r\n            Date.now(),\r\n            Math.random().toString(36).slice(2),\r\n        ].join(\":\");\r\n    }\r\n    Slot.prototype.hasValue = function () {\r\n        for (var context_1 = currentContext; context_1; context_1 = context_1.parent) {\r\n            // We use the Slot object iself as a key to its value, which means the\r\n            // value cannot be obtained without a reference to the Slot object.\r\n            if (this.id in context_1.slots) {\r\n                var value = context_1.slots[this.id];\r\n                if (value === MISSING_VALUE)\r\n                    break;\r\n                if (context_1 !== currentContext) {\r\n                    // Cache the value in currentContext.slots so the next lookup will\r\n                    // be faster. This caching is safe because the tree of contexts and\r\n                    // the values of the slots are logically immutable.\r\n                    currentContext.slots[this.id] = value;\r\n                }\r\n                return true;\r\n            }\r\n        }\r\n        if (currentContext) {\r\n            // If a value was not found for this Slot, it's never going to be found\r\n            // no matter how many times we look it up, so we might as well cache\r\n            // the absence of the value, too.\r\n            currentContext.slots[this.id] = MISSING_VALUE;\r\n        }\r\n        return false;\r\n    };\r\n    Slot.prototype.getValue = function () {\r\n        if (this.hasValue()) {\r\n            return currentContext.slots[this.id];\r\n        }\r\n    };\r\n    Slot.prototype.withValue = function (value, callback, \r\n    // Given the prevalence of arrow functions, specifying arguments is likely\r\n    // to be much more common than specifying `this`, hence this ordering:\r\n    args, thisArg) {\r\n        var _a;\r\n        var slots = (_a = {\r\n                __proto__: null\r\n            },\r\n            _a[this.id] = value,\r\n            _a);\r\n        var parent = currentContext;\r\n        currentContext = { parent: parent, slots: slots };\r\n        try {\r\n            // Function.prototype.apply allows the arguments array argument to be\r\n            // omitted or undefined, so args! is fine here.\r\n            return callback.apply(thisArg, args);\r\n        }\r\n        finally {\r\n            currentContext = parent;\r\n        }\r\n    };\r\n    // Capture the current context and wrap a callback function so that it\r\n    // reestablishes the captured context when called.\r\n    Slot.bind = function (callback) {\r\n        var context = currentContext;\r\n        return function () {\r\n            var saved = currentContext;\r\n            try {\r\n                currentContext = context;\r\n                return callback.apply(this, arguments);\r\n            }\r\n            finally {\r\n                currentContext = saved;\r\n            }\r\n        };\r\n    };\r\n    // Immediately run a callback function without any captured context.\r\n    Slot.noContext = function (callback, \r\n    // Given the prevalence of arrow functions, specifying arguments is likely\r\n    // to be much more common than specifying `this`, hence this ordering:\r\n    args, thisArg) {\r\n        if (currentContext) {\r\n            var saved = currentContext;\r\n            try {\r\n                currentContext = null;\r\n                // Function.prototype.apply allows the arguments array argument to be\r\n                // omitted or undefined, so args! is fine here.\r\n                return callback.apply(thisArg, args);\r\n            }\r\n            finally {\r\n                currentContext = saved;\r\n            }\r\n        }\r\n        else {\r\n            return callback.apply(thisArg, args);\r\n        }\r\n    };\r\n    return Slot;\r\n}()); };\r\n// We store a single global implementation of the Slot class as a permanent\r\n// non-enumerable symbol property of the Array constructor. This obfuscation\r\n// does nothing to prevent access to the Slot class, but at least it ensures\r\n// the implementation (i.e. currentContext) cannot be tampered with, and all\r\n// copies of the @wry/context package (hopefully just one) will share the\r\n// same Slot implementation. Since the first copy of the @wry/context package\r\n// to be imported wins, this technique imposes a very high cost for any\r\n// future breaking changes to the Slot class.\r\nvar globalKey = \"@wry/context:Slot\";\r\nvar host = Array;\r\nvar Slot = host[globalKey] || function () {\r\n    var Slot = makeSlotClass();\r\n    try {\r\n        Object.defineProperty(host, globalKey, {\r\n            value: host[globalKey] = Slot,\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: false,\r\n        });\r\n    }\r\n    finally {\r\n        return Slot;\r\n    }\r\n}();\n\nvar bind = Slot.bind, noContext = Slot.noContext;\r\nfunction setTimeoutWithContext(callback, delay) {\r\n    return setTimeout(bind(callback), delay);\r\n}\r\n// Turn any generator function into an async function (using yield instead\r\n// of await), with context automatically preserved across yields.\r\nfunction asyncFromGen(genFn) {\r\n    return function () {\r\n        var gen = genFn.apply(this, arguments);\r\n        var boundNext = bind(gen.next);\r\n        var boundThrow = bind(gen.throw);\r\n        return new Promise(function (resolve, reject) {\r\n            function invoke(method, argument) {\r\n                try {\r\n                    var result = method.call(gen, argument);\r\n                }\r\n                catch (error) {\r\n                    return reject(error);\r\n                }\r\n                var next = result.done ? resolve : invokeNext;\r\n                if (isPromiseLike(result.value)) {\r\n                    result.value.then(next, result.done ? reject : invokeThrow);\r\n                }\r\n                else {\r\n                    next(result.value);\r\n                }\r\n            }\r\n            var invokeNext = function (value) { return invoke(boundNext, value); };\r\n            var invokeThrow = function (error) { return invoke(boundThrow, error); };\r\n            invokeNext();\r\n        });\r\n    };\r\n}\r\nfunction isPromiseLike(value) {\r\n    return value && typeof value.then === \"function\";\r\n}\r\n// If you use the fibers npm package to implement coroutines in Node.js,\r\n// you should call this function at least once to ensure context management\r\n// remains coherent across any yields.\r\nvar wrappedFibers = [];\r\nfunction wrapYieldingFiberMethods(Fiber) {\r\n    // There can be only one implementation of Fiber per process, so this array\r\n    // should never grow longer than one element.\r\n    if (wrappedFibers.indexOf(Fiber) < 0) {\r\n        var wrap = function (obj, method) {\r\n            var fn = obj[method];\r\n            obj[method] = function () {\r\n                return noContext(fn, arguments, this);\r\n            };\r\n        };\r\n        // These methods can yield, according to\r\n        // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\r\n        wrap(Fiber, \"yield\");\r\n        wrap(Fiber.prototype, \"run\");\r\n        wrap(Fiber.prototype, \"throwInto\");\r\n        wrappedFibers.push(Fiber);\r\n    }\r\n    return Fiber;\r\n}\n\nexport { Slot, asyncFromGen, bind, noContext, setTimeoutWithContext as setTimeout, wrapYieldingFiberMethods };\n//# sourceMappingURL=context.esm.js.map\n","function _taggedTemplateLiteral(e, t) {\n  return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, {\n    raw: {\n      value: Object.freeze(t)\n    }\n  }));\n}\nexport { _taggedTemplateLiteral as default };","var _a = Object.prototype, toString = _a.toString, hasOwnProperty = _a.hasOwnProperty;\r\nvar previousComparisons = new Map();\r\n/**\r\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\r\n */\r\nfunction equal(a, b) {\r\n    try {\r\n        return check(a, b);\r\n    }\r\n    finally {\r\n        previousComparisons.clear();\r\n    }\r\n}\r\nfunction check(a, b) {\r\n    // If the two values are strictly equal, our job is easy.\r\n    if (a === b) {\r\n        return true;\r\n    }\r\n    // Object.prototype.toString returns a representation of the runtime type of\r\n    // the given value that is considerably more precise than typeof.\r\n    var aTag = toString.call(a);\r\n    var bTag = toString.call(b);\r\n    // If the runtime types of a and b are different, they could maybe be equal\r\n    // under some interpretation of equality, but for simplicity and performance\r\n    // we just return false instead.\r\n    if (aTag !== bTag) {\r\n        return false;\r\n    }\r\n    switch (aTag) {\r\n        case '[object Array]':\r\n            // Arrays are a lot like other objects, but we can cheaply compare their\r\n            // lengths as a short-cut before comparing their elements.\r\n            if (a.length !== b.length)\r\n                return false;\r\n        // Fall through to object case...\r\n        case '[object Object]': {\r\n            if (previouslyCompared(a, b))\r\n                return true;\r\n            var aKeys = Object.keys(a);\r\n            var bKeys = Object.keys(b);\r\n            // If `a` and `b` have a different number of enumerable keys, they\r\n            // must be different.\r\n            var keyCount = aKeys.length;\r\n            if (keyCount !== bKeys.length)\r\n                return false;\r\n            // Now make sure they have the same keys.\r\n            for (var k = 0; k < keyCount; ++k) {\r\n                if (!hasOwnProperty.call(b, aKeys[k])) {\r\n                    return false;\r\n                }\r\n            }\r\n            // Finally, check deep equality of all child properties.\r\n            for (var k = 0; k < keyCount; ++k) {\r\n                var key = aKeys[k];\r\n                if (!check(a[key], b[key])) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n        case '[object Error]':\r\n            return a.name === b.name && a.message === b.message;\r\n        case '[object Number]':\r\n            // Handle NaN, which is !== itself.\r\n            if (a !== a)\r\n                return b !== b;\r\n        // Fall through to shared +a === +b case...\r\n        case '[object Boolean]':\r\n        case '[object Date]':\r\n            return +a === +b;\r\n        case '[object RegExp]':\r\n        case '[object String]':\r\n            return a == \"\" + b;\r\n        case '[object Map]':\r\n        case '[object Set]': {\r\n            if (a.size !== b.size)\r\n                return false;\r\n            if (previouslyCompared(a, b))\r\n                return true;\r\n            var aIterator = a.entries();\r\n            var isMap = aTag === '[object Map]';\r\n            while (true) {\r\n                var info = aIterator.next();\r\n                if (info.done)\r\n                    break;\r\n                // If a instanceof Set, aValue === aKey.\r\n                var _a = info.value, aKey = _a[0], aValue = _a[1];\r\n                // So this works the same way for both Set and Map.\r\n                if (!b.has(aKey)) {\r\n                    return false;\r\n                }\r\n                // However, we care about deep equality of values only when dealing\r\n                // with Map structures.\r\n                if (isMap && !check(aValue, b.get(aKey))) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n    }\r\n    // Otherwise the values are not equal.\r\n    return false;\r\n}\r\nfunction previouslyCompared(a, b) {\r\n    // Though cyclic references can make an object graph appear infinite from the\r\n    // perspective of a depth-first traversal, the graph still contains a finite\r\n    // number of distinct object references. We use the previousComparisons cache\r\n    // to avoid comparing the same pair of object references more than once, which\r\n    // guarantees termination (even if we end up comparing every object in one\r\n    // graph to every object in the other graph, which is extremely unlikely),\r\n    // while still allowing weird isomorphic structures (like rings with different\r\n    // lengths) a chance to pass the equality test.\r\n    var bSet = previousComparisons.get(a);\r\n    if (bSet) {\r\n        // Return true here because we can be sure false will be returned somewhere\r\n        // else if the objects are not equivalent.\r\n        if (bSet.has(b))\r\n            return true;\r\n    }\r\n    else {\r\n        previousComparisons.set(a, bSet = new Set);\r\n    }\r\n    bSet.add(b);\r\n    return false;\r\n}\n\nexport default equal;\nexport { equal };\n//# sourceMappingURL=equality.esm.js.map\n","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\nexport { _typeof as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nexport function Emitter(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n\n  // Remove event specific arrays for event types that no\n  // one is subscribed for to avoid memory leak.\n  if (callbacks.length === 0) {\n    delete this._callbacks['$' + event];\n  }\n\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n\n  var args = new Array(arguments.length - 1)\n    , callbacks = this._callbacks['$' + event];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args[i - 1] = arguments[i];\n  }\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n// alias used for reserved events (protected method)\nEmitter.prototype.emitReserved = Emitter.prototype.emit;\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n","import Observable from 'zen-observable-ts';\nexport { default as Observable } from 'zen-observable-ts';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { __extends, __assign } from 'tslib';\nimport { getOperationName } from 'apollo-utilities';\nexport { getOperationName } from 'apollo-utilities';\n\nfunction validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        'query',\n        'operationName',\n        'variables',\n        'extensions',\n        'context',\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"illegal argument: \" + key);\n        }\n    }\n    return operation;\n}\nvar LinkError = (function (_super) {\n    __extends(LinkError, _super);\n    function LinkError(message, link) {\n        var _this = _super.call(this, message) || this;\n        _this.link = link;\n        return _this;\n    }\n    return LinkError;\n}(Error));\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nfunction toPromise(observable) {\n    var completed = false;\n    return new Promise(function (resolve, reject) {\n        observable.subscribe({\n            next: function (data) {\n                if (completed) {\n                    process.env.NODE_ENV === \"production\" || invariant.warn(\"Promise Wrapper does not support multiple results from Observable\");\n                }\n                else {\n                    completed = true;\n                    resolve(data);\n                }\n            },\n            error: reject,\n        });\n    });\n}\nvar makePromise = toPromise;\nfunction fromPromise(promise) {\n    return new Observable(function (observer) {\n        promise\n            .then(function (value) {\n            observer.next(value);\n            observer.complete();\n        })\n            .catch(observer.error.bind(observer));\n    });\n}\nfunction fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\nfunction transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\n    };\n    if (!transformedOperation.operationName) {\n        transformedOperation.operationName =\n            typeof transformedOperation.query !== 'string'\n                ? getOperationName(transformedOperation.query)\n                : '';\n    }\n    return transformedOperation;\n}\nfunction createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === 'function') {\n            context = __assign({}, context, next(context));\n        }\n        else {\n            context = __assign({}, context, next);\n        }\n    };\n    var getContext = function () { return (__assign({}, context)); };\n    Object.defineProperty(operation, 'setContext', {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, 'getContext', {\n        enumerable: false,\n        value: getContext,\n    });\n    Object.defineProperty(operation, 'toKey', {\n        enumerable: false,\n        value: function () { return getKey(operation); },\n    });\n    return operation;\n}\nfunction getKey(operation) {\n    var query = operation.query, variables = operation.variables, operationName = operation.operationName;\n    return JSON.stringify([operationName, query, variables]);\n}\n\nfunction passthrough(op, forward) {\n    return forward ? forward(op) : Observable.of();\n}\nfunction toLink(handler) {\n    return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\nfunction empty() {\n    return new ApolloLink(function () { return Observable.of(); });\n}\nfunction from(links) {\n    if (links.length === 0)\n        return empty();\n    return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n}\nfunction split(test, left, right) {\n    var leftLink = toLink(left);\n    var rightLink = toLink(right || new ApolloLink(passthrough));\n    if (isTerminating(leftLink) && isTerminating(rightLink)) {\n        return new ApolloLink(function (operation) {\n            return test(operation)\n                ? leftLink.request(operation) || Observable.of()\n                : rightLink.request(operation) || Observable.of();\n        });\n    }\n    else {\n        return new ApolloLink(function (operation, forward) {\n            return test(operation)\n                ? leftLink.request(operation, forward) || Observable.of()\n                : rightLink.request(operation, forward) || Observable.of();\n        });\n    }\n}\nvar concat = function (first, second) {\n    var firstLink = toLink(first);\n    if (isTerminating(firstLink)) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(new LinkError(\"You are calling concat on a terminating link, which will have no effect\", firstLink));\n        return firstLink;\n    }\n    var nextLink = toLink(second);\n    if (isTerminating(nextLink)) {\n        return new ApolloLink(function (operation) {\n            return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n        });\n    }\n    else {\n        return new ApolloLink(function (operation, forward) {\n            return (firstLink.request(operation, function (op) {\n                return nextLink.request(op, forward) || Observable.of();\n            }) || Observable.of());\n        });\n    }\n};\nvar ApolloLink = (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('request is not implemented');\n    };\n    ApolloLink.empty = empty;\n    ApolloLink.from = from;\n    ApolloLink.split = split;\n    ApolloLink.execute = execute;\n    return ApolloLink;\n}());\nfunction execute(link, operation) {\n    return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n}\n\nexport { ApolloLink, concat, createOperation, empty, execute, from, fromError, fromPromise, makePromise, split, toPromise };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __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            try {\n                sub = forward(operation).subscribe({\n                    next: function (result) {\n                        if (result.errors) {\n                            retriedResult = errorHandler({\n                                graphQLErrors: result.errors,\n                                response: result,\n                                operation: operation,\n                                forward: forward,\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.next(result);\n                    },\n                    error: function (networkError) {\n                        retriedResult = errorHandler({\n                            operation: operation,\n                            networkError: networkError,\n                            graphQLErrors: networkError &&\n                                networkError.result &&\n                                networkError.result.errors,\n                            forward: forward,\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                        observer.error(networkError);\n                    },\n                    complete: function () {\n                        if (!retriedResult) {\n                            observer.complete.bind(observer)();\n                        }\n                    },\n                });\n            }\n            catch (e) {\n                errorHandler({ networkError: e, operation: operation, forward: forward });\n                observer.error(e);\n            }\n            return function () {\n                if (sub)\n                    sub.unsubscribe();\n                if (retriedSub)\n                    sub.unsubscribe();\n            };\n        });\n    });\n}\nvar ErrorLink = (function (_super) {\n    __extends(ErrorLink, _super);\n    function ErrorLink(errorHandler) {\n        var _this = _super.call(this) || this;\n        _this.link = onError(errorHandler);\n        return _this;\n    }\n    ErrorLink.prototype.request = function (operation, forward) {\n        return this.link.request(operation, forward);\n    };\n    return ErrorLink;\n}(ApolloLink));\n\nexport { ErrorLink, onError };\n//# sourceMappingURL=bundle.esm.js.map\n"],"sourceRoot":""}