{"version":3,"sources":["../node_modules/apollo-utilities/lib/bundle.esm.js","../node_modules/apollo-client/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link/lib/bundle.esm.js","../node_modules/apollo-utilities/node_modules/tslib/tslib.es6.js","../node_modules/apollo-client/bundle.esm.js","../node_modules/apollo-client/util/arrays.js","../node_modules/apollo-client/util/Observable.js","../node_modules/apollo-client/core/networkStatus.js","../node_modules/apollo-cache-inmemory/node_modules/tslib/tslib.es6.js","../node_modules/apollo-cache/lib/bundle.esm.js","../node_modules/apollo-cache-inmemory/lib/bundle.esm.js","../node_modules/apollo-upload-client/public/formDataAppendFile.js","../node_modules/apollo-upload-client/public/isExtractableFile.js","../node_modules/apollo-client/errors/ApolloError.js","../node_modules/apollo-client/core/types.js","../node_modules/apollo-client/core/LocalState.js","../node_modules/are-passive-events-supported/dist/are-passive-events-supported.esm.browser.js","../node_modules/apollo-upload-client/public/index.js","../node_modules/apollo-client/ApolloClient.js","../node_modules/apollo-link-batch-http/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link-http-common/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link-http-common/lib/bundle.esm.js","../node_modules/apollo-link-batch/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link-batch/lib/bundle.esm.js","../node_modules/apollo-link-batch-http/lib/bundle.esm.js","../node_modules/apollo-link-context/lib/bundle.esm.js","../node_modules/apollo-link-context/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link-ws/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link-ws/lib/bundle.esm.js","../node_modules/apollo-link-error/node_modules/tslib/tslib.es6.js","../node_modules/apollo-link-error/lib/bundle.esm.js","../node_modules/apollo-upload-client/public/createUploadLink.js","../node_modules/apollo-upload-client/public/ReactNativeFile.js","../node_modules/apollo-client/core/QueryManager.js","../node_modules/apollo-client/data/mutations.js","../node_modules/apollo-client/data/queries.js","../node_modules/apollo-client/core/ObservableQuery.js","../node_modules/apollo-client/util/capitalizeFirstLetter.js","../node_modules/apollo-client/util/observables.js","../node_modules/apollo-client/data/store.js","../node_modules/apollo-client/version.js"],"names":["isScalarValue","value","indexOf","kind","isNumberValue","valueToObjectRepresentation","argObj","name","variables","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","fields","map","obj","isVariable","variableValue","isListValue","values","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","field","directivesObj","directives","forEach","directive","arguments","_a","length","getStoreKeyName","KNOWN_DIRECTIVES","fieldName","args","filterKeys","sort","queryArgs_1","filteredArgs_1","key","JSON","stringify","completeFieldName","stringifiedArgs","Object","keys","argumentsObjectFromField","argObj_1","resultKeyNameFromField","alias","isField","selection","isInlineFragment","isIdValue","idObject","type","generated","toIdValue","idConfig","id","typename","undefined","isJsonValue","jsonObject","defaultValueFromVariable","node","valueFromNode","onVariable","parseInt","parseFloat","v","_i","getDirectiveInfoFromField","directiveObj_1","shouldInclude","getInclusionDirectives","every","ifArgument","evaledValue","getDirectiveNames","doc","names","Directive","push","hasDirectives","some","hasClientExports","document","isInclusionDirective","filter","directiveArguments","ifValue","getFragmentQueryDocument","fragmentName","actualFragmentName","fragments","definitions","definition","operation","selectionSet","selections","assign","target","sources","source","getMutationDefinition","checkDocument","mutationDef","operations","d","getOperationDefinition","getOperationDefinitionOrDie","def","getOperationName","x","getFragmentDefinitions","getQueryDefinition","queryDef","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","fragment","getDefaultValues","variableDefinitions","defaultValues","defaultValue","variable","defaultValueObj","apply","variablesInOperation","Set","add","filterInPlace","array","test","context","elem","i","call","this","TYPENAME_FIELD","nullIfDocIsEmpty","isEmpty","op","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","create","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","parent","Field","remove","arg","getAllFragmentSpreadsFromSelectionSet","allFragments","frag","FragmentSpread","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","hasDirectivesInSelectionSet","nestedCheck","hasDirectivesInSelection","getDirectivesFromDocument","parentPath","_parent","path","currentPath","join","startsWith","selectionsWithDirectives","config","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","FragmentDefinition","buildQueryFromSelectionSet","removeClientSetsFromDocument","canUseWeakMap","WeakMap","navigator","product","toString","prototype","cloneDeep","cloneDeepHelper","val","seen","has","get","copy_1","slice","set","child","copy_2","getPrototypeOf","Map","getEnv","process","isEnv","env","isProduction","isDevelopment","isTest","tryFunctionOrLogError","f","e","console","error","graphQLResultHasError","result","errors","maybeDeepFreeze","Symbol","deepFreeze","o","freeze","getOwnPropertyNames","prop","isFrozen","hasOwnProperty","mergeDeep","mergeDeepArray","count","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","Array","isArray","__proto__","haveWarned","warnOnceInDevelopment","msg","warn","stripSymbols","data","parse","extendStatics","b","setPrototypeOf","p","__extends","__","constructor","__assign","t","s","n","__rest","getOwnPropertySymbols","propertyIsEnumerable","__decorate","decorators","desc","c","r","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","__param","paramIndex","decorator","__metadata","metadataKey","metadataValue","metadata","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","done","then","__generator","body","y","g","_","label","sent","trys","ops","verb","iterator","TypeError","pop","__createBinding","m","k","k2","__exportStar","exports","__values","__read","ar","__spread","concat","__spreadArrays","il","a","j","jl","__await","__asyncGenerator","asyncIterator","q","resume","fulfill","settle","shift","__asyncDelegator","__asyncValues","__makeTemplateObject","cooked","raw","__importStar","mod","__esModule","default","__importDefault","__classPrivateFieldGet","receiver","privateMap","__classPrivateFieldSet","_super","LinkError","message","link","_this","Error","isTerminating","request","toPromise","observable","completed","subscribe","makePromise","fromPromise","promise","observer","complete","catch","bind","fromError","errorValue","createOperation","starting","enumerable","query","operationName","getKey","passthrough","forward","of","toLink","handler","empty","from","links","reduce","split","left","right","leftLink","rightLink","first","second","firstLink","nextLink","ApolloLink","execute","transformedOperation","extensions","transformOperation","OPERATION_FIELDS","validateOperation","NetworkStatus","isNetworkRequestInFlight","networkStatus","Observable","isNonEmptyArray","FetchType","ApolloError","graphQLErrors","networkError","errorMessage","extraInfo","err","graphQLError","replace","generateErrorMessage","ObservableQuery","queryManager","options","_b","shouldSubscribe","onSubscribe","observers","subscriptions","isTornDown","queryId","generateQueryId","opDef","queryName","delete","size","removeQuery","setTimeout","subscription","unsubscribe","currentResult","getCurrentResult","lastResult","lastError","loading","storeValue","policy","getCurrentQueryResult","partial","queryStoreValue","queryStore","fetchPolicy","isNetworkFetchPolicy","errorPolicy","ready","updateLastResult","stale","isDifferentFromLastResult","newResult","snapshot","lastResultSnapshot","getLastResult","getLastError","resetLastResults","resetQueryStoreErrors","refetch","fetchQuery","fetchMore","fetchMoreOptions","updateQuery","combinedOptions","qid","normal","fetchMoreResult","previousResult","stopQuery","subscribeToMore","startGraphQLSubscription","subscriptionData","previous","onError","setOptions","opts","oldFetchPolicy","pollInterval","startPolling","stopPolling","setVariables","fetchResults","tryFetch","mapFn","getQueryWithPreviousResult","dataStore","markUpdateQueryResult","broadcastQueries","stopPollingQuery","assertNotCacheFirstOrOnly","startPollingQuery","assumeImmutableResults","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","setUpQuery","tearDownQuery","addObservableQuery","iterateObserversSafely","observeQuery","previousResult_1","query_1","fetchPolicy_1","transform","getLocalState","addExportedVariables","previousVariables","serverQuery","sub","clear","removeObservableQuery","method","observersWithMethod","obs","obsQuery","MutationStore","store","getStore","mutationId","initMutation","mutation","markMutationError","markMutationResult","reset","QueryStore","initQuery","previousQuery","isSetVariables","storePreviousVariables","isPoll","poll","isRefetch","fetchMoreForQueryId","markQueryResult","markQueryError","markQueryResultClient","observableQueryIds","LocalState","cache","client","resolvers","fragmentMatcher","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","_c","resolveDocument","localResult","getFragmentMatcher","clientQuery","prepareContext","getCacheKey","dataIdFromObject","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","diff","returnPartialData","optimistic","rootValue","mainDefinition","fragmentMap","definitionOperation","defaultOperationType","execContext","str","charAt","toUpperCase","resolveSelectionSet","resultsToMerge","typeCondition","resolveField","fieldResult","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","__typename","resolveSubSelectedArray","item","multiplex","inner","QueryManager","queryDeduplication","onBroadcast","_d","ssrMode","_e","clientAwareness","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","ret","observableQuery","updater","markMutationInit","storeResult","getObservableFromLink","markMutationComplete","refetchQueryPromises","refetchQuery","queryOptions","fetchType","isNetworkOnly","needToFetch","shouldFetch","requestId","cancel","networkResult","updateQueryWatch","lastRequestId","invalidated","invalidate","fetchRequest","getQuery","hasForcedResolvers","newData","queryListenerForObserver","invoke","networkStatusChanged","shouldNotifyIfLoading","notifyOnNetworkStatusChange","hasGraphQLErrors","isMissing","errorStatusChanged","diffResult","resultFromStore","transformed","transformDocument","forLink","transformForLink","cacheEntry_1","defaultVars","watchQuery","transformedOptions","watchedQuery","String","stopQueryInStore","stopQueryInStoreNoBroadcast","addQueryListener","listener","listeners","watch","callback","clearStore","resetIds","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","startQuery","makeObservable","markSubscriptionResult","observablePromise_1","queryIdOrObservable","foundObserveableQuery","info","deduplication","inFlightLinkObservables_1","forceFetch","byVariables_1","varJson_1","cleanup","cleanupSub_1","activeNextCount","asyncMap","errorsFromStore","fqrfId","result_1","prev","newInfo","newContext","checkInFlight","interval","maybeFetch_1","poll_1","clearTimeout","timeout","DataStore","initialCache","ignoreErrors","writeWithErrors","write","dataId","optimistic_1","recordOptimisticTransaction","orig","cacheWrites_1","updateQueries_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","performTransaction","removeOptimistic","ApolloClient","defaultOptions","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","version","disableNetworkFetches","window","__APOLLO_CLIENT__","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","extract","readQuery","readFragment","writeQuery","writeFragment","writeData","__actionHookForDevTools","cb","__requestRaw","payload","initQueryManager","fn","onResetStore","onClearStore","restore","serializedState","setLocalStateFragmentMatcher","tslib_1","apollo_link_1","symbol_observable_1","queryFromPojo","selectionSetFromObj","Cache","justTypenameQuery","ApolloCache","read","rootId","typenameResult","dataToWrite","shouldWarn","answer","HeuristicFragmentMatcher","ensureReady","canBypassInit","match","idValue","isRootQuery","IntrospectionFragmentMatcher","introspectionQueryResultData","possibleTypesMap","parseIntrospectionResult","isReady","implementingTypes","introspectionResultData","typeMap","__schema","types","possibleTypes","implementingType","hasOwn","DepTrackingCache","depend","disposable","makeCacheKey","toObject","dirty","defaultNormalizedCacheFactory","seed","StoreReader","cacheKeyRoot","freezeResults","executeStoreQuery","executeSelectionSet","executeSubSelectedArray","contextValue","variableValues","lookup","readQueryFromStore","diffQueryAgainstStore","fragmentMatcherFunction","queryDefinition","cacheRedirects","execResult","hasMissingFields","missing","tolerable","defaultFragmentMatcher","finalResult","objectsToMerge","object","handleMissing","executeField","fragmentExecResult","readStoreResult","resultKey","storeKeyName","fieldValue","resolver","storeObj","json","readStoreResolver","combineExecResults","assertSelectionSetForIdValue","execResults","childResult","ObjectCache","WriteError","StoreWriter","writeQueryToStore","writeResultToStore","operationDefinition","writeSelectionSetToStore","processedData","enhancedError","stack","enhanceErrorWithDocument","resultFieldKey","writeFieldToStore","isDefered","isClient","matches","fakeContext","storeObject","storeFieldName","generatedId","processArrayValue","valueDataId","isGeneratedId","semanticId","isDataProcessed","escapedId","hadTypename","hasTypename","typenameChanged","mergeWithGenerated","generatedKey","realKey","real","madeChanges","realValue","newRealValue","index","itemDataId","defaultConfig","_id","addTypename","resultCaching","hasOwn$1","OptimisticCacheLayer","optimisticId","transaction","InMemoryCache","watches","typenameDocumentCache","silenceBroadcast","customResolvers","cacheResolvers","optimisticData","storeWriter","storeReader","maybeBroadcastWatch","broadcastWatches","evict","idToRemove","toReapply","removedCount","layer","layer_1","module","formData","file","append","arrays_1","isApolloError","visitor_1","apollo_utilities_1","ts_invariant_1","capitalizeFirstLetter_1","invariant","visit","BREAK","capitalizeFirstLetter","supportsPassiveEvents","passive","noop","addEventListener","removeEventListener","createUploadLink","formDataAppendFile","isExtractableFile","ReactNativeFile","QueryManager_1","LocalState_1","store_1","version_1","InvariantError","fallbackHttpConfig","http","includeQuery","includeExtensions","headers","accept","throwServerError","response","statusCode","status","selectURI","fallbackURI","contextURI","getContext","uri","OperationBatcher","batchInterval","batchMax","batchHandler","batchKey","queuedRequests","enqueueRequest","requestCopy","queued","scheduleQueueConsumption","consumeQueue","requestKey","requests","queuedRequest","forwards","observables","nexts","completes","batchableRequest","batchedObservable","rejecters","results","BatchLink","fetchParams","batcher","BatchHttpLink","fetcher","fetch","requestOptions","checkFetcher","linkConfig","fetchOptions","credentials","contextConfig","chosenURI","clientAwarenessHeaders","name_1","controller","optsAndBody","fallbackConfig","configs","selectHttpOptionsAndBody","loadedBody","serialized","parseError","serializeFetchParameter","signal","AbortController","createSignalIfSupported","_controller","setContext","text","bodyText","parseAndCheckHttpResponse","abort","setter","handle","req","WebSocketLink","paramsOrClient","subscriptionClient","webSocketImpl","errorHandler","retriedSub","retriedResult","ErrorLink","_extends","_require","_require2","rewriteURIForGET","extractFiles","_temp","_ref","_ref$uri","fetchUri","useGETForQueries","_ref$isExtractableFil","customIsExtractableFile","CustomFormData","FormData","_ref$formDataAppendFi","customFormDataAppendFile","customFetch","_context$clientAwaren","_selectHttpOptionsAnd","_extractFiles","clone","files","form","paths","_rewriteURIForGET","newURI","runtimeFetch","cleaningUp","ApolloError_1","Observable_1","mutations_1","queries_1","ObservableQuery_1","networkStatus_1","types_1","observables_1","isEqual","hasError"],"mappings":"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","file":"static/js/defaultVendors~main~c06c607f.f3561e9c.chunk.js","sourcesContent":["import { visit } from 'graphql/language/visitor';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { __assign, __spreadArrays } from 'tslib';\nimport stringify from 'fast-json-stable-stringify';\nexport { equal as isEqual } from '@wry/equality';\n\nfunction isScalarValue(value) {\n    return ['StringValue', 'BooleanValue', 'EnumValue'].indexOf(value.kind) > -1;\n}\nfunction isNumberValue(value) {\n    return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\nfunction isStringValue(value) {\n    return value.kind === 'StringValue';\n}\nfunction isBooleanValue(value) {\n    return value.kind === 'BooleanValue';\n}\nfunction isIntValue(value) {\n    return value.kind === 'IntValue';\n}\nfunction isFloatValue(value) {\n    return value.kind === 'FloatValue';\n}\nfunction isVariable(value) {\n    return value.kind === 'Variable';\n}\nfunction isObjectValue(value) {\n    return value.kind === 'ObjectValue';\n}\nfunction isListValue(value) {\n    return value.kind === 'ListValue';\n}\nfunction isEnumValue(value) {\n    return value.kind === 'EnumValue';\n}\nfunction isNullValue(value) {\n    return value.kind === 'NullValue';\n}\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(17) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.');\n    }\n}\nfunction storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    'connection',\n    'include',\n    'skip',\n    'client',\n    'rest',\n    'export',\n];\nfunction getStoreKeyName(fieldName, args, directives) {\n    if (directives &&\n        directives['connection'] &&\n        directives['connection']['key']) {\n        if (directives['connection']['filter'] &&\n            directives['connection']['filter'].length > 0) {\n            var filterKeys = directives['connection']['filter']\n                ? directives['connection']['filter']\n                : [];\n            filterKeys.sort();\n            var queryArgs_1 = args;\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = queryArgs_1[key];\n            });\n            return directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n        }\n        else {\n            return directives['connection']['key'];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\" + stringifiedArgs + \")\";\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n            }\n            else {\n                completeFieldName += \"@\" + key;\n            }\n        });\n    }\n    return completeFieldName;\n}\nfunction argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nfunction resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nfunction isField(selection) {\n    return selection.kind === 'Field';\n}\nfunction isInlineFragment(selection) {\n    return selection.kind === 'InlineFragment';\n}\nfunction isIdValue(idObject) {\n    return idObject &&\n        idObject.type === 'id' &&\n        typeof idObject.generated === 'boolean';\n}\nfunction toIdValue(idConfig, generated) {\n    if (generated === void 0) { generated = false; }\n    return __assign({ type: 'id', generated: generated }, (typeof idConfig === 'string'\n        ? { id: idConfig, typename: undefined }\n        : idConfig));\n}\nfunction isJsonValue(jsonObject) {\n    return (jsonObject != null &&\n        typeof jsonObject === 'object' &&\n        jsonObject.type === 'json');\n}\nfunction defaultValueFromVariable(node) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(18) : new InvariantError(\"Variable nodes are not supported by valueFromNode\");\n}\nfunction valueFromNode(node, onVariable) {\n    if (onVariable === void 0) { onVariable = defaultValueFromVariable; }\n    switch (node.kind) {\n        case 'Variable':\n            return onVariable(node);\n        case 'NullValue':\n            return null;\n        case 'IntValue':\n            return parseInt(node.value, 10);\n        case 'FloatValue':\n            return parseFloat(node.value);\n        case 'ListValue':\n            return node.values.map(function (v) { return valueFromNode(v, onVariable); });\n        case 'ObjectValue': {\n            var value = {};\n            for (var _i = 0, _a = node.fields; _i < _a.length; _i++) {\n                var field = _a[_i];\n                value[field.name.value] = valueFromNode(field.value, onVariable);\n            }\n            return value;\n        }\n        default:\n            return node.value;\n    }\n}\n\nfunction getDirectiveInfoFromField(field, variables) {\n    if (field.directives && field.directives.length) {\n        var directiveObj_1 = {};\n        field.directives.forEach(function (directive) {\n            directiveObj_1[directive.name.value] = argumentsObjectFromField(directive, variables);\n        });\n        return directiveObj_1;\n    }\n    return null;\n}\nfunction shouldInclude(selection, variables) {\n    if (variables === void 0) { variables = {}; }\n    return getInclusionDirectives(selection.directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === 'Variable') {\n            evaledValue = variables[ifArgument.value.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 13) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\nfunction getDirectiveNames(doc) {\n    var names = [];\n    visit(doc, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nfunction hasDirectives(names, doc) {\n    return getDirectiveNames(doc).some(function (name) { return names.indexOf(name) > -1; });\n}\nfunction hasClientExports(document) {\n    return (document &&\n        hasDirectives(['client'], document) &&\n        hasDirectives(['export'], document));\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\nfunction getInclusionDirectives(directives) {\n    return directives ? directives.filter(isInclusionDirective).map(function (directive) {\n        var directiveArguments = directive.arguments;\n        var directiveName = directive.name.value;\n        process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 14) : invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\" + directiveName + \" directive.\");\n        var ifArgument = directiveArguments[0];\n        process.env.NODE_ENV === \"production\" ? invariant(ifArgument.name && ifArgument.name.value === 'if', 15) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n        var ifValue = ifArgument.value;\n        process.env.NODE_ENV === \"production\" ? invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 16) : invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n        return { directive: directive, ifArgument: ifArgument };\n    }) : [];\n}\n\nfunction getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(11) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 12) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArrays([\n            {\n                kind: 'OperationDefinition',\n                operation: 'query',\n                selectionSet: {\n                    kind: 'SelectionSet',\n                    selections: [\n                        {\n                            kind: 'FragmentSpread',\n                            name: {\n                                kind: 'Name',\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions) });\n    return query;\n}\n\nfunction assign(target) {\n    var sources = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        sources[_i - 1] = arguments[_i];\n    }\n    sources.forEach(function (source) {\n        if (typeof source === 'undefined' || source === null) {\n            return;\n        }\n        Object.keys(source).forEach(function (key) {\n            target[key] = source[key];\n        });\n    });\n    return target;\n}\n\nfunction getMutationDefinition(doc) {\n    checkDocument(doc);\n    var mutationDef = doc.definitions.filter(function (definition) {\n        return definition.kind === 'OperationDefinition' &&\n            definition.operation === 'mutation';\n    })[0];\n    process.env.NODE_ENV === \"production\" ? invariant(mutationDef, 1) : invariant(mutationDef, 'Must contain a mutation definition.');\n    return mutationDef;\n}\nfunction checkDocument(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 2) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(3) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n        }\n        return definition;\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 4) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\n    return doc;\n}\nfunction getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];\n}\nfunction getOperationDefinitionOrDie(document) {\n    var def = getOperationDefinition(document);\n    process.env.NODE_ENV === \"production\" ? invariant(def, 5) : invariant(def, \"GraphQL document is missing an operation\");\n    return def;\n}\nfunction getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === 'OperationDefinition' && definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\nfunction getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });\n}\nfunction getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 6) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n    return queryDef;\n}\nfunction getFragmentDefinition(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 7) : invariant(doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    process.env.NODE_ENV === \"production\" ? invariant(doc.definitions.length <= 1, 8) : invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.');\n    var fragmentDef = doc.definitions[0];\n    process.env.NODE_ENV === \"production\" ? invariant(fragmentDef.kind === 'FragmentDefinition', 9) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\n    return fragmentDef;\n}\nfunction getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === 'OperationDefinition') {\n            var operation = definition.operation;\n            if (operation === 'query' ||\n                operation === 'mutation' ||\n                operation === 'subscription') {\n                return definition;\n            }\n        }\n        if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\n}\nfunction createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nfunction getDefaultValues(definition) {\n    if (definition &&\n        definition.variableDefinitions &&\n        definition.variableDefinitions.length) {\n        var defaultValues = definition.variableDefinitions\n            .filter(function (_a) {\n            var defaultValue = _a.defaultValue;\n            return defaultValue;\n        })\n            .map(function (_a) {\n            var variable = _a.variable, defaultValue = _a.defaultValue;\n            var defaultValueObj = {};\n            valueToObjectRepresentation(defaultValueObj, variable.name, defaultValue);\n            return defaultValueObj;\n        });\n        return assign.apply(void 0, __spreadArrays([{}], defaultValues));\n    }\n    return {};\n}\nfunction variablesInOperation(operation) {\n    var names = new Set();\n    if (operation.variableDefinitions) {\n        for (var _i = 0, _a = operation.variableDefinitions; _i < _a.length; _i++) {\n            var definition = _a[_i];\n            names.add(definition.variable.name.value);\n        }\n    }\n    return names;\n}\n\nfunction filterInPlace(array, test, context) {\n    var target = 0;\n    array.forEach(function (elem, i) {\n        if (test.call(this, elem, i, array)) {\n            array[target++] = elem;\n        }\n    }, context);\n    array.length = target;\n    return array;\n}\n\nvar TYPENAME_FIELD = {\n    kind: 'Field',\n    name: {\n        kind: 'Name',\n        value: '__typename',\n    },\n};\nfunction isEmpty(op, fragments) {\n    return op.selectionSet.selections.every(function (selection) {\n        return selection.kind === 'FragmentSpread' &&\n            isEmpty(fragments[selection.name.value], fragments);\n    });\n}\nfunction nullIfDocIsEmpty(doc) {\n    return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))\n        ? null\n        : doc;\n}\nfunction getDirectiveMatcher(directives) {\n    return function directiveMatcher(directive) {\n        return directives.some(function (dir) {\n            return (dir.name && dir.name === directive.name.value) ||\n                (dir.test && dir.test(directive));\n        });\n    };\n}\nfunction removeDirectivesFromDocument(directives, doc) {\n    var variablesInUse = Object.create(null);\n    var variablesToRemove = [];\n    var fragmentSpreadsInUse = Object.create(null);\n    var fragmentSpreadsToRemove = [];\n    var modifiedDoc = nullIfDocIsEmpty(visit(doc, {\n        Variable: {\n            enter: function (node, _key, parent) {\n                if (parent.kind !== 'VariableDefinition') {\n                    variablesInUse[node.name.value] = true;\n                }\n            },\n        },\n        Field: {\n            enter: function (node) {\n                if (directives && node.directives) {\n                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });\n                    if (shouldRemoveField &&\n                        node.directives &&\n                        node.directives.some(getDirectiveMatcher(directives))) {\n                        if (node.arguments) {\n                            node.arguments.forEach(function (arg) {\n                                if (arg.value.kind === 'Variable') {\n                                    variablesToRemove.push({\n                                        name: arg.value.name.value,\n                                    });\n                                }\n                            });\n                        }\n                        if (node.selectionSet) {\n                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                                fragmentSpreadsToRemove.push({\n                                    name: frag.name.value,\n                                });\n                            });\n                        }\n                        return null;\n                    }\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node) {\n                fragmentSpreadsInUse[node.name.value] = true;\n            },\n        },\n        Directive: {\n            enter: function (node) {\n                if (getDirectiveMatcher(directives)(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n    if (modifiedDoc &&\n        filterInPlace(variablesToRemove, function (v) { return !variablesInUse[v.name]; }).length) {\n        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n    }\n    if (modifiedDoc &&\n        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !fragmentSpreadsInUse[fs.name]; })\n            .length) {\n        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n    }\n    return modifiedDoc;\n}\nfunction addTypenameToDocument(doc) {\n    return visit(checkDocument(doc), {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind === 'OperationDefinition') {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === '__typename' ||\n                            selection.name.value.lastIndexOf('__', 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === 'export'; })) {\n                    return;\n                }\n                return __assign(__assign({}, node), { selections: __spreadArrays(selections, [TYPENAME_FIELD]) });\n            },\n        },\n    });\n}\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === 'connection';\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' +\n                    'You may want to use the key parameter to specify a store key.');\n            }\n        }\n        return willRemove;\n    },\n};\nfunction removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    var parentPath;\n    return nullIfDocIsEmpty(visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, _parent, path) {\n                var currentPath = path.join('-');\n                if (!parentPath ||\n                    currentPath === parentPath ||\n                    !currentPath.startsWith(parentPath)) {\n                    if (node.selections) {\n                        var selectionsWithDirectives = node.selections.filter(function (selection) { return hasDirectivesInSelection(directives, selection); });\n                        if (hasDirectivesInSelectionSet(directives, node, false)) {\n                            parentPath = currentPath;\n                        }\n                        return __assign(__assign({}, node), { selections: selectionsWithDirectives });\n                    }\n                    else {\n                        return null;\n                    }\n                }\n            },\n        },\n    }));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === 'Variable' &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nfunction removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                    }) });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    node.arguments.forEach(function (arg) {\n                        if (argMatcher(arg)) {\n                            argMatchCount_1 += 1;\n                        }\n                    });\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nfunction removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n    var allFragments = [];\n    selectionSet.selections.forEach(function (selection) {\n        if ((isField(selection) || isInlineFragment(selection)) &&\n            selection.selectionSet) {\n            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });\n        }\n        else if (selection.kind === 'FragmentSpread') {\n            allFragments.push(selection);\n        }\n    });\n    return allFragments;\n}\nfunction buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === 'query') {\n        return document;\n    }\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: 'query' });\n            },\n        },\n    });\n    return modifiedDoc;\n}\nfunction removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === 'client'; },\n            remove: true,\n        },\n    ], document);\n    if (modifiedDoc) {\n        modifiedDoc = visit(modifiedDoc, {\n            FragmentDefinition: {\n                enter: function (node) {\n                    if (node.selectionSet) {\n                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n                            return isField(selection) && selection.name.value === '__typename';\n                        });\n                        if (isTypenameOnly) {\n                            return null;\n                        }\n                    }\n                },\n            },\n        });\n    }\n    return modifiedDoc;\n}\n\nvar canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&\n    navigator.product === 'ReactNative');\n\nvar toString = Object.prototype.toString;\nfunction cloneDeep(value) {\n    return cloneDeepHelper(value, new Map());\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n\nfunction getEnv() {\n    if (typeof process !== 'undefined' && process.env.NODE_ENV) {\n        return process.env.NODE_ENV;\n    }\n    return 'development';\n}\nfunction isEnv(env) {\n    return getEnv() === env;\n}\nfunction isProduction() {\n    return isEnv('production') === true;\n}\nfunction isDevelopment() {\n    return isEnv('development') === true;\n}\nfunction isTest() {\n    return isEnv('test') === true;\n}\n\nfunction tryFunctionOrLogError(f) {\n    try {\n        return f();\n    }\n    catch (e) {\n        if (console.error) {\n            console.error(e);\n        }\n    }\n}\nfunction graphQLResultHasError(result) {\n    return result.errors && result.errors.length;\n}\n\nfunction deepFreeze(o) {\n    Object.freeze(o);\n    Object.getOwnPropertyNames(o).forEach(function (prop) {\n        if (o[prop] !== null &&\n            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n            !Object.isFrozen(o[prop])) {\n            deepFreeze(o[prop]);\n        }\n    });\n    return o;\n}\nfunction maybeDeepFreeze(obj) {\n    if (isDevelopment() || isTest()) {\n        var symbolIsPolyfilled = typeof Symbol === 'function' && typeof Symbol('') === 'string';\n        if (!symbolIsPolyfilled) {\n            return deepFreeze(obj);\n        }\n    }\n    return obj;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nfunction mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var pastCopies = [];\n        target = shallowCopyForMerge(target, pastCopies);\n        for (var i = 1; i < count; ++i) {\n            target = mergeHelper(target, sources[i], pastCopies);\n        }\n    }\n    return target;\n}\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\nfunction mergeHelper(target, source, pastCopies) {\n    if (isObject(source) && isObject(target)) {\n        if (Object.isExtensible && !Object.isExtensible(target)) {\n            target = shallowCopyForMerge(target, pastCopies);\n        }\n        Object.keys(source).forEach(function (sourceKey) {\n            var sourceValue = source[sourceKey];\n            if (hasOwnProperty.call(target, sourceKey)) {\n                var targetValue = target[sourceKey];\n                if (sourceValue !== targetValue) {\n                    target[sourceKey] = mergeHelper(shallowCopyForMerge(targetValue, pastCopies), sourceValue, pastCopies);\n                }\n            }\n            else {\n                target[sourceKey] = sourceValue;\n            }\n        });\n        return target;\n    }\n    return source;\n}\nfunction shallowCopyForMerge(value, pastCopies) {\n    if (value !== null &&\n        typeof value === 'object' &&\n        pastCopies.indexOf(value) < 0) {\n        if (Array.isArray(value)) {\n            value = value.slice(0);\n        }\n        else {\n            value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n        }\n        pastCopies.push(value);\n    }\n    return value;\n}\n\nvar haveWarned = Object.create({});\nfunction warnOnceInDevelopment(msg, type) {\n    if (type === void 0) { type = 'warn'; }\n    if (!isProduction() && !haveWarned[msg]) {\n        if (!isTest()) {\n            haveWarned[msg] = true;\n        }\n        if (type === 'error') {\n            console.error(msg);\n        }\n        else {\n            console.warn(msg);\n        }\n    }\n}\n\nfunction stripSymbols(data) {\n    return JSON.parse(JSON.stringify(data));\n}\n\nexport { addTypenameToDocument, argumentsObjectFromField, assign, buildQueryFromSelectionSet, canUseWeakMap, checkDocument, cloneDeep, createFragmentMap, getDefaultValues, getDirectiveInfoFromField, getDirectiveNames, getDirectivesFromDocument, getEnv, getFragmentDefinition, getFragmentDefinitions, getFragmentQueryDocument, getInclusionDirectives, getMainDefinition, getMutationDefinition, getOperationDefinition, getOperationDefinitionOrDie, getOperationName, getQueryDefinition, getStoreKeyName, graphQLResultHasError, hasClientExports, hasDirectives, isDevelopment, isEnv, isField, isIdValue, isInlineFragment, isJsonValue, isNumberValue, isProduction, isScalarValue, isTest, maybeDeepFreeze, mergeDeep, mergeDeepArray, removeArgumentsFromDocument, removeClientSetsFromDocument, removeConnectionDirectiveFromDocument, removeDirectivesFromDocument, removeFragmentSpreadFromDocument, resultKeyNameFromField, shouldInclude, storeKeyNameFromField, stripSymbols, toIdValue, tryFunctionOrLogError, valueFromNode, valueToObjectRepresentation, variablesInOperation, warnOnceInDevelopment };\n//# sourceMappingURL=bundle.esm.js.map\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import 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","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __extends, __assign, __awaiter, __generator } from 'tslib';\nimport { getOperationDefinition, isEqual, tryFunctionOrLogError, cloneDeep, mergeDeep, hasDirectives, removeClientSetsFromDocument, buildQueryFromSelectionSet, getMainDefinition, getFragmentDefinitions, createFragmentMap, mergeDeepArray, resultKeyNameFromField, argumentsObjectFromField, shouldInclude, isField, isInlineFragment, canUseWeakMap, graphQLResultHasError, removeConnectionDirectiveFromDocument, hasClientExports, getDefaultValues, getOperationName } from 'apollo-utilities';\nimport { Observable as Observable$1, execute, ApolloLink } from 'apollo-link';\nimport $$observable from 'symbol-observable';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { visit, BREAK } from 'graphql/language/visitor';\n\nvar NetworkStatus;\n(function (NetworkStatus) {\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\nfunction isNetworkRequestInFlight(networkStatus) {\n    return networkStatus < 7;\n}\n\nvar Observable = (function (_super) {\n    __extends(Observable, _super);\n    function Observable() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Observable.prototype[$$observable] = function () {\n        return this;\n    };\n    Observable.prototype['@@observable'] = function () {\n        return this;\n    };\n    return Observable;\n}(Observable$1));\n\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n\nfunction isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (isNonEmptyArray(err.graphQLErrors)) {\n        err.graphQLErrors.forEach(function (graphQLError) {\n            var errorMessage = graphQLError\n                ? graphQLError.message\n                : 'Error message not found.';\n            message += \"GraphQL error: \" + errorMessage + \"\\n\";\n        });\n    }\n    if (err.networkError) {\n        message += 'Network error: ' + err.networkError.message + '\\n';\n    }\n    message = message.replace(/\\n$/, '');\n    return message;\n};\nvar ApolloError = (function (_super) {\n    __extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.networkError = networkError || null;\n        if (!errorMessage) {\n            _this.message = generateErrorMessage(_this);\n        }\n        else {\n            _this.message = errorMessage;\n        }\n        _this.extraInfo = extraInfo;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\n\nvar FetchType;\n(function (FetchType) {\n    FetchType[FetchType[\"normal\"] = 1] = \"normal\";\n    FetchType[FetchType[\"refetch\"] = 2] = \"refetch\";\n    FetchType[FetchType[\"poll\"] = 3] = \"poll\";\n})(FetchType || (FetchType = {}));\n\nvar hasError = function (storeValue, policy) {\n    if (policy === void 0) { policy = 'none'; }\n    return storeValue && (storeValue.networkError ||\n        (policy === 'none' && isNonEmptyArray(storeValue.graphQLErrors)));\n};\nvar ObservableQuery = (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, options = _a.options, _b = _a.shouldSubscribe, shouldSubscribe = _b === void 0 ? true : _b;\n        var _this = _super.call(this, function (observer) {\n            return _this.onSubscribe(observer);\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.isTornDown = false;\n        _this.options = options;\n        _this.variables = options.variables || {};\n        _this.queryId = queryManager.generateQueryId();\n        _this.shouldSubscribe = shouldSubscribe;\n        var opDef = getOperationDefinition(options.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        _this.queryManager = queryManager;\n        return _this;\n    }\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    ObservableQuery.prototype.currentResult = function () {\n        var result = this.getCurrentResult();\n        if (result.data === undefined) {\n            result.data = {};\n        }\n        return result;\n    };\n    ObservableQuery.prototype.getCurrentResult = function () {\n        if (this.isTornDown) {\n            var lastResult = this.lastResult;\n            return {\n                data: !this.lastError && lastResult && lastResult.data || void 0,\n                error: this.lastError,\n                loading: false,\n                networkStatus: NetworkStatus.error,\n            };\n        }\n        var _a = this.queryManager.getCurrentQueryResult(this), data = _a.data, partial = _a.partial;\n        var queryStoreValue = this.queryManager.queryStore.get(this.queryId);\n        var result;\n        var fetchPolicy = this.options.fetchPolicy;\n        var isNetworkFetchPolicy = fetchPolicy === 'network-only' ||\n            fetchPolicy === 'no-cache';\n        if (queryStoreValue) {\n            var networkStatus = queryStoreValue.networkStatus;\n            if (hasError(queryStoreValue, this.options.errorPolicy)) {\n                return {\n                    data: void 0,\n                    loading: false,\n                    networkStatus: networkStatus,\n                    error: new ApolloError({\n                        graphQLErrors: queryStoreValue.graphQLErrors,\n                        networkError: queryStoreValue.networkError,\n                    }),\n                };\n            }\n            if (queryStoreValue.variables) {\n                this.options.variables = __assign(__assign({}, this.options.variables), queryStoreValue.variables);\n                this.variables = this.options.variables;\n            }\n            result = {\n                data: data,\n                loading: isNetworkRequestInFlight(networkStatus),\n                networkStatus: networkStatus,\n            };\n            if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {\n                result.errors = queryStoreValue.graphQLErrors;\n            }\n        }\n        else {\n            var loading = isNetworkFetchPolicy ||\n                (partial && fetchPolicy !== 'cache-only');\n            result = {\n                data: data,\n                loading: loading,\n                networkStatus: loading ? NetworkStatus.loading : NetworkStatus.ready,\n            };\n        }\n        if (!partial) {\n            this.updateLastResult(__assign(__assign({}, result), { stale: false }));\n        }\n        return __assign(__assign({}, result), { partial: partial });\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        var snapshot = this.lastResultSnapshot;\n        return !(snapshot &&\n            newResult &&\n            snapshot.networkStatus === newResult.networkStatus &&\n            snapshot.stale === newResult.stale &&\n            isEqual(snapshot.data, newResult.data));\n    };\n    ObservableQuery.prototype.getLastResult = function () {\n        return this.lastResult;\n    };\n    ObservableQuery.prototype.getLastError = function () {\n        return this.lastError;\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.lastResult;\n        delete this.lastResultSnapshot;\n        delete this.lastError;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        var queryStore = this.queryManager.queryStore.get(this.queryId);\n        if (queryStore) {\n            queryStore.networkError = null;\n            queryStore.graphQLErrors = [];\n        }\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === 'cache-only') {\n            return Promise.reject(process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('cache-only fetchPolicy option should not be used together with query refetch.'));\n        }\n        if (fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'cache-and-network') {\n            fetchPolicy = 'network-only';\n        }\n        if (!isEqual(this.variables, variables)) {\n            this.variables = __assign(__assign({}, this.variables), variables);\n        }\n        if (!isEqual(this.options.variables, this.variables)) {\n            this.options.variables = __assign(__assign({}, this.options.variables), this.variables);\n        }\n        return this.queryManager.fetchQuery(this.queryId, __assign(__assign({}, this.options), { fetchPolicy: fetchPolicy }), FetchType.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(fetchMoreOptions.updateQuery, 2) : invariant(fetchMoreOptions.updateQuery, 'updateQuery option is required. This function defines how to update the query data with the new results.');\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), { variables: __assign(__assign({}, this.variables), fetchMoreOptions.variables) }))), { fetchPolicy: 'network-only' });\n        var qid = this.queryManager.generateQueryId();\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, FetchType.normal, this.queryId)\n            .then(function (fetchMoreResult) {\n            _this.updateQuery(function (previousResult) {\n                return fetchMoreOptions.updateQuery(previousResult, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n            });\n            _this.queryManager.stopQuery(qid);\n            return fetchMoreResult;\n        }, function (error) {\n            _this.queryManager.stopQuery(qid);\n            throw error;\n        });\n    };\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                process.env.NODE_ENV === \"production\" || invariant.error('Unhandled GraphQL subscription error', err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (opts) {\n        var oldFetchPolicy = this.options.fetchPolicy;\n        this.options = __assign(__assign({}, this.options), opts);\n        if (opts.pollInterval) {\n            this.startPolling(opts.pollInterval);\n        }\n        else if (opts.pollInterval === 0) {\n            this.stopPolling();\n        }\n        var fetchPolicy = opts.fetchPolicy;\n        return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' ||\n            oldFetchPolicy === 'standby' ||\n            fetchPolicy === 'network-only'), opts.fetchResults);\n    };\n    ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {\n        if (tryFetch === void 0) { tryFetch = false; }\n        if (fetchResults === void 0) { fetchResults = true; }\n        this.isTornDown = false;\n        variables = variables || this.variables;\n        if (!tryFetch && isEqual(variables, this.variables)) {\n            return this.observers.size && fetchResults\n                ? this.result()\n                : Promise.resolve();\n        }\n        this.variables = this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.queryManager.fetchQuery(this.queryId, this.options);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var _a = queryManager.getQueryWithPreviousResult(this.queryId), previousResult = _a.previousResult, variables = _a.variables, document = _a.document;\n        var newResult = tryFunctionOrLogError(function () {\n            return mapFn(previousResult, { variables: variables });\n        });\n        if (newResult) {\n            queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.queryManager.stopPollingQuery(this.queryId);\n        this.options.pollInterval = undefined;\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        assertNotCacheFirstOrOnly(this);\n        this.options.pollInterval = pollInterval;\n        this.queryManager.startPollingQuery(this.options, this.queryId);\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult) {\n        var previousResult = this.lastResult;\n        this.lastResult = newResult;\n        this.lastResultSnapshot = this.queryManager.assumeImmutableResults\n            ? newResult\n            : cloneDeep(newResult);\n        return previousResult;\n    };\n    ObservableQuery.prototype.onSubscribe = function (observer) {\n        var _this = this;\n        try {\n            var subObserver = observer._subscription._observer;\n            if (subObserver && !subObserver.error) {\n                subObserver.error = defaultSubscriptionObserverErrorCallback;\n            }\n        }\n        catch (_a) { }\n        var first = !this.observers.size;\n        this.observers.add(observer);\n        if (observer.next && this.lastResult)\n            observer.next(this.lastResult);\n        if (observer.error && this.lastError)\n            observer.error(this.lastError);\n        if (first) {\n            this.setUpQuery();\n        }\n        return function () {\n            if (_this.observers.delete(observer) && !_this.observers.size) {\n                _this.tearDownQuery();\n            }\n        };\n    };\n    ObservableQuery.prototype.setUpQuery = function () {\n        var _this = this;\n        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;\n        if (this.shouldSubscribe) {\n            queryManager.addObservableQuery(queryId, this);\n        }\n        if (this.options.pollInterval) {\n            assertNotCacheFirstOrOnly(this);\n            queryManager.startPollingQuery(this.options, queryId);\n        }\n        var onError = function (error) {\n            _this.updateLastResult(__assign(__assign({}, _this.lastResult), { errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false }));\n            iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n        };\n        queryManager.observeQuery(queryId, this.options, {\n            next: function (result) {\n                if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n                    var previousResult_1 = _this.updateLastResult(result);\n                    var _a = _this.options, query_1 = _a.query, variables = _a.variables, fetchPolicy_1 = _a.fetchPolicy;\n                    if (queryManager.transform(query_1).hasClientExports) {\n                        queryManager.getLocalState().addExportedVariables(query_1, variables).then(function (variables) {\n                            var previousVariables = _this.variables;\n                            _this.variables = _this.options.variables = variables;\n                            if (!result.loading &&\n                                previousResult_1 &&\n                                fetchPolicy_1 !== 'cache-only' &&\n                                queryManager.transform(query_1).serverQuery &&\n                                !isEqual(previousVariables, variables)) {\n                                _this.refetch();\n                            }\n                            else {\n                                iterateObserversSafely(_this.observers, 'next', result);\n                            }\n                        });\n                    }\n                    else {\n                        iterateObserversSafely(_this.observers, 'next', result);\n                    }\n                }\n            },\n            error: onError,\n        }).catch(onError);\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        var queryManager = this.queryManager;\n        this.isTornDown = true;\n        queryManager.stopPollingQuery(this.queryId);\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        queryManager.removeObservableQuery(this.queryId);\n        queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n    };\n    return ObservableQuery;\n}(Observable));\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\nfunction iterateObserversSafely(observers, method, argument) {\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\nfunction assertNotCacheFirstOrOnly(obsQuery) {\n    var fetchPolicy = obsQuery.options.fetchPolicy;\n    process.env.NODE_ENV === \"production\" ? invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 3) : invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 'Queries that specify the cache-first and cache-only fetchPolicies cannot also be polling queries.');\n}\n\nvar MutationStore = (function () {\n    function MutationStore() {\n        this.store = {};\n    }\n    MutationStore.prototype.getStore = function () {\n        return this.store;\n    };\n    MutationStore.prototype.get = function (mutationId) {\n        return this.store[mutationId];\n    };\n    MutationStore.prototype.initMutation = function (mutationId, mutation, variables) {\n        this.store[mutationId] = {\n            mutation: mutation,\n            variables: variables || {},\n            loading: true,\n            error: null,\n        };\n    };\n    MutationStore.prototype.markMutationError = function (mutationId, error) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = error;\n        }\n    };\n    MutationStore.prototype.markMutationResult = function (mutationId) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = null;\n        }\n    };\n    MutationStore.prototype.reset = function () {\n        this.store = {};\n    };\n    return MutationStore;\n}());\n\nvar QueryStore = (function () {\n    function QueryStore() {\n        this.store = {};\n    }\n    QueryStore.prototype.getStore = function () {\n        return this.store;\n    };\n    QueryStore.prototype.get = function (queryId) {\n        return this.store[queryId];\n    };\n    QueryStore.prototype.initQuery = function (query) {\n        var previousQuery = this.store[query.queryId];\n        process.env.NODE_ENV === \"production\" ? invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 19) : invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 'Internal Error: may not update existing query string in store');\n        var isSetVariables = false;\n        var previousVariables = null;\n        if (query.storePreviousVariables &&\n            previousQuery &&\n            previousQuery.networkStatus !== NetworkStatus.loading) {\n            if (!isEqual(previousQuery.variables, query.variables)) {\n                isSetVariables = true;\n                previousVariables = previousQuery.variables;\n            }\n        }\n        var networkStatus;\n        if (isSetVariables) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        else if (query.isPoll) {\n            networkStatus = NetworkStatus.poll;\n        }\n        else if (query.isRefetch) {\n            networkStatus = NetworkStatus.refetch;\n        }\n        else {\n            networkStatus = NetworkStatus.loading;\n        }\n        var graphQLErrors = [];\n        if (previousQuery && previousQuery.graphQLErrors) {\n            graphQLErrors = previousQuery.graphQLErrors;\n        }\n        this.store[query.queryId] = {\n            document: query.document,\n            variables: query.variables,\n            previousVariables: previousVariables,\n            networkError: null,\n            graphQLErrors: graphQLErrors,\n            networkStatus: networkStatus,\n            metadata: query.metadata,\n        };\n        if (typeof query.fetchMoreForQueryId === 'string' &&\n            this.store[query.fetchMoreForQueryId]) {\n            this.store[query.fetchMoreForQueryId].networkStatus =\n                NetworkStatus.fetchMore;\n        }\n    };\n    QueryStore.prototype.markQueryResult = function (queryId, result, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = null;\n        this.store[queryId].graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];\n        this.store[queryId].previousVariables = null;\n        this.store[queryId].networkStatus = NetworkStatus.ready;\n        if (typeof fetchMoreForQueryId === 'string' &&\n            this.store[fetchMoreForQueryId]) {\n            this.store[fetchMoreForQueryId].networkStatus = NetworkStatus.ready;\n        }\n    };\n    QueryStore.prototype.markQueryError = function (queryId, error, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = error;\n        this.store[queryId].networkStatus = NetworkStatus.error;\n        if (typeof fetchMoreForQueryId === 'string') {\n            this.markQueryResultClient(fetchMoreForQueryId, true);\n        }\n    };\n    QueryStore.prototype.markQueryResultClient = function (queryId, complete) {\n        var storeValue = this.store && this.store[queryId];\n        if (storeValue) {\n            storeValue.networkError = null;\n            storeValue.previousVariables = null;\n            if (complete) {\n                storeValue.networkStatus = NetworkStatus.ready;\n            }\n        }\n    };\n    QueryStore.prototype.stopQuery = function (queryId) {\n        delete this.store[queryId];\n    };\n    QueryStore.prototype.reset = function (observableQueryIds) {\n        var _this = this;\n        Object.keys(this.store).forEach(function (queryId) {\n            if (observableQueryIds.indexOf(queryId) < 0) {\n                _this.stopQuery(queryId);\n            }\n            else {\n                _this.store[queryId].networkStatus = NetworkStatus.loading;\n            }\n        });\n    };\n    return QueryStore;\n}());\n\nfunction capitalizeFirstLetter(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nvar LocalState = (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    LocalState.prototype.runResolvers = function (_a) {\n        var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_c) {\n                if (document) {\n                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives(['client'], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n            process.env.NODE_ENV === \"production\" || invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' +\n                'were specified. This means ApolloClient local resolver handling ' +\n                'has been disabled, and @client directives will be passed through ' +\n                'to your link chain.');\n        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return this.resolvers ? removeClientSetsFromDocument(document) : document;\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var cache = this.cache;\n        var newContext = __assign(__assign({}, context), { cache: cache, getCacheKey: function (obj) {\n                if (cache.config) {\n                    return cache.config.dataIdFromObject(obj);\n                }\n                else {\n                    process.env.NODE_ENV === \"production\" ? invariant(false, 6) : invariant(false, 'To use context.getCacheKey, you need to use a cache that has ' +\n                        'a configurable dataIdFromObject, like apollo-cache-inmemory.');\n                }\n            } });\n        return newContext;\n    };\n    LocalState.prototype.addExportedVariables = function (document, variables, context) {\n        if (variables === void 0) { variables = {}; }\n        if (context === void 0) { context = {}; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === 'client' && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === 'always' &&\n                                arg.value.kind === 'BooleanValue' &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n        if (context === void 0) { context = {}; }\n        if (variables === void 0) { variables = {}; }\n        if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n        if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n        return __awaiter(this, void 0, void 0, function () {\n            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                definitionOperation = mainDefinition\n                    .operation;\n                defaultOperationType = definitionOperation\n                    ? capitalizeFirstLetter(definitionOperation)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache,\n                        client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (isField(selection)) {\n                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== 'undefined') {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            process.env.NODE_ENV === \"production\" ? invariant(fragment, 7) : invariant(fragment, \"No fragment named \" + selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2];\n                    });\n                }); };\n                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(resolve(rootValue, argumentsObjectFromField(field, variables), execContext.context, { field: field, fragmentMap: execContext.fragmentMap }));\n                        }\n                    }\n                }\n                return [2, resultPromise.then(function (result) {\n                        if (result === void 0) { result = defaultResult; }\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === 'export' && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        if (result == null) {\n                            return result;\n                        }\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, result, execContext);\n                        }\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, item, execContext);\n            }\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n            }\n        }));\n    };\n    return LocalState;\n}());\n\nfunction multiplex(inner) {\n    var observers = new Set();\n    var sub = null;\n    return new Observable(function (observer) {\n        observers.add(observer);\n        sub = sub || inner.subscribe({\n            next: function (value) {\n                observers.forEach(function (obs) { return obs.next && obs.next(value); });\n            },\n            error: function (error) {\n                observers.forEach(function (obs) { return obs.error && obs.error(error); });\n            },\n            complete: function () {\n                observers.forEach(function (obs) { return obs.complete && obs.complete(); });\n            },\n        });\n        return function () {\n            if (observers.delete(observer) && !observers.size && sub) {\n                sub.unsubscribe();\n                sub = null;\n            }\n        };\n    });\n}\nfunction asyncMap(observable, mapFn) {\n    return new Observable(function (observer) {\n        var next = observer.next, error = observer.error, complete = observer.complete;\n        var activeNextCount = 0;\n        var completed = false;\n        var handler = {\n            next: function (value) {\n                ++activeNextCount;\n                new Promise(function (resolve) {\n                    resolve(mapFn(value));\n                }).then(function (result) {\n                    --activeNextCount;\n                    next && next.call(observer, result);\n                    completed && handler.complete();\n                }, function (e) {\n                    --activeNextCount;\n                    error && error.call(observer, e);\n                });\n            },\n            error: function (e) {\n                error && error.call(observer, e);\n            },\n            complete: function () {\n                completed = true;\n                if (!activeNextCount) {\n                    complete && complete.call(observer);\n                }\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = (function () {\n    function QueryManager(_a) {\n        var link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, store = _a.store, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;\n        this.mutationStore = new MutationStore();\n        this.queryStore = new QueryStore();\n        this.clientAwareness = {};\n        this.idCounter = 1;\n        this.queries = new Map();\n        this.fetchQueryRejectFns = new Map();\n        this.transformCache = new (canUseWeakMap ? WeakMap : Map)();\n        this.inFlightLinkObservables = new Map();\n        this.pollingInfoByQueryId = new Map();\n        this.link = link;\n        this.queryDeduplication = queryDeduplication;\n        this.dataStore = store;\n        this.onBroadcast = onBroadcast;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: store.getCache() });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = !!assumeImmutableResults;\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError('QueryManager stopped while query was in flight'));\n        });\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, generateUpdateQueriesInfo, self;\n            var _this = this;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        process.env.NODE_ENV === \"production\" ? invariant(mutation, 9) : invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        process.env.NODE_ENV === \"production\" ? invariant(!fetchPolicy || fetchPolicy === 'no-cache', 10) : invariant(!fetchPolicy || fetchPolicy === 'no-cache', \"Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.\");\n                        mutationId = this.generateQueryId();\n                        mutation = this.transform(mutation).document;\n                        this.setQuery(mutationId, function () { return ({ document: mutation }); });\n                        variables = this.getVariables(mutation, variables);\n                        if (!this.transform(mutation).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = _f.sent();\n                        _f.label = 2;\n                    case 2:\n                        generateUpdateQueriesInfo = function () {\n                            var ret = {};\n                            if (updateQueriesByName) {\n                                _this.queries.forEach(function (_a, queryId) {\n                                    var observableQuery = _a.observableQuery;\n                                    if (observableQuery) {\n                                        var queryName = observableQuery.queryName;\n                                        if (queryName &&\n                                            hasOwnProperty.call(updateQueriesByName, queryName)) {\n                                            ret[queryId] = {\n                                                updater: updateQueriesByName[queryName],\n                                                query: _this.queryStore.get(queryId),\n                                            };\n                                        }\n                                    }\n                                });\n                            }\n                            return ret;\n                        };\n                        this.mutationStore.initMutation(mutationId, mutation, variables);\n                        this.dataStore.markMutationInit({\n                            mutationId: mutationId,\n                            document: mutation,\n                            variables: variables,\n                            updateQueries: generateUpdateQueriesInfo(),\n                            update: updateWithProxyFn,\n                            optimisticResponse: optimisticResponse,\n                        });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                var storeResult;\n                                var error;\n                                self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError({\n                                                graphQLErrors: result.errors,\n                                            });\n                                            return;\n                                        }\n                                        self.mutationStore.markMutationResult(mutationId);\n                                        if (fetchPolicy !== 'no-cache') {\n                                            self.dataStore.markMutationResult({\n                                                mutationId: mutationId,\n                                                result: result,\n                                                document: mutation,\n                                                variables: variables,\n                                                updateQueries: generateUpdateQueriesInfo(),\n                                                update: updateWithProxyFn,\n                                            });\n                                        }\n                                        storeResult = result;\n                                    },\n                                    error: function (err) {\n                                        self.mutationStore.markMutationError(mutationId, err);\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        self.setQuery(mutationId, function () { return ({ document: null }); });\n                                        reject(new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                    complete: function () {\n                                        if (error) {\n                                            self.mutationStore.markMutationError(mutationId, error);\n                                        }\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        if (error) {\n                                            reject(error);\n                                            return;\n                                        }\n                                        if (typeof refetchQueries === 'function') {\n                                            refetchQueries = refetchQueries(storeResult);\n                                        }\n                                        var refetchQueryPromises = [];\n                                        if (isNonEmptyArray(refetchQueries)) {\n                                            refetchQueries.forEach(function (refetchQuery) {\n                                                if (typeof refetchQuery === 'string') {\n                                                    self.queries.forEach(function (_a) {\n                                                        var observableQuery = _a.observableQuery;\n                                                        if (observableQuery &&\n                                                            observableQuery.queryName === refetchQuery) {\n                                                            refetchQueryPromises.push(observableQuery.refetch());\n                                                        }\n                                                    });\n                                                }\n                                                else {\n                                                    var queryOptions = {\n                                                        query: refetchQuery.query,\n                                                        variables: refetchQuery.variables,\n                                                        fetchPolicy: 'network-only',\n                                                    };\n                                                    if (refetchQuery.context) {\n                                                        queryOptions.context = refetchQuery.context;\n                                                    }\n                                                    refetchQueryPromises.push(self.query(queryOptions));\n                                                }\n                                            });\n                                        }\n                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                                            self.setQuery(mutationId, function () { return ({ document: null }); });\n                                            if (errorPolicy === 'ignore' &&\n                                                storeResult &&\n                                                graphQLResultHasError(storeResult)) {\n                                                delete storeResult.errors;\n                                            }\n                                            resolve(storeResult);\n                                        });\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, fetchType, fetchMoreForQueryId) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, metadata, _b, fetchPolicy, _c, context, query, variables, storeResult, isNetworkOnly, needToFetch, _d, complete, result, shouldFetch, requestId, cancel, networkResult;\n            var _this = this;\n            return __generator(this, function (_e) {\n                switch (_e.label) {\n                    case 0:\n                        _a = options.metadata, metadata = _a === void 0 ? null : _a, _b = options.fetchPolicy, fetchPolicy = _b === void 0 ? 'cache-first' : _b, _c = options.context, context = _c === void 0 ? {} : _c;\n                        query = this.transform(options.query).document;\n                        variables = this.getVariables(query, options.variables);\n                        if (!this.transform(query).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(query, variables, context)];\n                    case 1:\n                        variables = _e.sent();\n                        _e.label = 2;\n                    case 2:\n                        options = __assign(__assign({}, options), { variables: variables });\n                        isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n                        needToFetch = isNetworkOnly;\n                        if (!isNetworkOnly) {\n                            _d = this.dataStore.getCache().diff({\n                                query: query,\n                                variables: variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }), complete = _d.complete, result = _d.result;\n                            needToFetch = !complete || fetchPolicy === 'cache-and-network';\n                            storeResult = result;\n                        }\n                        shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';\n                        if (hasDirectives(['live'], query))\n                            shouldFetch = true;\n                        requestId = this.idCounter++;\n                        cancel = fetchPolicy !== 'no-cache'\n                            ? this.updateQueryWatch(queryId, query, options)\n                            : undefined;\n                        this.setQuery(queryId, function () { return ({\n                            document: query,\n                            lastRequestId: requestId,\n                            invalidated: true,\n                            cancel: cancel,\n                        }); });\n                        this.invalidate(fetchMoreForQueryId);\n                        this.queryStore.initQuery({\n                            queryId: queryId,\n                            document: query,\n                            storePreviousVariables: shouldFetch,\n                            variables: variables,\n                            isPoll: fetchType === FetchType.poll,\n                            isRefetch: fetchType === FetchType.refetch,\n                            metadata: metadata,\n                            fetchMoreForQueryId: fetchMoreForQueryId,\n                        });\n                        this.broadcastQueries();\n                        if (shouldFetch) {\n                            networkResult = this.fetchRequest({\n                                requestId: requestId,\n                                queryId: queryId,\n                                document: query,\n                                options: options,\n                                fetchMoreForQueryId: fetchMoreForQueryId,\n                            }).catch(function (error) {\n                                if (isApolloError(error)) {\n                                    throw error;\n                                }\n                                else {\n                                    if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                                        _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);\n                                        _this.invalidate(queryId);\n                                        _this.invalidate(fetchMoreForQueryId);\n                                        _this.broadcastQueries();\n                                    }\n                                    throw new ApolloError({ networkError: error });\n                                }\n                            });\n                            if (fetchPolicy !== 'cache-and-network') {\n                                return [2, networkResult];\n                            }\n                            networkResult.catch(function () { });\n                        }\n                        this.queryStore.markQueryResultClient(queryId, !shouldFetch);\n                        this.invalidate(queryId);\n                        this.invalidate(fetchMoreForQueryId);\n                        if (this.transform(query).hasForcedResolvers) {\n                            return [2, this.localState.runResolvers({\n                                    document: query,\n                                    remoteResult: { data: storeResult },\n                                    context: context,\n                                    variables: variables,\n                                    onlyRunForcedResolvers: true,\n                                }).then(function (result) {\n                                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                                    _this.broadcastQueries();\n                                    return result;\n                                })];\n                        }\n                        this.broadcastQueries();\n                        return [2, { data: storeResult }];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {\n        var fetchPolicy = _a.fetchPolicy, variables = _a.variables, errorPolicy = _a.errorPolicy;\n        if (fetchPolicy === 'no-cache') {\n            this.setQuery(queryId, function () { return ({\n                newData: { result: result.data, complete: true },\n            }); });\n        }\n        else {\n            this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');\n        }\n    };\n    QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {\n        var _this = this;\n        function invoke(method, argument) {\n            if (observer[method]) {\n                try {\n                    observer[method](argument);\n                }\n                catch (e) {\n                    process.env.NODE_ENV === \"production\" || invariant.error(e);\n                }\n            }\n            else if (method === 'error') {\n                process.env.NODE_ENV === \"production\" || invariant.error(argument);\n            }\n        }\n        return function (queryStoreValue, newData) {\n            _this.invalidate(queryId, false);\n            if (!queryStoreValue)\n                return;\n            var _a = _this.getQuery(queryId), observableQuery = _a.observableQuery, document = _a.document;\n            var fetchPolicy = observableQuery\n                ? observableQuery.options.fetchPolicy\n                : options.fetchPolicy;\n            if (fetchPolicy === 'standby')\n                return;\n            var loading = isNetworkRequestInFlight(queryStoreValue.networkStatus);\n            var lastResult = observableQuery && observableQuery.getLastResult();\n            var networkStatusChanged = !!(lastResult &&\n                lastResult.networkStatus !== queryStoreValue.networkStatus);\n            var shouldNotifyIfLoading = options.returnPartialData ||\n                (!newData && queryStoreValue.previousVariables) ||\n                (networkStatusChanged && options.notifyOnNetworkStatusChange) ||\n                fetchPolicy === 'cache-only' ||\n                fetchPolicy === 'cache-and-network';\n            if (loading && !shouldNotifyIfLoading) {\n                return;\n            }\n            var hasGraphQLErrors = isNonEmptyArray(queryStoreValue.graphQLErrors);\n            var errorPolicy = observableQuery\n                && observableQuery.options.errorPolicy\n                || options.errorPolicy\n                || 'none';\n            if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {\n                return invoke('error', new ApolloError({\n                    graphQLErrors: queryStoreValue.graphQLErrors,\n                    networkError: queryStoreValue.networkError,\n                }));\n            }\n            try {\n                var data = void 0;\n                var isMissing = void 0;\n                if (newData) {\n                    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {\n                        _this.setQuery(queryId, function () { return ({ newData: null }); });\n                    }\n                    data = newData.result;\n                    isMissing = !newData.complete;\n                }\n                else {\n                    var lastError = observableQuery && observableQuery.getLastError();\n                    var errorStatusChanged = errorPolicy !== 'none' &&\n                        (lastError && lastError.graphQLErrors) !==\n                            queryStoreValue.graphQLErrors;\n                    if (lastResult && lastResult.data && !errorStatusChanged) {\n                        data = lastResult.data;\n                        isMissing = false;\n                    }\n                    else {\n                        var diffResult = _this.dataStore.getCache().diff({\n                            query: document,\n                            variables: queryStoreValue.previousVariables ||\n                                queryStoreValue.variables,\n                            returnPartialData: true,\n                            optimistic: true,\n                        });\n                        data = diffResult.result;\n                        isMissing = !diffResult.complete;\n                    }\n                }\n                var stale = isMissing && !(options.returnPartialData ||\n                    fetchPolicy === 'cache-only');\n                var resultFromStore = {\n                    data: stale ? lastResult && lastResult.data : data,\n                    loading: loading,\n                    networkStatus: queryStoreValue.networkStatus,\n                    stale: stale,\n                };\n                if (errorPolicy === 'all' && hasGraphQLErrors) {\n                    resultFromStore.errors = queryStoreValue.graphQLErrors;\n                }\n                invoke('next', resultFromStore);\n            }\n            catch (networkError) {\n                invoke('error', new ApolloError({ networkError: networkError }));\n            }\n        };\n    };\n    QueryManager.prototype.transform = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cache = this.dataStore.getCache();\n            var transformed = cache.transformDocument(document);\n            var forLink = removeConnectionDirectiveFromDocument(cache.transformForLink(transformed));\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = this.localState.serverQuery(forLink);\n            var cacheEntry_1 = {\n                document: transformed,\n                hasClientExports: hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: getDefaultValues(getOperationDefinition(transformed)),\n            };\n            var add = function (doc) {\n                if (doc && !transformCache.has(doc)) {\n                    transformCache.set(doc, cacheEntry_1);\n                }\n            };\n            add(document);\n            add(transformed);\n            add(clientQuery);\n            add(serverQuery);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n        if (shouldSubscribe === void 0) { shouldSubscribe = true; }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'standby', 11) : invariant(options.fetchPolicy !== 'standby', 'client.watchQuery cannot be called with fetchPolicy set to \"standby\"');\n        options.variables = this.getVariables(options.query, options.variables);\n        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var transformedOptions = __assign({}, options);\n        return new ObservableQuery({\n            queryManager: this,\n            options: transformedOptions,\n            shouldSubscribe: shouldSubscribe,\n        });\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(options.query, 12) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        process.env.NODE_ENV === \"production\" ? invariant(options.query.kind === 'Document', 13) : invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.returnPartialData, 14) : invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.pollInterval, 15) : invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');\n        return new Promise(function (resolve, reject) {\n            var watchedQuery = _this.watchQuery(options, false);\n            _this.fetchQueryRejectFns.set(\"query:\" + watchedQuery.queryId, reject);\n            watchedQuery\n                .result()\n                .then(resolve, reject)\n                .then(function () {\n                return _this.fetchQueryRejectFns.delete(\"query:\" + watchedQuery.queryId);\n            });\n        });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.idCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        this.stopPollingQuery(queryId);\n        this.queryStore.stopQuery(queryId);\n        this.invalidate(queryId);\n    };\n    QueryManager.prototype.addQueryListener = function (queryId, listener) {\n        this.setQuery(queryId, function (_a) {\n            var listeners = _a.listeners;\n            listeners.add(listener);\n            return { invalidated: false };\n        });\n    };\n    QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {\n        var _this = this;\n        var cancel = this.getQuery(queryId).cancel;\n        if (cancel)\n            cancel();\n        var previousResult = function () {\n            var previousResult = null;\n            var observableQuery = _this.getQuery(queryId).observableQuery;\n            if (observableQuery) {\n                var lastResult = observableQuery.getLastResult();\n                if (lastResult) {\n                    previousResult = lastResult.data;\n                }\n            }\n            return previousResult;\n        };\n        return this.dataStore.getCache().watch({\n            query: document,\n            variables: options.variables,\n            optimistic: true,\n            previousResult: previousResult,\n            callback: function (newData) {\n                _this.setQuery(queryId, function () { return ({ invalidated: true, newData: newData }); });\n            },\n        });\n    };\n    QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {\n        this.setQuery(queryId, function () { return ({ observableQuery: observableQuery }); });\n    };\n    QueryManager.prototype.removeObservableQuery = function (queryId) {\n        var cancel = this.getQuery(queryId).cancel;\n        this.setQuery(queryId, function () { return ({ observableQuery: null }); });\n        if (cancel)\n            cancel();\n    };\n    QueryManager.prototype.clearStore = function () {\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(16) : new InvariantError('Store reset while query was in flight (not completed in link chain)'));\n        });\n        var resetIds = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery)\n                resetIds.push(queryId);\n        });\n        this.queryStore.reset(resetIds);\n        this.mutationStore.reset();\n        return this.dataStore.reset();\n    };\n    QueryManager.prototype.resetStore = function () {\n        var _this = this;\n        return this.clearStore().then(function () {\n            return _this.reFetchObservableQueries();\n        });\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery) {\n                var fetchPolicy = observableQuery.options.fetchPolicy;\n                observableQuery.resetLastResults();\n                if (fetchPolicy !== 'cache-only' &&\n                    (includeStandby || fetchPolicy !== 'standby')) {\n                    observableQueryPromises.push(observableQuery.refetch());\n                }\n                _this.setQuery(queryId, function () { return ({ newData: null }); });\n                _this.invalidate(queryId);\n            }\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.observeQuery = function (queryId, options, observer) {\n        this.addQueryListener(queryId, this.queryListenerForObserver(queryId, options, observer));\n        return this.fetchQuery(queryId, options);\n    };\n    QueryManager.prototype.startQuery = function (queryId, options, listener) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"The QueryManager.startQuery method has been deprecated\");\n        this.addQueryListener(queryId, listener);\n        this.fetchQuery(queryId, options)\n            .catch(function () { return undefined; });\n        return queryId;\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables;\n        query = this.transform(query).document;\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, {}, variables, false).map(function (result) {\n                if (!fetchPolicy || fetchPolicy !== 'no-cache') {\n                    _this.dataStore.markSubscriptionResult(result, query, variables);\n                    _this.broadcastQueries();\n                }\n                if (graphQLResultHasError(result)) {\n                    throw new ApolloError({\n                        graphQLErrors: result.errors,\n                    });\n                }\n                return result;\n            });\n        };\n        if (this.transform(query).hasClientExports) {\n            var observablePromise_1 = this.localState.addExportedVariables(query, variables).then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        this.fetchQueryRejectFns.delete(\"query:\" + queryId);\n        this.fetchQueryRejectFns.delete(\"fetchRequest:\" + queryId);\n        this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });\n        this.queries.delete(queryId);\n    };\n    QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {\n        if (optimistic === void 0) { optimistic = true; }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query, fetchPolicy = _a.fetchPolicy, returnPartialData = _a.returnPartialData;\n        var lastResult = observableQuery.getLastResult();\n        var newData = this.getQuery(observableQuery.queryId).newData;\n        if (newData && newData.complete) {\n            return { data: newData.result, partial: false };\n        }\n        if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {\n            return { data: undefined, partial: false };\n        }\n        var _b = this.dataStore.getCache().diff({\n            query: query,\n            variables: variables,\n            previousResult: lastResult ? lastResult.data : undefined,\n            returnPartialData: true,\n            optimistic: optimistic,\n        }), result = _b.result, complete = _b.complete;\n        return {\n            data: (complete || returnPartialData) ? result : void 0,\n            partial: !complete,\n        };\n    };\n    QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {\n        var observableQuery;\n        if (typeof queryIdOrObservable === 'string') {\n            var foundObserveableQuery = this.getQuery(queryIdOrObservable).observableQuery;\n            process.env.NODE_ENV === \"production\" ? invariant(foundObserveableQuery, 17) : invariant(foundObserveableQuery, \"ObservableQuery with this id doesn't exist: \" + queryIdOrObservable);\n            observableQuery = foundObserveableQuery;\n        }\n        else {\n            observableQuery = queryIdOrObservable;\n        }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query;\n        return {\n            previousResult: this.getCurrentQueryResult(observableQuery, false).data,\n            variables: variables,\n            document: query,\n        };\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        var _this = this;\n        this.onBroadcast();\n        this.queries.forEach(function (info, id) {\n            if (info.invalidated) {\n                info.listeners.forEach(function (listener) {\n                    if (listener) {\n                        listener(_this.queryStore.get(id), info.newData);\n                    }\n                });\n            }\n        });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n        var _this = this;\n        if (deduplication === void 0) { deduplication = this.queryDeduplication; }\n        var observable;\n        var serverQuery = this.transform(query).serverQuery;\n        if (serverQuery) {\n            var _a = this, inFlightLinkObservables_1 = _a.inFlightLinkObservables, link = _a.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n            };\n            context = operation.context;\n            if (deduplication) {\n                var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();\n                inFlightLinkObservables_1.set(serverQuery, byVariables_1);\n                var varJson_1 = JSON.stringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    byVariables_1.set(varJson_1, observable = multiplex(execute(link, operation)));\n                    var cleanup = function () {\n                        byVariables_1.delete(varJson_1);\n                        if (!byVariables_1.size)\n                            inFlightLinkObservables_1.delete(serverQuery);\n                        cleanupSub_1.unsubscribe();\n                    };\n                    var cleanupSub_1 = observable.subscribe({\n                        next: cleanup,\n                        error: cleanup,\n                        complete: cleanup,\n                    });\n                }\n            }\n            else {\n                observable = multiplex(execute(link, operation));\n            }\n        }\n        else {\n            observable = Observable.of({ data: {} });\n            context = this.prepareContext(context);\n        }\n        var clientQuery = this.transform(query).clientQuery;\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.fetchRequest = function (_a) {\n        var _this = this;\n        var requestId = _a.requestId, queryId = _a.queryId, document = _a.document, options = _a.options, fetchMoreForQueryId = _a.fetchMoreForQueryId;\n        var variables = options.variables, _b = options.errorPolicy, errorPolicy = _b === void 0 ? 'none' : _b, fetchPolicy = options.fetchPolicy;\n        var resultFromStore;\n        var errorsFromStore;\n        return new Promise(function (resolve, reject) {\n            var observable = _this.getObservableFromLink(document, options.context, variables);\n            var fqrfId = \"fetchRequest:\" + queryId;\n            _this.fetchQueryRejectFns.set(fqrfId, reject);\n            var cleanup = function () {\n                _this.fetchQueryRejectFns.delete(fqrfId);\n                _this.setQuery(queryId, function (_a) {\n                    var subscriptions = _a.subscriptions;\n                    subscriptions.delete(subscription);\n                });\n            };\n            var subscription = observable.map(function (result) {\n                if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                    _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);\n                    _this.invalidate(queryId);\n                    _this.invalidate(fetchMoreForQueryId);\n                    _this.broadcastQueries();\n                }\n                if (errorPolicy === 'none' && isNonEmptyArray(result.errors)) {\n                    return reject(new ApolloError({\n                        graphQLErrors: result.errors,\n                    }));\n                }\n                if (errorPolicy === 'all') {\n                    errorsFromStore = result.errors;\n                }\n                if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {\n                    resultFromStore = result.data;\n                }\n                else {\n                    var _a = _this.dataStore.getCache().diff({\n                        variables: variables,\n                        query: document,\n                        optimistic: false,\n                        returnPartialData: true,\n                    }), result_1 = _a.result, complete = _a.complete;\n                    if (complete || options.returnPartialData) {\n                        resultFromStore = result_1;\n                    }\n                }\n            }).subscribe({\n                error: function (error) {\n                    cleanup();\n                    reject(error);\n                },\n                complete: function () {\n                    cleanup();\n                    resolve({\n                        data: resultFromStore,\n                        errors: errorsFromStore,\n                        loading: false,\n                        networkStatus: NetworkStatus.ready,\n                        stale: false,\n                    });\n                },\n            });\n            _this.setQuery(queryId, function (_a) {\n                var subscriptions = _a.subscriptions;\n                subscriptions.add(subscription);\n            });\n        });\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        return (this.queries.get(queryId) || {\n            listeners: new Set(),\n            invalidated: false,\n            document: null,\n            newData: null,\n            lastRequestId: 1,\n            observableQuery: null,\n            subscriptions: new Set(),\n        });\n    };\n    QueryManager.prototype.setQuery = function (queryId, updater) {\n        var prev = this.getQuery(queryId);\n        var newInfo = __assign(__assign({}, prev), updater(prev));\n        this.queries.set(queryId, newInfo);\n    };\n    QueryManager.prototype.invalidate = function (queryId, invalidated) {\n        if (invalidated === void 0) { invalidated = true; }\n        if (queryId) {\n            this.setQuery(queryId, function () { return ({ invalidated: invalidated }); });\n        }\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign({}, newContext), { clientAwareness: this.clientAwareness });\n    };\n    QueryManager.prototype.checkInFlight = function (queryId) {\n        var query = this.queryStore.get(queryId);\n        return (query &&\n            query.networkStatus !== NetworkStatus.ready &&\n            query.networkStatus !== NetworkStatus.error);\n    };\n    QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n        var _this = this;\n        var pollInterval = options.pollInterval;\n        process.env.NODE_ENV === \"production\" ? invariant(pollInterval, 18) : invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');\n        if (!this.ssrMode) {\n            var info = this.pollingInfoByQueryId.get(queryId);\n            if (!info) {\n                this.pollingInfoByQueryId.set(queryId, (info = {}));\n            }\n            info.interval = pollInterval;\n            info.options = __assign(__assign({}, options), { fetchPolicy: 'network-only' });\n            var maybeFetch_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    if (_this.checkInFlight(queryId)) {\n                        poll_1();\n                    }\n                    else {\n                        _this.fetchQuery(queryId, info.options, FetchType.poll).then(poll_1, poll_1);\n                    }\n                }\n            };\n            var poll_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    clearTimeout(info.timeout);\n                    info.timeout = setTimeout(maybeFetch_1, info.interval);\n                }\n            };\n            if (listener) {\n                this.addQueryListener(queryId, listener);\n            }\n            poll_1();\n        }\n        return queryId;\n    };\n    QueryManager.prototype.stopPollingQuery = function (queryId) {\n        this.pollingInfoByQueryId.delete(queryId);\n    };\n    return QueryManager;\n}());\n\nvar DataStore = (function () {\n    function DataStore(initialCache) {\n        this.cache = initialCache;\n    }\n    DataStore.prototype.getCache = function () {\n        return this.cache;\n    };\n    DataStore.prototype.markQueryResult = function (result, document, variables, fetchMoreForQueryId, ignoreErrors) {\n        if (ignoreErrors === void 0) { ignoreErrors = false; }\n        var writeWithErrors = !graphQLResultHasError(result);\n        if (ignoreErrors && graphQLResultHasError(result) && result.data) {\n            writeWithErrors = true;\n        }\n        if (!fetchMoreForQueryId && writeWithErrors) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_QUERY',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markSubscriptionResult = function (result, document, variables) {\n        if (!graphQLResultHasError(result)) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_SUBSCRIPTION',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markMutationInit = function (mutation) {\n        var _this = this;\n        if (mutation.optimisticResponse) {\n            var optimistic_1;\n            if (typeof mutation.optimisticResponse === 'function') {\n                optimistic_1 = mutation.optimisticResponse(mutation.variables);\n            }\n            else {\n                optimistic_1 = mutation.optimisticResponse;\n            }\n            this.cache.recordOptimisticTransaction(function (c) {\n                var orig = _this.cache;\n                _this.cache = c;\n                try {\n                    _this.markMutationResult({\n                        mutationId: mutation.mutationId,\n                        result: { data: optimistic_1 },\n                        document: mutation.document,\n                        variables: mutation.variables,\n                        updateQueries: mutation.updateQueries,\n                        update: mutation.update,\n                    });\n                }\n                finally {\n                    _this.cache = orig;\n                }\n            }, mutation.mutationId);\n        }\n    };\n    DataStore.prototype.markMutationResult = function (mutation) {\n        var _this = this;\n        if (!graphQLResultHasError(mutation.result)) {\n            var cacheWrites_1 = [{\n                    result: mutation.result.data,\n                    dataId: 'ROOT_MUTATION',\n                    query: mutation.document,\n                    variables: mutation.variables,\n                }];\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                Object.keys(updateQueries_1).forEach(function (id) {\n                    var _a = updateQueries_1[id], query = _a.query, updater = _a.updater;\n                    var _b = _this.cache.diff({\n                        query: query.document,\n                        variables: query.variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _b.result, complete = _b.complete;\n                    if (complete) {\n                        var nextQueryResult = tryFunctionOrLogError(function () {\n                            return updater(currentQueryResult, {\n                                mutationResult: mutation.result,\n                                queryName: getOperationName(query.document) || undefined,\n                                queryVariables: query.variables,\n                            });\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites_1.push({\n                                result: nextQueryResult,\n                                dataId: 'ROOT_QUERY',\n                                query: query.document,\n                                variables: query.variables,\n                            });\n                        }\n                    }\n                });\n            }\n            this.cache.performTransaction(function (c) {\n                cacheWrites_1.forEach(function (write) { return c.write(write); });\n                var update = mutation.update;\n                if (update) {\n                    tryFunctionOrLogError(function () { return update(c, mutation.result); });\n                }\n            });\n        }\n    };\n    DataStore.prototype.markMutationComplete = function (_a) {\n        var mutationId = _a.mutationId, optimisticResponse = _a.optimisticResponse;\n        if (optimisticResponse) {\n            this.cache.removeOptimistic(mutationId);\n        }\n    };\n    DataStore.prototype.markUpdateQueryResult = function (document, variables, newResult) {\n        this.cache.write({\n            result: newResult,\n            dataId: 'ROOT_QUERY',\n            variables: variables,\n            query: document,\n        });\n    };\n    DataStore.prototype.reset = function () {\n        return this.cache.reset();\n    };\n    return DataStore;\n}());\n\nvar version = \"2.6.10\";\n\nvar hasSuggestedDevtools = false;\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.defaultOptions = {};\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        var cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? false : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;\n        var link = options.link;\n        if (!link && resolvers) {\n            link = ApolloLink.empty();\n        }\n        if (!link || !cache) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(4) : new InvariantError(\"In order to initialize Apollo Client, you must specify 'link' and 'cache' properties in the options object.\\n\" +\n                \"These options are part of the upgrade requirements when migrating from Apollo Client 1.x to Apollo Client 2.x.\\n\" +\n                \"For more information, please visit: https://www.apollographql.com/docs/tutorial/client.html#apollo-client-setup\");\n        }\n        this.link = link;\n        this.cache = cache;\n        this.store = new DataStore(cache);\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || {};\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        var defaultConnectToDevTools = process.env.NODE_ENV !== 'production' &&\n            typeof window !== 'undefined' &&\n            !window.__APOLLO_CLIENT__;\n        if (typeof connectToDevTools === 'undefined'\n            ? defaultConnectToDevTools\n            : connectToDevTools && typeof window !== 'undefined') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self) {\n                if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n                    if (window.navigator &&\n                        window.navigator.userAgent &&\n                        window.navigator.userAgent.indexOf('Chrome') > -1) {\n                        console.debug('Download the Apollo DevTools ' +\n                            'for a better development experience: ' +\n                            'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n                    }\n                }\n            }\n        }\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            link: this.link,\n            store: this.store,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: function () {\n                if (_this.devToolsHookCb) {\n                    _this.devToolsHookCb({\n                        action: {},\n                        state: {\n                            queries: _this.queryManager.queryStore.getStore(),\n                            mutations: _this.queryManager.mutationStore.getStore(),\n                        },\n                        dataWithOptimisticResults: _this.cache.extract(true),\n                    });\n                }\n            },\n        });\n    }\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = __assign(__assign({}, this.defaultOptions.watchQuery), options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = __assign(__assign({}, this.defaultOptions.query), options);\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'cache-and-network', 5) : invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +\n            'client.query can only return a single result. Please use client.watchQuery ' +\n            'to receive multiple results from the cache and the network, or consider ' +\n            'using a different fetchPolicy, such as cache-first or network-only.');\n        if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = __assign(__assign({}, this.defaultOptions.mutate), options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    ApolloClient.prototype.writeQuery = function (options) {\n        var result = this.cache.writeQuery(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        var result = this.cache.writeFragment(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeData = function (options) {\n        var result = this.cache.writeData(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    ApolloClient.prototype.initQueryManager = function () {\n        process.env.NODE_ENV === \"production\" || invariant.warn('Calling the initQueryManager method is no longer necessary, ' +\n            'and it will be removed from ApolloClient in version 3.0.');\n        return this.queryManager;\n    };\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    return ApolloClient;\n}());\n\nexport default ApolloClient;\nexport { ApolloClient, ApolloError, FetchType, NetworkStatus, ObservableQuery, isApolloError };\n//# sourceMappingURL=bundle.esm.js.map\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\nexports.isNonEmptyArray = isNonEmptyArray;\n//# sourceMappingURL=arrays.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tslib_1 = require(\"tslib\");\nvar apollo_link_1 = require(\"apollo-link\");\nvar symbol_observable_1 = tslib_1.__importDefault(require(\"symbol-observable\"));\nvar Observable = (function (_super) {\n    tslib_1.__extends(Observable, _super);\n    function Observable() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Observable.prototype[symbol_observable_1.default] = function () {\n        return this;\n    };\n    Observable.prototype['@@observable'] = function () {\n        return this;\n    };\n    return Observable;\n}(apollo_link_1.Observable));\nexports.Observable = Observable;\n//# sourceMappingURL=Observable.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\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 = exports.NetworkStatus || (exports.NetworkStatus = {}));\nfunction isNetworkRequestInFlight(networkStatus) {\n    return networkStatus < 7;\n}\nexports.isNetworkRequestInFlight = isNetworkRequestInFlight;\n//# sourceMappingURL=networkStatus.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { getFragmentQueryDocument } from 'apollo-utilities';\n\nfunction queryFromPojo(obj) {\n    var op = {\n        kind: 'OperationDefinition',\n        operation: 'query',\n        name: {\n            kind: 'Name',\n            value: 'GeneratedClientQuery',\n        },\n        selectionSet: selectionSetFromObj(obj),\n    };\n    var out = {\n        kind: 'Document',\n        definitions: [op],\n    };\n    return out;\n}\nfunction fragmentFromPojo(obj, typename) {\n    var frag = {\n        kind: 'FragmentDefinition',\n        typeCondition: {\n            kind: 'NamedType',\n            name: {\n                kind: 'Name',\n                value: typename || '__FakeType',\n            },\n        },\n        name: {\n            kind: 'Name',\n            value: 'GeneratedClientQuery',\n        },\n        selectionSet: selectionSetFromObj(obj),\n    };\n    var out = {\n        kind: 'Document',\n        definitions: [frag],\n    };\n    return out;\n}\nfunction selectionSetFromObj(obj) {\n    if (typeof obj === 'number' ||\n        typeof obj === 'boolean' ||\n        typeof obj === 'string' ||\n        typeof obj === 'undefined' ||\n        obj === null) {\n        return null;\n    }\n    if (Array.isArray(obj)) {\n        return selectionSetFromObj(obj[0]);\n    }\n    var selections = [];\n    Object.keys(obj).forEach(function (key) {\n        var nestedSelSet = selectionSetFromObj(obj[key]);\n        var field = {\n            kind: 'Field',\n            name: {\n                kind: 'Name',\n                value: key,\n            },\n            selectionSet: nestedSelSet || undefined,\n        };\n        selections.push(field);\n    });\n    var selectionSet = {\n        kind: 'SelectionSet',\n        selections: selections,\n    };\n    return selectionSet;\n}\nvar justTypenameQuery = {\n    kind: 'Document',\n    definitions: [\n        {\n            kind: 'OperationDefinition',\n            operation: 'query',\n            name: null,\n            variableDefinitions: null,\n            directives: [],\n            selectionSet: {\n                kind: 'SelectionSet',\n                selections: [\n                    {\n                        kind: 'Field',\n                        alias: null,\n                        name: {\n                            kind: 'Name',\n                            value: '__typename',\n                        },\n                        arguments: [],\n                        directives: [],\n                        selectionSet: null,\n                    },\n                ],\n            },\n        },\n    ],\n};\n\nvar ApolloCache = (function () {\n    function ApolloCache() {\n    }\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: options.query,\n            variables: options.variables,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n            variables: options.variables,\n            rootId: options.id,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.writeQuery = function (options) {\n        this.write({\n            dataId: 'ROOT_QUERY',\n            result: options.data,\n            query: options.query,\n            variables: options.variables,\n        });\n    };\n    ApolloCache.prototype.writeFragment = function (options) {\n        this.write({\n            dataId: options.id,\n            result: options.data,\n            variables: options.variables,\n            query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n        });\n    };\n    ApolloCache.prototype.writeData = function (_a) {\n        var id = _a.id, data = _a.data;\n        if (typeof id !== 'undefined') {\n            var typenameResult = null;\n            try {\n                typenameResult = this.read({\n                    rootId: id,\n                    optimistic: false,\n                    query: justTypenameQuery,\n                });\n            }\n            catch (e) {\n            }\n            var __typename = (typenameResult && typenameResult.__typename) || '__ClientData';\n            var dataToWrite = Object.assign({ __typename: __typename }, data);\n            this.writeFragment({\n                id: id,\n                fragment: fragmentFromPojo(dataToWrite, __typename),\n                data: dataToWrite,\n            });\n        }\n        else {\n            this.writeQuery({ query: queryFromPojo(data), data: data });\n        }\n    };\n    return ApolloCache;\n}());\n\nvar Cache;\n(function (Cache) {\n})(Cache || (Cache = {}));\n\nexport { ApolloCache, Cache };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __assign, __extends } from 'tslib';\nimport { ApolloCache } from 'apollo-cache';\nimport { isTest, getQueryDefinition, assign, getDefaultValues, isEqual, getMainDefinition, getFragmentDefinitions, createFragmentMap, shouldInclude, isField, resultKeyNameFromField, isInlineFragment, mergeDeepArray, argumentsObjectFromField, getDirectiveInfoFromField, maybeDeepFreeze, isIdValue, getStoreKeyName, toIdValue, isJsonValue, canUseWeakMap, getOperationDefinition, isProduction, storeKeyNameFromField, addTypenameToDocument } from 'apollo-utilities';\nimport { wrap, KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\n\nvar haveWarned = false;\nfunction shouldWarn() {\n    var answer = !haveWarned;\n    if (!isTest()) {\n        haveWarned = true;\n    }\n    return answer;\n}\nvar HeuristicFragmentMatcher = (function () {\n    function HeuristicFragmentMatcher() {\n    }\n    HeuristicFragmentMatcher.prototype.ensureReady = function () {\n        return Promise.resolve();\n    };\n    HeuristicFragmentMatcher.prototype.canBypassInit = function () {\n        return true;\n    };\n    HeuristicFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        if (!__typename) {\n            if (shouldWarn()) {\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"You're using fragments in your queries, but either don't have the addTypename:\\n  true option set in Apollo Client, or you are trying to write a fragment to the store without the __typename.\\n   Please turn on the addTypename option and include __typename when writing fragments so that Apollo Client\\n   can accurately match fragments.\");\n                process.env.NODE_ENV === \"production\" || invariant.warn('Could not find __typename on Fragment ', typeCondition, obj);\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"DEPRECATION WARNING: using fragments without __typename is unsupported behavior \" +\n                    \"and will be removed in future versions of Apollo client. You should fix this and set addTypename to true now.\");\n            }\n            return 'heuristic';\n        }\n        if (__typename === typeCondition) {\n            return true;\n        }\n        if (shouldWarn()) {\n            process.env.NODE_ENV === \"production\" || invariant.error('You are using the simple (heuristic) fragment matcher, but your ' +\n                'queries contain union or interface types. Apollo Client will not be ' +\n                'able to accurately map fragments. To make this error go away, use ' +\n                'the `IntrospectionFragmentMatcher` as described in the docs: ' +\n                'https://www.apollographql.com/docs/react/advanced/fragments.html#fragment-matcher');\n        }\n        return 'heuristic';\n    };\n    return HeuristicFragmentMatcher;\n}());\nvar IntrospectionFragmentMatcher = (function () {\n    function IntrospectionFragmentMatcher(options) {\n        if (options && options.introspectionQueryResultData) {\n            this.possibleTypesMap = this.parseIntrospectionResult(options.introspectionQueryResultData);\n            this.isReady = true;\n        }\n        else {\n            this.isReady = false;\n        }\n        this.match = this.match.bind(this);\n    }\n    IntrospectionFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n        process.env.NODE_ENV === \"production\" ? invariant(this.isReady, 1) : invariant(this.isReady, 'FragmentMatcher.match() was called before FragmentMatcher.init()');\n        var obj = context.store.get(idValue.id);\n        var isRootQuery = idValue.id === 'ROOT_QUERY';\n        if (!obj) {\n            return isRootQuery;\n        }\n        var _a = obj.__typename, __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n        process.env.NODE_ENV === \"production\" ? invariant(__typename, 2) : invariant(__typename, \"Cannot match fragment because __typename property is missing: \" + JSON.stringify(obj));\n        if (__typename === typeCondition) {\n            return true;\n        }\n        var implementingTypes = this.possibleTypesMap[typeCondition];\n        if (__typename &&\n            implementingTypes &&\n            implementingTypes.indexOf(__typename) > -1) {\n            return true;\n        }\n        return false;\n    };\n    IntrospectionFragmentMatcher.prototype.parseIntrospectionResult = function (introspectionResultData) {\n        var typeMap = {};\n        introspectionResultData.__schema.types.forEach(function (type) {\n            if (type.kind === 'UNION' || type.kind === 'INTERFACE') {\n                typeMap[type.name] = type.possibleTypes.map(function (implementingType) { return implementingType.name; });\n            }\n        });\n        return typeMap;\n    };\n    return IntrospectionFragmentMatcher;\n}());\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar DepTrackingCache = (function () {\n    function DepTrackingCache(data) {\n        var _this = this;\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n        this.depend = wrap(function (dataId) { return _this.data[dataId]; }, {\n            disposable: true,\n            makeCacheKey: function (dataId) {\n                return dataId;\n            },\n        });\n    }\n    DepTrackingCache.prototype.toObject = function () {\n        return this.data;\n    };\n    DepTrackingCache.prototype.get = function (dataId) {\n        this.depend(dataId);\n        return this.data[dataId];\n    };\n    DepTrackingCache.prototype.set = function (dataId, value) {\n        var oldValue = this.data[dataId];\n        if (value !== oldValue) {\n            this.data[dataId] = value;\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.delete = function (dataId) {\n        if (hasOwn.call(this.data, dataId)) {\n            delete this.data[dataId];\n            this.depend.dirty(dataId);\n        }\n    };\n    DepTrackingCache.prototype.clear = function () {\n        this.replace(null);\n    };\n    DepTrackingCache.prototype.replace = function (newData) {\n        var _this = this;\n        if (newData) {\n            Object.keys(newData).forEach(function (dataId) {\n                _this.set(dataId, newData[dataId]);\n            });\n            Object.keys(this.data).forEach(function (dataId) {\n                if (!hasOwn.call(newData, dataId)) {\n                    _this.delete(dataId);\n                }\n            });\n        }\n        else {\n            Object.keys(this.data).forEach(function (dataId) {\n                _this.delete(dataId);\n            });\n        }\n    };\n    return DepTrackingCache;\n}());\nfunction defaultNormalizedCacheFactory(seed) {\n    return new DepTrackingCache(seed);\n}\n\nvar StoreReader = (function () {\n    function StoreReader(_a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.cacheKeyRoot, cacheKeyRoot = _c === void 0 ? new KeyTrie(canUseWeakMap) : _c, _d = _b.freezeResults, freezeResults = _d === void 0 ? false : _d;\n        var _e = this, executeStoreQuery = _e.executeStoreQuery, executeSelectionSet = _e.executeSelectionSet, executeSubSelectedArray = _e.executeSubSelectedArray;\n        this.freezeResults = freezeResults;\n        this.executeStoreQuery = wrap(function (options) {\n            return executeStoreQuery.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, fragmentMatcher = _a.fragmentMatcher;\n                if (contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(contextValue.store, query, fragmentMatcher, JSON.stringify(variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSelectionSet = wrap(function (options) {\n            return executeSelectionSet.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, selectionSet, execContext.fragmentMatcher, JSON.stringify(execContext.variableValues), rootValue.id);\n                }\n            }\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            return executeSubSelectedArray.call(_this, options);\n        }, {\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, execContext = _a.execContext;\n                if (execContext.contextValue.store instanceof DepTrackingCache) {\n                    return cacheKeyRoot.lookup(execContext.contextValue.store, field, array, JSON.stringify(execContext.variableValues));\n                }\n            }\n        });\n    }\n    StoreReader.prototype.readQueryFromStore = function (options) {\n        return this.diffQueryAgainstStore(__assign(__assign({}, options), { returnPartialData: false })).result;\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, variables = _a.variables, previousResult = _a.previousResult, _b = _a.returnPartialData, returnPartialData = _b === void 0 ? true : _b, _c = _a.rootId, rootId = _c === void 0 ? 'ROOT_QUERY' : _c, fragmentMatcherFunction = _a.fragmentMatcherFunction, config = _a.config;\n        var queryDefinition = getQueryDefinition(query);\n        variables = assign({}, getDefaultValues(queryDefinition), variables);\n        var context = {\n            store: store,\n            dataIdFromObject: config && config.dataIdFromObject,\n            cacheRedirects: (config && config.cacheRedirects) || {},\n        };\n        var execResult = this.executeStoreQuery({\n            query: query,\n            rootValue: {\n                type: 'id',\n                id: rootId,\n                generated: true,\n                typename: 'Query',\n            },\n            contextValue: context,\n            variableValues: variables,\n            fragmentMatcher: fragmentMatcherFunction,\n        });\n        var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n        if (hasMissingFields && !returnPartialData) {\n            execResult.missing.forEach(function (info) {\n                if (info.tolerable)\n                    return;\n                throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Can't find field \" + info.fieldName + \" on object \" + JSON.stringify(info.object, null, 2) + \".\");\n            });\n        }\n        if (previousResult) {\n            if (isEqual(previousResult, execResult.result)) {\n                execResult.result = previousResult;\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !hasMissingFields,\n        };\n    };\n    StoreReader.prototype.executeStoreQuery = function (_a) {\n        var query = _a.query, rootValue = _a.rootValue, contextValue = _a.contextValue, variableValues = _a.variableValues, _b = _a.fragmentMatcher, fragmentMatcher = _b === void 0 ? defaultFragmentMatcher : _b;\n        var mainDefinition = getMainDefinition(query);\n        var fragments = getFragmentDefinitions(query);\n        var fragmentMap = createFragmentMap(fragments);\n        var execContext = {\n            query: query,\n            fragmentMap: fragmentMap,\n            contextValue: contextValue,\n            variableValues: variableValues,\n            fragmentMatcher: fragmentMatcher,\n        };\n        return this.executeSelectionSet({\n            selectionSet: mainDefinition.selectionSet,\n            rootValue: rootValue,\n            execContext: execContext,\n        });\n    };\n    StoreReader.prototype.executeSelectionSet = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, rootValue = _a.rootValue, execContext = _a.execContext;\n        var fragmentMap = execContext.fragmentMap, contextValue = execContext.contextValue, variables = execContext.variableValues;\n        var finalResult = { result: null };\n        var objectsToMerge = [];\n        var object = contextValue.store.get(rootValue.id);\n        var typename = (object && object.__typename) ||\n            (rootValue.id === 'ROOT_QUERY' && 'Query') ||\n            void 0;\n        function handleMissing(result) {\n            var _a;\n            if (result.missing) {\n                finalResult.missing = finalResult.missing || [];\n                (_a = finalResult.missing).push.apply(_a, result.missing);\n            }\n            return result.result;\n        }\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var fieldResult = handleMissing(_this.executeField(object, typename, selection, execContext));\n                if (typeof fieldResult !== 'undefined') {\n                    objectsToMerge.push((_a = {},\n                        _a[resultKeyNameFromField(selection)] = fieldResult,\n                        _a));\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = fragmentMap[selection.name.value];\n                    if (!fragment) {\n                        throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"No fragment named \" + selection.name.value);\n                    }\n                }\n                var typeCondition = fragment.typeCondition && fragment.typeCondition.name.value;\n                var match = !typeCondition ||\n                    execContext.fragmentMatcher(rootValue, typeCondition, contextValue);\n                if (match) {\n                    var fragmentExecResult = _this.executeSelectionSet({\n                        selectionSet: fragment.selectionSet,\n                        rootValue: rootValue,\n                        execContext: execContext,\n                    });\n                    if (match === 'heuristic' && fragmentExecResult.missing) {\n                        fragmentExecResult = __assign(__assign({}, fragmentExecResult), { missing: fragmentExecResult.missing.map(function (info) {\n                                return __assign(__assign({}, info), { tolerable: true });\n                            }) });\n                    }\n                    objectsToMerge.push(handleMissing(fragmentExecResult));\n                }\n            }\n        });\n        finalResult.result = mergeDeepArray(objectsToMerge);\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(finalResult.result);\n        }\n        return finalResult;\n    };\n    StoreReader.prototype.executeField = function (object, typename, field, execContext) {\n        var variables = execContext.variableValues, contextValue = execContext.contextValue;\n        var fieldName = field.name.value;\n        var args = argumentsObjectFromField(field, variables);\n        var info = {\n            resultKey: resultKeyNameFromField(field),\n            directives: getDirectiveInfoFromField(field, variables),\n        };\n        var readStoreResult = readStoreResolver(object, typename, fieldName, args, contextValue, info);\n        if (Array.isArray(readStoreResult.result)) {\n            return this.combineExecResults(readStoreResult, this.executeSubSelectedArray({\n                field: field,\n                array: readStoreResult.result,\n                execContext: execContext,\n            }));\n        }\n        if (!field.selectionSet) {\n            assertSelectionSetForIdValue(field, readStoreResult.result);\n            if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n                maybeDeepFreeze(readStoreResult);\n            }\n            return readStoreResult;\n        }\n        if (readStoreResult.result == null) {\n            return readStoreResult;\n        }\n        return this.combineExecResults(readStoreResult, this.executeSelectionSet({\n            selectionSet: field.selectionSet,\n            rootValue: readStoreResult.result,\n            execContext: execContext,\n        }));\n    };\n    StoreReader.prototype.combineExecResults = function () {\n        var execResults = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            execResults[_i] = arguments[_i];\n        }\n        var missing;\n        execResults.forEach(function (execResult) {\n            if (execResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, execResult.missing);\n            }\n        });\n        return {\n            result: execResults.pop().result,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.executeSubSelectedArray = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, execContext = _a.execContext;\n        var missing;\n        function handleMissing(childResult) {\n            if (childResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, childResult.missing);\n            }\n            return childResult.result;\n        }\n        array = array.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    execContext: execContext,\n                }));\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    rootValue: item,\n                    execContext: execContext,\n                }));\n            }\n            assertSelectionSetForIdValue(field, item);\n            return item;\n        });\n        if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n            Object.freeze(array);\n        }\n        return { result: array, missing: missing };\n    };\n    return StoreReader;\n}());\nfunction assertSelectionSetForIdValue(field, value) {\n    if (!field.selectionSet && isIdValue(value)) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError(\"Missing selection set for object of type \" + value.typename + \" returned for query field \" + field.name.value);\n    }\n}\nfunction defaultFragmentMatcher() {\n    return true;\n}\nfunction assertIdValue(idValue) {\n    process.env.NODE_ENV === \"production\" ? invariant(isIdValue(idValue), 11) : invariant(isIdValue(idValue), \"Encountered a sub-selection on the query, but the store doesn't have an object reference. This should never happen during normal use unless you have custom code that is directly manipulating the store; please file an issue.\");\n}\nfunction readStoreResolver(object, typename, fieldName, args, context, _a) {\n    var resultKey = _a.resultKey, directives = _a.directives;\n    var storeKeyName = fieldName;\n    if (args || directives) {\n        storeKeyName = getStoreKeyName(storeKeyName, args, directives);\n    }\n    var fieldValue = void 0;\n    if (object) {\n        fieldValue = object[storeKeyName];\n        if (typeof fieldValue === 'undefined' &&\n            context.cacheRedirects &&\n            typeof typename === 'string') {\n            var type = context.cacheRedirects[typename];\n            if (type) {\n                var resolver = type[fieldName];\n                if (resolver) {\n                    fieldValue = resolver(object, args, {\n                        getCacheKey: function (storeObj) {\n                            var id = context.dataIdFromObject(storeObj);\n                            return id && toIdValue({\n                                id: id,\n                                typename: storeObj.__typename,\n                            });\n                        },\n                    });\n                }\n            }\n        }\n    }\n    if (typeof fieldValue === 'undefined') {\n        return {\n            result: fieldValue,\n            missing: [{\n                    object: object,\n                    fieldName: storeKeyName,\n                    tolerable: false,\n                }],\n        };\n    }\n    if (isJsonValue(fieldValue)) {\n        fieldValue = fieldValue.json;\n    }\n    return {\n        result: fieldValue,\n    };\n}\n\nvar ObjectCache = (function () {\n    function ObjectCache(data) {\n        if (data === void 0) { data = Object.create(null); }\n        this.data = data;\n    }\n    ObjectCache.prototype.toObject = function () {\n        return this.data;\n    };\n    ObjectCache.prototype.get = function (dataId) {\n        return this.data[dataId];\n    };\n    ObjectCache.prototype.set = function (dataId, value) {\n        this.data[dataId] = value;\n    };\n    ObjectCache.prototype.delete = function (dataId) {\n        this.data[dataId] = void 0;\n    };\n    ObjectCache.prototype.clear = function () {\n        this.data = Object.create(null);\n    };\n    ObjectCache.prototype.replace = function (newData) {\n        this.data = newData || Object.create(null);\n    };\n    return ObjectCache;\n}());\nfunction defaultNormalizedCacheFactory$1(seed) {\n    return new ObjectCache(seed);\n}\n\nvar WriteError = (function (_super) {\n    __extends(WriteError, _super);\n    function WriteError() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.type = 'WriteError';\n        return _this;\n    }\n    return WriteError;\n}(Error));\nfunction enhanceErrorWithDocument(error, document) {\n    var enhancedError = new WriteError(\"Error writing result to store for query:\\n \" + JSON.stringify(document));\n    enhancedError.message += '\\n' + error.message;\n    enhancedError.stack = error.stack;\n    return enhancedError;\n}\nvar StoreWriter = (function () {\n    function StoreWriter() {\n    }\n    StoreWriter.prototype.writeQueryToStore = function (_a) {\n        var query = _a.query, result = _a.result, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        return this.writeResultToStore({\n            dataId: 'ROOT_QUERY',\n            result: result,\n            document: query,\n            store: store,\n            variables: variables,\n            dataIdFromObject: dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n    };\n    StoreWriter.prototype.writeResultToStore = function (_a) {\n        var dataId = _a.dataId, result = _a.result, document = _a.document, _b = _a.store, store = _b === void 0 ? defaultNormalizedCacheFactory() : _b, variables = _a.variables, dataIdFromObject = _a.dataIdFromObject, fragmentMatcherFunction = _a.fragmentMatcherFunction;\n        var operationDefinition = getOperationDefinition(document);\n        try {\n            return this.writeSelectionSetToStore({\n                result: result,\n                dataId: dataId,\n                selectionSet: operationDefinition.selectionSet,\n                context: {\n                    store: store,\n                    processedData: {},\n                    variables: assign({}, getDefaultValues(operationDefinition), variables),\n                    dataIdFromObject: dataIdFromObject,\n                    fragmentMap: createFragmentMap(getFragmentDefinitions(document)),\n                    fragmentMatcherFunction: fragmentMatcherFunction,\n                },\n            });\n        }\n        catch (e) {\n            throw enhanceErrorWithDocument(e, document);\n        }\n    };\n    StoreWriter.prototype.writeSelectionSetToStore = function (_a) {\n        var _this = this;\n        var result = _a.result, dataId = _a.dataId, selectionSet = _a.selectionSet, context = _a.context;\n        var variables = context.variables, store = context.store, fragmentMap = context.fragmentMap;\n        selectionSet.selections.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables)) {\n                return;\n            }\n            if (isField(selection)) {\n                var resultFieldKey = resultKeyNameFromField(selection);\n                var value = result[resultFieldKey];\n                if (typeof value !== 'undefined') {\n                    _this.writeFieldToStore({\n                        dataId: dataId,\n                        value: value,\n                        field: selection,\n                        context: context,\n                    });\n                }\n                else {\n                    var isDefered = false;\n                    var isClient = false;\n                    if (selection.directives && selection.directives.length) {\n                        isDefered = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'defer'; });\n                        isClient = selection.directives.some(function (directive) { return directive.name && directive.name.value === 'client'; });\n                    }\n                    if (!isDefered && !isClient && context.fragmentMatcherFunction) {\n                        process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing field \" + resultFieldKey + \" in \" + JSON.stringify(result, null, 2).substring(0, 100));\n                    }\n                }\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    fragment = (fragmentMap || {})[selection.name.value];\n                    process.env.NODE_ENV === \"production\" ? invariant(fragment, 3) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n                }\n                var matches = true;\n                if (context.fragmentMatcherFunction && fragment.typeCondition) {\n                    var id = dataId || 'self';\n                    var idValue = toIdValue({ id: id, typename: undefined });\n                    var fakeContext = {\n                        store: new ObjectCache((_a = {}, _a[id] = result, _a)),\n                        cacheRedirects: {},\n                    };\n                    var match = context.fragmentMatcherFunction(idValue, fragment.typeCondition.name.value, fakeContext);\n                    if (!isProduction() && match === 'heuristic') {\n                        process.env.NODE_ENV === \"production\" || invariant.error('WARNING: heuristic fragment matching going on!');\n                    }\n                    matches = !!match;\n                }\n                if (matches) {\n                    _this.writeSelectionSetToStore({\n                        result: result,\n                        selectionSet: fragment.selectionSet,\n                        dataId: dataId,\n                        context: context,\n                    });\n                }\n            }\n        });\n        return store;\n    };\n    StoreWriter.prototype.writeFieldToStore = function (_a) {\n        var _b;\n        var field = _a.field, value = _a.value, dataId = _a.dataId, context = _a.context;\n        var variables = context.variables, dataIdFromObject = context.dataIdFromObject, store = context.store;\n        var storeValue;\n        var storeObject;\n        var storeFieldName = storeKeyNameFromField(field, variables);\n        if (!field.selectionSet || value === null) {\n            storeValue =\n                value != null && typeof value === 'object'\n                    ?\n                        { type: 'json', json: value }\n                    :\n                        value;\n        }\n        else if (Array.isArray(value)) {\n            var generatedId = dataId + \".\" + storeFieldName;\n            storeValue = this.processArrayValue(value, generatedId, field.selectionSet, context);\n        }\n        else {\n            var valueDataId = dataId + \".\" + storeFieldName;\n            var generated = true;\n            if (!isGeneratedId(valueDataId)) {\n                valueDataId = '$' + valueDataId;\n            }\n            if (dataIdFromObject) {\n                var semanticId = dataIdFromObject(value);\n                process.env.NODE_ENV === \"production\" ? invariant(!semanticId || !isGeneratedId(semanticId), 4) : invariant(!semanticId || !isGeneratedId(semanticId), 'IDs returned by dataIdFromObject cannot begin with the \"$\" character.');\n                if (semanticId ||\n                    (typeof semanticId === 'number' && semanticId === 0)) {\n                    valueDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(valueDataId, field, context.processedData)) {\n                this.writeSelectionSetToStore({\n                    dataId: valueDataId,\n                    result: value,\n                    selectionSet: field.selectionSet,\n                    context: context,\n                });\n            }\n            var typename = value.__typename;\n            storeValue = toIdValue({ id: valueDataId, typename: typename }, generated);\n            storeObject = store.get(dataId);\n            var escapedId = storeObject && storeObject[storeFieldName];\n            if (escapedId !== storeValue && isIdValue(escapedId)) {\n                var hadTypename = escapedId.typename !== undefined;\n                var hasTypename = typename !== undefined;\n                var typenameChanged = hadTypename && hasTypename && escapedId.typename !== typename;\n                process.env.NODE_ENV === \"production\" ? invariant(!generated || escapedId.generated || typenameChanged, 5) : invariant(!generated || escapedId.generated || typenameChanged, \"Store error: the application attempted to write an object with no provided id but the store already contains an id of \" + escapedId.id + \" for this object. The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                process.env.NODE_ENV === \"production\" ? invariant(!hadTypename || hasTypename, 6) : invariant(!hadTypename || hasTypename, \"Store error: the application attempted to write an object with no provided typename but the store already contains an object with typename of \" + escapedId.typename + \" for the object of id \" + escapedId.id + \". The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n                if (escapedId.generated) {\n                    if (typenameChanged) {\n                        if (!generated) {\n                            store.delete(escapedId.id);\n                        }\n                    }\n                    else {\n                        mergeWithGenerated(escapedId.id, storeValue.id, store);\n                    }\n                }\n            }\n        }\n        storeObject = store.get(dataId);\n        if (!storeObject || !isEqual(storeValue, storeObject[storeFieldName])) {\n            store.set(dataId, __assign(__assign({}, storeObject), (_b = {}, _b[storeFieldName] = storeValue, _b)));\n        }\n    };\n    StoreWriter.prototype.processArrayValue = function (value, generatedId, selectionSet, context) {\n        var _this = this;\n        return value.map(function (item, index) {\n            if (item === null) {\n                return null;\n            }\n            var itemDataId = generatedId + \".\" + index;\n            if (Array.isArray(item)) {\n                return _this.processArrayValue(item, itemDataId, selectionSet, context);\n            }\n            var generated = true;\n            if (context.dataIdFromObject) {\n                var semanticId = context.dataIdFromObject(item);\n                if (semanticId) {\n                    itemDataId = semanticId;\n                    generated = false;\n                }\n            }\n            if (!isDataProcessed(itemDataId, selectionSet, context.processedData)) {\n                _this.writeSelectionSetToStore({\n                    dataId: itemDataId,\n                    result: item,\n                    selectionSet: selectionSet,\n                    context: context,\n                });\n            }\n            return toIdValue({ id: itemDataId, typename: item.__typename }, generated);\n        });\n    };\n    return StoreWriter;\n}());\nfunction isGeneratedId(id) {\n    return id[0] === '$';\n}\nfunction mergeWithGenerated(generatedKey, realKey, cache) {\n    if (generatedKey === realKey) {\n        return false;\n    }\n    var generated = cache.get(generatedKey);\n    var real = cache.get(realKey);\n    var madeChanges = false;\n    Object.keys(generated).forEach(function (key) {\n        var value = generated[key];\n        var realValue = real[key];\n        if (isIdValue(value) &&\n            isGeneratedId(value.id) &&\n            isIdValue(realValue) &&\n            !isEqual(value, realValue) &&\n            mergeWithGenerated(value.id, realValue.id, cache)) {\n            madeChanges = true;\n        }\n    });\n    cache.delete(generatedKey);\n    var newRealValue = __assign(__assign({}, generated), real);\n    if (isEqual(newRealValue, real)) {\n        return madeChanges;\n    }\n    cache.set(realKey, newRealValue);\n    return true;\n}\nfunction isDataProcessed(dataId, field, processedData) {\n    if (!processedData) {\n        return false;\n    }\n    if (processedData[dataId]) {\n        if (processedData[dataId].indexOf(field) >= 0) {\n            return true;\n        }\n        else {\n            processedData[dataId].push(field);\n        }\n    }\n    else {\n        processedData[dataId] = [field];\n    }\n    return false;\n}\n\nvar defaultConfig = {\n    fragmentMatcher: new HeuristicFragmentMatcher(),\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    freezeResults: false,\n};\nfunction defaultDataIdFromObject(result) {\n    if (result.__typename) {\n        if (result.id !== undefined) {\n            return result.__typename + \":\" + result.id;\n        }\n        if (result._id !== undefined) {\n            return result.__typename + \":\" + result._id;\n        }\n    }\n    return null;\n}\nvar hasOwn$1 = Object.prototype.hasOwnProperty;\nvar OptimisticCacheLayer = (function (_super) {\n    __extends(OptimisticCacheLayer, _super);\n    function OptimisticCacheLayer(optimisticId, parent, transaction) {\n        var _this = _super.call(this, Object.create(null)) || this;\n        _this.optimisticId = optimisticId;\n        _this.parent = parent;\n        _this.transaction = transaction;\n        return _this;\n    }\n    OptimisticCacheLayer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    OptimisticCacheLayer.prototype.get = function (dataId) {\n        return hasOwn$1.call(this.data, dataId)\n            ? this.data[dataId]\n            : this.parent.get(dataId);\n    };\n    return OptimisticCacheLayer;\n}(ObjectCache));\nvar InMemoryCache = (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.typenameDocumentCache = new Map();\n        _this.cacheKeyRoot = new KeyTrie(canUseWeakMap);\n        _this.silenceBroadcast = false;\n        _this.config = __assign(__assign({}, defaultConfig), config);\n        if (_this.config.customResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.customResolvers;\n        }\n        if (_this.config.cacheResolvers) {\n            process.env.NODE_ENV === \"production\" || invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');\n            _this.config.cacheRedirects = _this.config.cacheResolvers;\n        }\n        _this.addTypename = !!_this.config.addTypename;\n        _this.data = _this.config.resultCaching\n            ? new DepTrackingCache()\n            : new ObjectCache();\n        _this.optimisticData = _this.data;\n        _this.storeWriter = new StoreWriter();\n        _this.storeReader = new StoreReader({\n            cacheKeyRoot: _this.cacheKeyRoot,\n            freezeResults: config.freezeResults,\n        });\n        var cache = _this;\n        var maybeBroadcastWatch = cache.maybeBroadcastWatch;\n        _this.maybeBroadcastWatch = wrap(function (c) {\n            return maybeBroadcastWatch.call(_this, c);\n        }, {\n            makeCacheKey: function (c) {\n                if (c.optimistic) {\n                    return;\n                }\n                if (c.previousResult) {\n                    return;\n                }\n                if (cache.data instanceof DepTrackingCache) {\n                    return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));\n                }\n            }\n        });\n        return _this;\n    }\n    InMemoryCache.prototype.restore = function (data) {\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).toObject();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        if (typeof options.rootId === 'string' &&\n            typeof this.data.get(options.rootId) === 'undefined') {\n            return null;\n        }\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.readQueryFromStore({\n            store: options.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(options.query),\n            variables: options.variables,\n            rootId: options.rootId,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            previousResult: options.previousResult,\n            config: this.config,\n        }) || null;\n    };\n    InMemoryCache.prototype.write = function (write) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        this.storeWriter.writeResultToStore({\n            dataId: write.dataId,\n            result: write.result,\n            variables: write.variables,\n            document: this.transformDocument(write.query),\n            store: this.data,\n            dataIdFromObject: this.config.dataIdFromObject,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n        });\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.diff = function (query) {\n        var fragmentMatcher = this.config.fragmentMatcher;\n        var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n        return this.storeReader.diffQueryAgainstStore({\n            store: query.optimistic ? this.optimisticData : this.data,\n            query: this.transformDocument(query.query),\n            variables: query.variables,\n            returnPartialData: query.returnPartialData,\n            previousResult: query.previousResult,\n            fragmentMatcherFunction: fragmentMatcherFunction,\n            config: this.config,\n        });\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        this.watches.add(watch);\n        return function () {\n            _this.watches.delete(watch);\n        };\n    };\n    InMemoryCache.prototype.evict = function (query) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(7) : new InvariantError(\"eviction is not implemented on InMemory Cache\");\n    };\n    InMemoryCache.prototype.reset = function () {\n        this.data.clear();\n        this.broadcastWatches();\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var toReapply = [];\n        var removedCount = 0;\n        var layer = this.optimisticData;\n        while (layer instanceof OptimisticCacheLayer) {\n            if (layer.optimisticId === idToRemove) {\n                ++removedCount;\n            }\n            else {\n                toReapply.push(layer);\n            }\n            layer = layer.parent;\n        }\n        if (removedCount > 0) {\n            this.optimisticData = layer;\n            while (toReapply.length > 0) {\n                var layer_1 = toReapply.pop();\n                this.performTransaction(layer_1.transaction, layer_1.optimisticId);\n            }\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n        var _a = this, data = _a.data, silenceBroadcast = _a.silenceBroadcast;\n        this.silenceBroadcast = true;\n        if (typeof optimisticId === 'string') {\n            this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);\n        }\n        try {\n            transaction(this);\n        }\n        finally {\n            this.silenceBroadcast = silenceBroadcast;\n            this.data = data;\n        }\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {\n        return this.performTransaction(transaction, id);\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        if (this.addTypename) {\n            var result = this.typenameDocumentCache.get(document);\n            if (!result) {\n                result = addTypenameToDocument(document);\n                this.typenameDocumentCache.set(document, result);\n                this.typenameDocumentCache.set(result, result);\n            }\n            return result;\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function () {\n        var _this = this;\n        if (!this.silenceBroadcast) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c); });\n        }\n    };\n    InMemoryCache.prototype.maybeBroadcastWatch = function (c) {\n        c.callback(this.diff({\n            query: c.query,\n            variables: c.variables,\n            previousResult: c.previousResult && c.previousResult(),\n            optimistic: c.optimistic,\n        }));\n    };\n    return InMemoryCache;\n}(ApolloCache));\n\nexport { HeuristicFragmentMatcher, InMemoryCache, IntrospectionFragmentMatcher, ObjectCache, StoreReader, StoreWriter, WriteError, assertIdValue, defaultDataIdFromObject, defaultNormalizedCacheFactory$1 as defaultNormalizedCacheFactory, enhanceErrorWithDocument };\n//# sourceMappingURL=bundle.esm.js.map\n","'use strict';\n\nmodule.exports = function formDataAppendFile(formData, fieldName, file) {\n  formData.append(fieldName, file, file.name);\n};\n","'use strict';\n\nmodule.exports = require('extract-files/public/isExtractableFile');\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tslib_1 = require(\"tslib\");\nvar arrays_1 = require(\"../util/arrays\");\nfunction isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nexports.isApolloError = isApolloError;\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (arrays_1.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    tslib_1.__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));\nexports.ApolloError = ApolloError;\n//# sourceMappingURL=ApolloError.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\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 = exports.FetchType || (exports.FetchType = {}));\n//# sourceMappingURL=types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tslib_1 = require(\"tslib\");\nvar visitor_1 = require(\"graphql/language/visitor\");\nvar apollo_utilities_1 = require(\"apollo-utilities\");\nvar ts_invariant_1 = require(\"ts-invariant\");\nvar capitalizeFirstLetter_1 = require(\"../util/capitalizeFirstLetter\");\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 = apollo_utilities_1.mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = apollo_utilities_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {\n            return tslib_1.__generator(this, function (_c) {\n                if (document) {\n                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib_1.__assign(tslib_1.__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 (apollo_utilities_1.hasDirectives(['client'], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n            ts_invariant_1.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 ? apollo_utilities_1.removeClientSetsFromDocument(document) : document;\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var cache = this.cache;\n        var newContext = tslib_1.__assign(tslib_1.__assign({}, context), { cache: cache, getCacheKey: function (obj) {\n                if (cache.config) {\n                    return cache.config.dataIdFromObject(obj);\n                }\n                else {\n                    ts_invariant_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {\n            return tslib_1.__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 (tslib_1.__assign(tslib_1.__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2, tslib_1.__assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visitor_1.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 visitor_1.BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: apollo_utilities_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {\n            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n            return tslib_1.__generator(this, function (_b) {\n                mainDefinition = apollo_utilities_1.getMainDefinition(document);\n                fragments = apollo_utilities_1.getFragmentDefinitions(document);\n                fragmentMap = apollo_utilities_1.createFragmentMap(fragments);\n                definitionOperation = mainDefinition\n                    .operation;\n                defaultOperationType = definitionOperation\n                    ? capitalizeFirstLetter_1.capitalizeFirstLetter(definitionOperation)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: tslib_1.__assign(tslib_1.__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 tslib_1.__awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return tslib_1.__generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return tslib_1.__awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return tslib_1.__generator(this, function (_a) {\n                        if (!apollo_utilities_1.shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (apollo_utilities_1.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[apollo_utilities_1.resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (apollo_utilities_1.isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            ts_invariant_1.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 apollo_utilities_1.mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return tslib_1.__awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return tslib_1.__generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = apollo_utilities_1.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, apollo_utilities_1.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}());\nexports.LocalState = LocalState;\n//# sourceMappingURL=LocalState.js.map","var supportsPassiveEvents;\nfunction arePassiveEventsSupported() {\n  if (supportsPassiveEvents !== undefined) {\n    return supportsPassiveEvents;\n  }\n\n  var passive = false;\n  var options = {\n    // @ts-ignore: this is a temporary object, it doesn't have to return anything\n    get passive() {\n      passive = true;\n    }\n\n  };\n\n  var noop = function noop() {};\n\n  window.addEventListener('t', noop, options);\n  window.removeEventListener('t', noop, options);\n  supportsPassiveEvents = passive;\n  return passive;\n}\n\nexport default arePassiveEventsSupported;\n","'use strict';\n\nexports.createUploadLink = require('./createUploadLink');\nexports.formDataAppendFile = require('./formDataAppendFile');\nexports.isExtractableFile = require('./isExtractableFile');\nexports.ReactNativeFile = require('./ReactNativeFile');\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tslib_1 = require(\"tslib\");\nvar apollo_link_1 = require(\"apollo-link\");\nvar ts_invariant_1 = require(\"ts-invariant\");\nvar QueryManager_1 = require(\"./core/QueryManager\");\nvar LocalState_1 = require(\"./core/LocalState\");\nvar store_1 = require(\"./data/store\");\nvar version_1 = require(\"./version\");\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 = apollo_link_1.ApolloLink.empty();\n        }\n        if (!link || !cache) {\n            throw new ts_invariant_1.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 store_1.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_1.version;\n        this.localState = new LocalState_1.LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager_1.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 = tslib_1.__assign(tslib_1.__assign({}, this.defaultOptions.watchQuery), options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options = tslib_1.__assign(tslib_1.__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 = tslib_1.__assign(tslib_1.__assign({}, this.defaultOptions.query), options);\n        }\n        ts_invariant_1.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 = tslib_1.__assign(tslib_1.__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 = tslib_1.__assign(tslib_1.__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 apollo_link_1.execute(this.link, payload);\n    };\n    ApolloClient.prototype.initQueryManager = function () {\n        ts_invariant_1.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}());\nexports.default = ApolloClient;\n//# sourceMappingURL=ApolloClient.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __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","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __assign, __extends } from 'tslib';\nimport { Observable, ApolloLink } from 'apollo-link';\n\nvar OperationBatcher = (function () {\n    function OperationBatcher(_a) {\n        var batchInterval = _a.batchInterval, batchMax = _a.batchMax, batchHandler = _a.batchHandler, batchKey = _a.batchKey;\n        this.queuedRequests = new Map();\n        this.batchInterval = batchInterval;\n        this.batchMax = batchMax || 0;\n        this.batchHandler = batchHandler;\n        this.batchKey = batchKey || (function () { return ''; });\n    }\n    OperationBatcher.prototype.enqueueRequest = function (request) {\n        var _this = this;\n        var requestCopy = __assign({}, request);\n        var queued = false;\n        var key = this.batchKey(request.operation);\n        if (!requestCopy.observable) {\n            requestCopy.observable = new Observable(function (observer) {\n                if (!_this.queuedRequests.has(key)) {\n                    _this.queuedRequests.set(key, []);\n                }\n                if (!queued) {\n                    _this.queuedRequests.get(key).push(requestCopy);\n                    queued = true;\n                }\n                requestCopy.next = requestCopy.next || [];\n                if (observer.next)\n                    requestCopy.next.push(observer.next.bind(observer));\n                requestCopy.error = requestCopy.error || [];\n                if (observer.error)\n                    requestCopy.error.push(observer.error.bind(observer));\n                requestCopy.complete = requestCopy.complete || [];\n                if (observer.complete)\n                    requestCopy.complete.push(observer.complete.bind(observer));\n                if (_this.queuedRequests.get(key).length === 1) {\n                    _this.scheduleQueueConsumption(key);\n                }\n                if (_this.queuedRequests.get(key).length === _this.batchMax) {\n                    _this.consumeQueue(key);\n                }\n            });\n        }\n        return requestCopy.observable;\n    };\n    OperationBatcher.prototype.consumeQueue = function (key) {\n        var requestKey = key || '';\n        var queuedRequests = this.queuedRequests.get(requestKey);\n        if (!queuedRequests) {\n            return;\n        }\n        this.queuedRequests.delete(requestKey);\n        var requests = queuedRequests.map(function (queuedRequest) { return queuedRequest.operation; });\n        var forwards = queuedRequests.map(function (queuedRequest) { return queuedRequest.forward; });\n        var observables = [];\n        var nexts = [];\n        var errors = [];\n        var completes = [];\n        queuedRequests.forEach(function (batchableRequest, index) {\n            observables.push(batchableRequest.observable);\n            nexts.push(batchableRequest.next);\n            errors.push(batchableRequest.error);\n            completes.push(batchableRequest.complete);\n        });\n        var batchedObservable = this.batchHandler(requests, forwards) || Observable.of();\n        var onError = function (error) {\n            errors.forEach(function (rejecters) {\n                if (rejecters) {\n                    rejecters.forEach(function (e) { return e(error); });\n                }\n            });\n        };\n        batchedObservable.subscribe({\n            next: function (results) {\n                if (!Array.isArray(results)) {\n                    results = [results];\n                }\n                if (nexts.length !== results.length) {\n                    var error = new Error(\"server returned results with length \" + results.length + \", expected length of \" + nexts.length);\n                    error.result = results;\n                    return onError(error);\n                }\n                results.forEach(function (result, index) {\n                    if (nexts[index]) {\n                        nexts[index].forEach(function (next) { return next(result); });\n                    }\n                });\n            },\n            error: onError,\n            complete: function () {\n                completes.forEach(function (complete) {\n                    if (complete) {\n                        complete.forEach(function (c) { return c(); });\n                    }\n                });\n            },\n        });\n        return observables;\n    };\n    OperationBatcher.prototype.scheduleQueueConsumption = function (key) {\n        var _this = this;\n        var requestKey = key || '';\n        setTimeout(function () {\n            if (_this.queuedRequests.get(requestKey) &&\n                _this.queuedRequests.get(requestKey).length) {\n                _this.consumeQueue(requestKey);\n            }\n        }, this.batchInterval);\n    };\n    return OperationBatcher;\n}());\n\nvar BatchLink = (function (_super) {\n    __extends(BatchLink, _super);\n    function BatchLink(fetchParams) {\n        var _this = _super.call(this) || this;\n        var _a = fetchParams || {}, _b = _a.batchInterval, batchInterval = _b === void 0 ? 10 : _b, _c = _a.batchMax, batchMax = _c === void 0 ? 0 : _c, _d = _a.batchHandler, batchHandler = _d === void 0 ? function () { return null; } : _d, _e = _a.batchKey, batchKey = _e === void 0 ? function () { return ''; } : _e;\n        _this.batcher = new OperationBatcher({\n            batchInterval: batchInterval,\n            batchMax: batchMax,\n            batchHandler: batchHandler,\n            batchKey: batchKey,\n        });\n        if (fetchParams.batchHandler.length <= 1) {\n            _this.request = function (operation) { return _this.batcher.enqueueRequest({ operation: operation }); };\n        }\n        return _this;\n    }\n    BatchLink.prototype.request = function (operation, forward) {\n        return this.batcher.enqueueRequest({\n            operation: operation,\n            forward: forward,\n        });\n    };\n    return BatchLink;\n}(ApolloLink));\n\nexport { BatchLink, OperationBatcher };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __extends, __rest, __assign } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, serializeFetchParameter, createSignalIfSupported, parseAndCheckHttpResponse } from 'apollo-link-http-common';\nimport { BatchLink } from 'apollo-link-batch';\n\nvar BatchHttpLink = (function (_super) {\n    __extends(BatchHttpLink, _super);\n    function BatchHttpLink(fetchParams) {\n        var _this = _super.call(this) || this;\n        var _a = fetchParams || {}, _b = _a.uri, uri = _b === void 0 ? '/graphql' : _b, fetcher = _a.fetch, includeExtensions = _a.includeExtensions, batchInterval = _a.batchInterval, batchMax = _a.batchMax, batchKey = _a.batchKey, requestOptions = __rest(_a, [\"uri\", \"fetch\", \"includeExtensions\", \"batchInterval\", \"batchMax\", \"batchKey\"]);\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        _this.batchInterval = batchInterval || 10;\n        _this.batchMax = batchMax || 10;\n        var batchHandler = function (operations) {\n            var chosenURI = selectURI(operations[0], uri);\n            var context = operations[0].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 contextConfig = {\n                http: context.http,\n                options: context.fetchOptions,\n                credentials: context.credentials,\n                headers: __assign({}, clientAwarenessHeaders, context.headers),\n            };\n            var optsAndBody = operations.map(function (operation) {\n                return selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig);\n            });\n            var loadedBody = optsAndBody.map(function (_a) {\n                var body = _a.body;\n                return body;\n            });\n            var options = optsAndBody[0].options;\n            if (options.method === 'GET') {\n                return fromError(new Error('apollo-link-batch-http does not support GET requests'));\n            }\n            try {\n                options.body = serializeFetchParameter(loadedBody, 'Payload');\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n            var controller;\n            if (!options.signal) {\n                var _b = createSignalIfSupported(), _controller = _b.controller, signal = _b.signal;\n                controller = _controller;\n                if (controller)\n                    options.signal = signal;\n            }\n            return new Observable(function (observer) {\n                fetcher(chosenURI, options)\n                    .then(function (response) {\n                    operations.forEach(function (operation) { return operation.setContext({ response: response }); });\n                    return response;\n                })\n                    .then(parseAndCheckHttpResponse(operations))\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        batchKey =\n            batchKey ||\n                (function (operation) {\n                    var context = operation.getContext();\n                    var contextConfig = {\n                        http: context.http,\n                        options: context.fetchOptions,\n                        credentials: context.credentials,\n                        headers: context.headers,\n                    };\n                    return selectURI(operation, uri) + JSON.stringify(contextConfig);\n                });\n        _this.batcher = new BatchLink({\n            batchInterval: _this.batchInterval,\n            batchMax: _this.batchMax,\n            batchKey: batchKey,\n            batchHandler: batchHandler,\n        });\n        return _this;\n    }\n    BatchHttpLink.prototype.request = function (operation) {\n        return this.batcher.request(operation);\n    };\n    return BatchHttpLink;\n}(ApolloLink));\n\nexport { BatchHttpLink };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __rest } from 'tslib';\nimport { ApolloLink, Observable } from 'apollo-link';\n\nfunction setContext(setter) {\n    return new ApolloLink(function (operation, forward) {\n        var request = __rest(operation, []);\n        return new Observable(function (observer) {\n            var handle;\n            Promise.resolve(request)\n                .then(function (req) { return setter(req, operation.getContext()); })\n                .then(operation.setContext)\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\nexport { setContext };\n//# sourceMappingURL=bundle.esm.js.map\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __extends } from 'tslib';\nimport { ApolloLink } from 'apollo-link';\nimport { SubscriptionClient } from 'subscriptions-transport-ws';\n\nvar WebSocketLink = (function (_super) {\n    __extends(WebSocketLink, _super);\n    function WebSocketLink(paramsOrClient) {\n        var _this = _super.call(this) || this;\n        if (paramsOrClient instanceof SubscriptionClient) {\n            _this.subscriptionClient = paramsOrClient;\n        }\n        else {\n            _this.subscriptionClient = new SubscriptionClient(paramsOrClient.uri, paramsOrClient.options, paramsOrClient.webSocketImpl);\n        }\n        return _this;\n    }\n    WebSocketLink.prototype.request = function (operation) {\n        return this.subscriptionClient.request(operation);\n    };\n    return WebSocketLink;\n}(ApolloLink));\n\nexport { WebSocketLink };\n//# sourceMappingURL=bundle.esm.js.map\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { __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","'use strict';\n\nvar _extends = require('@babel/runtime/helpers/extends');\n\nvar _require = require('@apollo/client/core'),\n  ApolloLink = _require.ApolloLink,\n  Observable = _require.Observable;\n\nvar _require2 = require('@apollo/client/link/http'),\n  createSignalIfSupported = _require2.createSignalIfSupported,\n  fallbackHttpConfig = _require2.fallbackHttpConfig,\n  parseAndCheckHttpResponse = _require2.parseAndCheckHttpResponse,\n  rewriteURIForGET = _require2.rewriteURIForGET,\n  selectHttpOptionsAndBody = _require2.selectHttpOptionsAndBody,\n  selectURI = _require2.selectURI,\n  serializeFetchParameter = _require2.serializeFetchParameter;\n\nvar extractFiles = require('extract-files/public/extractFiles');\n\nvar formDataAppendFile = require('./formDataAppendFile');\n\nvar isExtractableFile = require('./isExtractableFile');\n\nmodule.exports = function createUploadLink(_temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n    _ref$uri = _ref.uri,\n    fetchUri = _ref$uri === void 0 ? '/graphql' : _ref$uri,\n    useGETForQueries = _ref.useGETForQueries,\n    _ref$isExtractableFil = _ref.isExtractableFile,\n    customIsExtractableFile =\n      _ref$isExtractableFil === void 0\n        ? isExtractableFile\n        : _ref$isExtractableFil,\n    CustomFormData = _ref.FormData,\n    _ref$formDataAppendFi = _ref.formDataAppendFile,\n    customFormDataAppendFile =\n      _ref$formDataAppendFi === void 0\n        ? formDataAppendFile\n        : _ref$formDataAppendFi,\n    customFetch = _ref.fetch,\n    fetchOptions = _ref.fetchOptions,\n    credentials = _ref.credentials,\n    headers = _ref.headers,\n    includeExtensions = _ref.includeExtensions;\n\n  var linkConfig = {\n    http: {\n      includeExtensions: includeExtensions,\n    },\n    options: fetchOptions,\n    credentials: credentials,\n    headers: headers,\n  };\n  return new ApolloLink(function (operation) {\n    var context = operation.getContext();\n    var _context$clientAwaren = context.clientAwareness;\n    _context$clientAwaren =\n      _context$clientAwaren === void 0 ? {} : _context$clientAwaren;\n    var name = _context$clientAwaren.name,\n      version = _context$clientAwaren.version,\n      headers = context.headers;\n    var contextConfig = {\n      http: context.http,\n      options: context.fetchOptions,\n      credentials: context.credentials,\n      headers: _extends(\n        {},\n        name && {\n          'apollographql-client-name': name,\n        },\n        version && {\n          'apollographql-client-version': version,\n        },\n        headers\n      ),\n    };\n\n    var _selectHttpOptionsAnd = selectHttpOptionsAndBody(\n        operation,\n        fallbackHttpConfig,\n        linkConfig,\n        contextConfig\n      ),\n      options = _selectHttpOptionsAnd.options,\n      body = _selectHttpOptionsAnd.body;\n\n    var _extractFiles = extractFiles(body, '', customIsExtractableFile),\n      clone = _extractFiles.clone,\n      files = _extractFiles.files;\n\n    var uri = selectURI(operation, fetchUri);\n\n    if (files.size) {\n      delete options.headers['content-type'];\n      var RuntimeFormData = CustomFormData || FormData;\n      var form = new RuntimeFormData();\n      form.append('operations', serializeFetchParameter(clone, 'Payload'));\n      var map = {};\n      var i = 0;\n      files.forEach(function (paths) {\n        map[++i] = paths;\n      });\n      form.append('map', JSON.stringify(map));\n      i = 0;\n      files.forEach(function (paths, file) {\n        customFormDataAppendFile(form, ++i, file);\n      });\n      options.body = form;\n    } else {\n      if (\n        useGETForQueries &&\n        !operation.query.definitions.some(function (definition) {\n          return (\n            definition.kind === 'OperationDefinition' &&\n            definition.operation === 'mutation'\n          );\n        })\n      )\n        options.method = 'GET';\n\n      if (options.method === 'GET') {\n        var _rewriteURIForGET = rewriteURIForGET(uri, body),\n          newURI = _rewriteURIForGET.newURI,\n          parseError = _rewriteURIForGET.parseError;\n\n        if (parseError)\n          return new Observable(function (observer) {\n            observer.error(parseError);\n          });\n        uri = newURI;\n      } else options.body = serializeFetchParameter(clone, 'Payload');\n    }\n\n    var _createSignalIfSuppor = createSignalIfSupported(),\n      controller = _createSignalIfSuppor.controller;\n\n    if (controller) {\n      if (options.signal)\n        options.signal.addEventListener('abort', function () {\n          controller.abort();\n        });\n      options.signal = controller.signal;\n    }\n\n    var runtimeFetch = customFetch || fetch;\n    return new Observable(function (observer) {\n      var cleaningUp;\n      runtimeFetch(uri, options)\n        .then(function (response) {\n          operation.setContext({\n            response: response,\n          });\n          return response;\n        })\n        .then(parseAndCheckHttpResponse(operation))\n        .then(function (result) {\n          observer.next(result);\n          observer.complete();\n        })\n        .catch(function (error) {\n          if (!cleaningUp)\n            error.result && error.result.errors && error.result.data\n              ? observer.next(error.result)\n              : observer.error(error);\n        });\n      return function () {\n        cleaningUp = true;\n        if (controller) controller.abort();\n      };\n    });\n  });\n};\n","'use strict';\n\nmodule.exports = require('extract-files/public/ReactNativeFile');\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tslib_1 = require(\"tslib\");\nvar apollo_link_1 = require(\"apollo-link\");\nvar apollo_utilities_1 = require(\"apollo-utilities\");\nvar ts_invariant_1 = require(\"ts-invariant\");\nvar ApolloError_1 = require(\"../errors/ApolloError\");\nvar Observable_1 = require(\"../util/Observable\");\nvar mutations_1 = require(\"../data/mutations\");\nvar queries_1 = require(\"../data/queries\");\nvar ObservableQuery_1 = require(\"./ObservableQuery\");\nvar networkStatus_1 = require(\"./networkStatus\");\nvar types_1 = require(\"./types\");\nvar LocalState_1 = require(\"./LocalState\");\nvar observables_1 = require(\"../util/observables\");\nvar arrays_1 = require(\"../util/arrays\");\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 mutations_1.MutationStore();\n        this.queryStore = new queries_1.QueryStore();\n        this.clientAwareness = {};\n        this.idCounter = 1;\n        this.queries = new Map();\n        this.fetchQueryRejectFns = new Map();\n        this.transformCache = new (apollo_utilities_1.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_1.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(new ts_invariant_1.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 tslib_1.__awaiter(this, void 0, void 0, function () {\n            var mutationId, generateUpdateQueriesInfo, self;\n            var _this = this;\n            return tslib_1.__generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        ts_invariant_1.invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        ts_invariant_1.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, tslib_1.__assign(tslib_1.__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (apollo_utilities_1.graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError_1.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_1.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 (arrays_1.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                                                apollo_utilities_1.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 tslib_1.__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 tslib_1.__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 = tslib_1.__assign(tslib_1.__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 (apollo_utilities_1.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 === types_1.FetchType.poll,\n                            isRefetch: fetchType === types_1.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 (ApolloError_1.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_1.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                    ts_invariant_1.invariant.error(e);\n                }\n            }\n            else if (method === 'error') {\n                ts_invariant_1.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 = networkStatus_1.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 = arrays_1.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_1.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_1.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 = apollo_utilities_1.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: apollo_utilities_1.hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: apollo_utilities_1.getDefaultValues(apollo_utilities_1.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 tslib_1.__assign(tslib_1.__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n        if (shouldSubscribe === void 0) { shouldSubscribe = true; }\n        ts_invariant_1.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 = tslib_1.__assign({}, options);\n        return new ObservableQuery_1.ObservableQuery({\n            queryManager: this,\n            options: transformedOptions,\n            shouldSubscribe: shouldSubscribe,\n        });\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        ts_invariant_1.invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        ts_invariant_1.invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        ts_invariant_1.invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        ts_invariant_1.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(new ts_invariant_1.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        ts_invariant_1.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 (apollo_utilities_1.graphQLResultHasError(result)) {\n                    throw new ApolloError_1.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_1.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            ts_invariant_1.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: apollo_utilities_1.getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(tslib_1.__assign(tslib_1.__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 = observables_1.multiplex(apollo_link_1.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 = observables_1.multiplex(apollo_link_1.execute(link, operation));\n            }\n        }\n        else {\n            observable = Observable_1.Observable.of({ data: {} });\n            context = this.prepareContext(context);\n        }\n        var clientQuery = this.transform(query).clientQuery;\n        if (clientQuery) {\n            observable = observables_1.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' && arrays_1.isNonEmptyArray(result.errors)) {\n                    return reject(new ApolloError_1.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_1.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 = tslib_1.__assign(tslib_1.__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 tslib_1.__assign(tslib_1.__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_1.NetworkStatus.ready &&\n            query.networkStatus !== networkStatus_1.NetworkStatus.error);\n    };\n    QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n        var _this = this;\n        var pollInterval = options.pollInterval;\n        ts_invariant_1.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 = tslib_1.__assign(tslib_1.__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, types_1.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}());\nexports.QueryManager = QueryManager;\n//# sourceMappingURL=QueryManager.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\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}());\nexports.MutationStore = MutationStore;\n//# sourceMappingURL=mutations.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar apollo_utilities_1 = require(\"apollo-utilities\");\nvar ts_invariant_1 = require(\"ts-invariant\");\nvar networkStatus_1 = require(\"../core/networkStatus\");\nvar arrays_1 = require(\"../util/arrays\");\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        ts_invariant_1.invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            apollo_utilities_1.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_1.NetworkStatus.loading) {\n            if (!apollo_utilities_1.isEqual(previousQuery.variables, query.variables)) {\n                isSetVariables = true;\n                previousVariables = previousQuery.variables;\n            }\n        }\n        var networkStatus;\n        if (isSetVariables) {\n            networkStatus = networkStatus_1.NetworkStatus.setVariables;\n        }\n        else if (query.isPoll) {\n            networkStatus = networkStatus_1.NetworkStatus.poll;\n        }\n        else if (query.isRefetch) {\n            networkStatus = networkStatus_1.NetworkStatus.refetch;\n        }\n        else {\n            networkStatus = networkStatus_1.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_1.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 = arrays_1.isNonEmptyArray(result.errors) ? result.errors : [];\n        this.store[queryId].previousVariables = null;\n        this.store[queryId].networkStatus = networkStatus_1.NetworkStatus.ready;\n        if (typeof fetchMoreForQueryId === 'string' &&\n            this.store[fetchMoreForQueryId]) {\n            this.store[fetchMoreForQueryId].networkStatus = networkStatus_1.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_1.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_1.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_1.NetworkStatus.loading;\n            }\n        });\n    };\n    return QueryStore;\n}());\nexports.QueryStore = QueryStore;\n//# sourceMappingURL=queries.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar tslib_1 = require(\"tslib\");\nvar apollo_utilities_1 = require(\"apollo-utilities\");\nvar networkStatus_1 = require(\"./networkStatus\");\nvar Observable_1 = require(\"../util/Observable\");\nvar ApolloError_1 = require(\"../errors/ApolloError\");\nvar types_1 = require(\"./types\");\nvar ts_invariant_1 = require(\"ts-invariant\");\nvar arrays_1 = require(\"../util/arrays\");\nexports.hasError = function (storeValue, policy) {\n    if (policy === void 0) { policy = 'none'; }\n    return storeValue && (storeValue.networkError ||\n        (policy === 'none' && arrays_1.isNonEmptyArray(storeValue.graphQLErrors)));\n};\nvar ObservableQuery = (function (_super) {\n    tslib_1.__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 = apollo_utilities_1.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_1.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 (exports.hasError(queryStoreValue, this.options.errorPolicy)) {\n                return {\n                    data: void 0,\n                    loading: false,\n                    networkStatus: networkStatus,\n                    error: new ApolloError_1.ApolloError({\n                        graphQLErrors: queryStoreValue.graphQLErrors,\n                        networkError: queryStoreValue.networkError,\n                    }),\n                };\n            }\n            if (queryStoreValue.variables) {\n                this.options.variables = tslib_1.__assign(tslib_1.__assign({}, this.options.variables), queryStoreValue.variables);\n                this.variables = this.options.variables;\n            }\n            result = {\n                data: data,\n                loading: networkStatus_1.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_1.NetworkStatus.loading : networkStatus_1.NetworkStatus.ready,\n            };\n        }\n        if (!partial) {\n            this.updateLastResult(tslib_1.__assign(tslib_1.__assign({}, result), { stale: false }));\n        }\n        return tslib_1.__assign(tslib_1.__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            apollo_utilities_1.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(new ts_invariant_1.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 (!apollo_utilities_1.isEqual(this.variables, variables)) {\n            this.variables = tslib_1.__assign(tslib_1.__assign({}, this.variables), variables);\n        }\n        if (!apollo_utilities_1.isEqual(this.options.variables, this.variables)) {\n            this.options.variables = tslib_1.__assign(tslib_1.__assign({}, this.options.variables), this.variables);\n        }\n        return this.queryManager.fetchQuery(this.queryId, tslib_1.__assign(tslib_1.__assign({}, this.options), { fetchPolicy: fetchPolicy }), types_1.FetchType.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        ts_invariant_1.invariant(fetchMoreOptions.updateQuery, 'updateQuery option is required. This function defines how to update the query data with the new results.');\n        var combinedOptions = tslib_1.__assign(tslib_1.__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, this.options), fetchMoreOptions), { variables: tslib_1.__assign(tslib_1.__assign({}, this.variables), fetchMoreOptions.variables) }))), { fetchPolicy: 'network-only' });\n        var qid = this.queryManager.generateQueryId();\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, types_1.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                ts_invariant_1.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 = tslib_1.__assign(tslib_1.__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 && apollo_utilities_1.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 = apollo_utilities_1.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            : apollo_utilities_1.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(tslib_1.__assign(tslib_1.__assign({}, _this.lastResult), { errors: error.graphQLErrors, networkStatus: networkStatus_1.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                                !apollo_utilities_1.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_1.Observable));\nexports.ObservableQuery = ObservableQuery;\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    ts_invariant_1.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    ts_invariant_1.invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 'Queries that specify the cache-first and cache-only fetchPolicies cannot also be polling queries.');\n}\n//# sourceMappingURL=ObservableQuery.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction capitalizeFirstLetter(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\nexports.capitalizeFirstLetter = capitalizeFirstLetter;\n//# sourceMappingURL=capitalizeFirstLetter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Observable_1 = require(\"./Observable\");\nfunction multiplex(inner) {\n    var observers = new Set();\n    var sub = null;\n    return new Observable_1.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}\nexports.multiplex = multiplex;\nfunction asyncMap(observable, mapFn) {\n    return new Observable_1.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}\nexports.asyncMap = asyncMap;\n//# sourceMappingURL=observables.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar apollo_utilities_1 = require(\"apollo-utilities\");\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 = !apollo_utilities_1.graphQLResultHasError(result);\n        if (ignoreErrors && apollo_utilities_1.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 (!apollo_utilities_1.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 (!apollo_utilities_1.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 = apollo_utilities_1.tryFunctionOrLogError(function () {\n                            return updater(currentQueryResult, {\n                                mutationResult: mutation.result,\n                                queryName: apollo_utilities_1.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                    apollo_utilities_1.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}());\nexports.DataStore = DataStore;\n//# sourceMappingURL=store.js.map","exports.version = \"2.6.10\""],"sourceRoot":""}