{"version":3,"sources":["webpack://web/./node_modules/@apollo/client/cache/core/cache.js","webpack://web/./node_modules/@apollo/client/cache/core/types/common.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/key-extractor.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/policies.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/object-canon.js","webpack://web/./node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://web/./node_modules/@apollo/client/core/LocalState.js","webpack://web/./node_modules/@apollo/client/core/QueryInfo.js","webpack://web/./node_modules/@apollo/client/core/QueryManager.js","webpack://web/./node_modules/@apollo/client/utilities/common/incrementalResult.js","webpack://web/./node_modules/@apollo/client/core/ApolloClient.js","webpack://web/./node_modules/@apollo/client/version.js","webpack://web/./node_modules/@apollo/client/core/ObservableQuery.js","webpack://web/./node_modules/@apollo/client/cache/core/types/Cache.js","webpack://web/./node_modules/@apollo/client/link/core/empty.js","webpack://web/./node_modules/@apollo/client/link/core/from.js","webpack://web/./node_modules/@apollo/client/link/core/split.js","webpack://web/./node_modules/@apollo/client/link/core/concat.js","webpack://web/./node_modules/@apollo/client/link/utils/toPromise.js","webpack://web/./node_modules/@apollo/client/link/utils/fromPromise.js","webpack://web/./node_modules/@apollo/client/core/index.js","webpack://web/./node_modules/@apollo/client/core/networkStatus.js","webpack://web/./node_modules/@apollo/client/errors/index.js","webpack://web/./node_modules/@apollo/client/link/core/ApolloLink.js","webpack://web/./node_modules/@apollo/client/link/utils/createOperation.js","webpack://web/./node_modules/@apollo/client/link/utils/transformOperation.js","webpack://web/./node_modules/@apollo/client/link/utils/validateOperation.js","webpack://web/./node_modules/@apollo/client/link/core/execute.js","webpack://web/./node_modules/@apollo/client/link/http/HttpLink.js","webpack://web/./node_modules/@apollo/client/link/http/checkFetcher.js","webpack://web/./node_modules/@apollo/client/link/http/createHttpLink.js","webpack://web/./node_modules/@apollo/client/link/http/createSignalIfSupported.js","webpack://web/./node_modules/@apollo/client/link/http/iterators/reader.js","webpack://web/./node_modules/@apollo/client/link/http/responseIterator.js","webpack://web/./node_modules/@apollo/client/link/http/iterators/async.js","webpack://web/./node_modules/@apollo/client/utilities/common/responseIterator.js","webpack://web/./node_modules/@apollo/client/link/http/iterators/promise.js","webpack://web/./node_modules/@apollo/client/link/http/iterators/nodeStream.js","webpack://web/./node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://web/./node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://web/./node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://web/./node_modules/@apollo/client/link/http/selectURI.js","webpack://web/./node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://web/./node_modules/@apollo/client/link/utils/fromError.js","webpack://web/./node_modules/@apollo/client/link/utils/throwServerError.js","webpack://web/./node_modules/@apollo/client/node_modules/graphql-tag/lib/index.js","webpack://web/./node_modules/@apollo/client/node_modules/tslib/tslib.es6.js","webpack://web/./node_modules/@apollo/client/react/context/ApolloContext.js","webpack://web/./node_modules/@apollo/client/react/context/ApolloProvider.js","webpack://web/./node_modules/@apollo/client/react/hooks/useApolloClient.js","webpack://web/./node_modules/@apollo/client/react/hooks/useLazyQuery.js","webpack://web/./node_modules/@apollo/client/react/hooks/useMutation.js","webpack://web/./node_modules/@apollo/client/react/hooks/useSyncExternalStore.js","webpack://web/./node_modules/@apollo/client/react/hooks/useQuery.js","webpack://web/./node_modules/@apollo/client/react/hooks/useReactiveVar.js","webpack://web/./node_modules/@apollo/client/react/parser/index.js","webpack://web/./node_modules/@apollo/client/utilities/common/arrays.js","webpack://web/./node_modules/@apollo/client/utilities/common/canUse.js","webpack://web/./node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://web/./node_modules/@apollo/client/utilities/common/compact.js","webpack://web/./node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://web/./node_modules/@apollo/client/utilities/common/makeUniqueId.js","webpack://web/./node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js","webpack://web/./node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://web/./node_modules/@apollo/client/utilities/common/mergeOptions.js","webpack://web/./node_modules/@apollo/client/utilities/common/objects.js","webpack://web/./node_modules/@apollo/client/utilities/common/stringifyForDisplay.js","webpack://web/./node_modules/@apollo/client/utilities/globals/maybe.js","webpack://web/./node_modules/@apollo/client/utilities/globals/global.js","webpack://web/./node_modules/@apollo/client/utilities/globals/DEV.js","webpack://web/./node_modules/@apollo/client/utilities/globals/fix-graphql.js","webpack://web/./node_modules/@apollo/client/utilities/globals/index.js","webpack://web/./node_modules/@apollo/client/utilities/graphql/directives.js","webpack://web/./node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://web/./node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://web/./node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://web/./node_modules/@apollo/client/utilities/common/filterInPlace.js","webpack://web/./node_modules/@apollo/client/utilities/graphql/transform.js","webpack://web/./node_modules/@apollo/client/utilities/policies/pagination.js","webpack://web/./node_modules/@apollo/client/utilities/observables/Concast.js","webpack://web/./node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://web/./node_modules/@apollo/client/utilities/observables/iteration.js","webpack://web/./node_modules/@apollo/client/utilities/observables/subclassing.js"],"names":["ApolloCache","this","getFragmentDoc","prototype","batch","options","updateResult","_this","optimisticId","optimistic","performTransaction","update","recordOptimisticTransaction","transaction","transformDocument","document","transformForLink","identify","object","gc","modify","readQuery","read","rootId","id","readFragment","query","fragment","fragmentName","writeQuery","_a","data","write","Object","assign","dataId","result","writeFragment","updateQuery","cache","value","updateFragment","MissingFieldError","_super","message","path","variables","call","Array","isArray","missing","i","length","__proto__","Error","hasOwn","hasOwnProperty","isNullish","defaultDataIdFromObject","context","__typename","_id","keyObject","concat","JSON","stringify","defaultConfig","dataIdFromObject","addTypename","resultCaching","canonizeResults","normalizeConfig","config","shouldCanonizeResults","getTypenameFromStoreObject","store","objectOrReference","get","__ref","TypeOrFieldNameRegExp","fieldNameFromStoreName","storeFieldName","match","selectionSetMatchesResult","selectionSet","every","item","selections","field","key","storeValueIsStoreObject","makeProcessedFieldsMerger","extractFragmentContext","fragments","fragmentMap","lookupFragment","name","def","lookup","DELETE","create","delModifier","INVALIDATE","EntityStore","policies","group","rootIds","refs","getFieldValue","maybeDeepFreeze","canRead","objOrRef","has","toReference","objOrIdOrRef","mergeIntoStore","ref","merge","toObject","fieldName","depend","storeObject","rootTypenamesById","Layer","parent","dependOnExistence","older","newer","existing","incoming","__DEV__","merged","storeObjectReconciler","caching","fieldsToDirty_1","__exists","keys","forEach","hasKeyArgs","dirty","fields","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","isReference","readField","fieldNameOrOptions","from","fieldValue","newValue","storage","getStorage","delete","args","typename","getStoreFieldName","evict","limit","evicted","clear","replace","extract","obj","extraRootIds","getRootIdSet","push","__META","sort","newData","rest_1","retain","release","count","ids","Set","add","snapshot","findChildRefIds","idsToRemove","root_1","found_1","root","workSet_1","child","makeCacheKey","keyMaker","lookupArray","arguments","CacheGroup","d","resetCaching","canUse","makeDepKey","maybeDependOnExistenceOfEntity","entityId","supportsResultCaching","Root","_b","seed","stump","Stump","storageTrie","addLayer","layerId","replay","removeLayer","ownStoreObject","parentStoreObject","fromParent","p","apply","existingObject","incomingObject","property","existingValue","incomingValue","execSelectionSetKeyArgs","StoreReader","knownResults","WeakMap","Map","compact","canon","executeSelectionSet","peekArgs","other","peek","admit","enclosingRef","execSelectionSetImpl","max","resultCacheMaxSize","keyArgs","varString","executeSubSelectedArray","execSubSelectedArrayImpl","array","resetCanon","diffQueryAgainstStore","_c","returnPartialData","_d","rootRef","execResult","firstMissing","complete","isFresh","latest","isKnown","empty","objectsToMerge","missingMerger","handleMissing","resultName","rootIdsByTypename","workSet","selection","pass","kind","fragmentMatches","finalResult","mergeDeep","frozen","set","childResult","filter","map","values","assertSelectionSetForIdValue","tree","_","specifierInfoCache","lookupSpecifierInfo","spec","cacheKey","keyFieldsFnFromSpecifier","specifier","info","keyFieldsFn","collectSpecifierPaths","schemaKeyPath","extracted","extractKeyPath","extractKey","join","keyArgsFnFromSpecifier","keyArgsFn","collected","keyPath","firstKey","firstChar","charAt","variableName","slice","varKeyPath","directives","directiveName_1","find","directiveArgs","suffix","extractor","merger","getSpecifierPaths","reduce","toMerge","paths","paths_1","currentPath_1","s","normalize","reducer","argsFromFieldSpecifier","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","Policies","typePolicies","toBeAdded","supertypeMap","fuzzySubtypes","usingPossibleTypes","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","partialContext","ROOT_QUERY","normalizeReadFieldOptions","policy","getTypePolicy","keyFn","specifierOrId","String","queryType","mutationType","subscriptionType","updateTypePolicy","keyFields","setMerge","getFieldPolicy","which","toUpperCase","old","supertype","getSupertypeSet","subtype","RegExp","policy_1","supertypes","size","rest","inbox","splice","createIfMissing","fieldPolicies","supertypeSet","typeCondition","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","indexOf","needToCheckFuzzySubtypes","checkingFuzzySubtypes","regExp","fuzzyString","fieldSpec","specifierOrString","readOptions","makeFieldFunctionOptions","getReadFunction","getMergeFunction","parentTypename","childTypename","runMergeFunction","makeMergeObjectsFunction","overwrite","readFieldArgs","argc","stringifyForDisplay","eType","iType","getContextFlavor","clientOnly","deferred","flavored","flavors","StoreWriter","reader","writeToStore","operationDefinition","written","incomingById","processSelectionSet","mergeTree","fieldNodeSet","entityRef","applied","applyMerges","fieldsWithSelectionSets_1","hasSelectionSet_1","childTree","Boolean","hasMergeFunction_1","existingRef","incomingObj","getChild","parentType","typeDotName","warnings","childTypenames","includes","warnAboutDataLoss","result_1","flattenFields","resultFieldKey","getChildMergeTree","processFieldValue","maybeRecycleChildMergeTree","substring","e","dataRef","sets","previous_1","mergeMergeTrees","mergeTreeIsEmpty","cloneDeep","fieldMap","limitingTrie","flatten","inheritedContext","visitedNode","visited","dir","if","getStorageArgs","e_1","i_1","getValue_1","eVal","iVal","aVal","pop","emptyMergeTreePool","left","right","needToMergeMaps","remainingRightKeys_1","leftTree","InMemoryCache","watches","typenameDocumentCache","makeVar","txCount","init","rootStore","optimisticData","resetResultCache","resetResultIdentities","previousReader","storeReader","storeWriter","maybeBroadcastWatch","c","broadcastWatch","callback","restore","broadcast","broadcastWatches","diff","watch","immediate","forget","reset","discardWatches","Promise","resolve","removeOptimistic","idToRemove","newOptimisticData","onWatchUpdated","perform","layer","alreadyDirty","transform","lastDiff","fromOptimisticTransaction","stringifyCanon","stringifyCache","ObjectCanon","known","WeakSet","pool","passes","keysByJSON","copy","getPrototypeOf","shallowCopy","original","node","freeze","proto_1","array_1","sortedKeys","json","firstValueIndex_1","sorted","obj_1","canonicalStringify","resetCanonicalStringify","canonical","cacheSlot","cacheInfoMap","getCacheInfo","vars","dep","forgetCache","rv","recallCache","attachCache","caches","listeners","oldListeners","listener","getValue","attach","onNextChange","LocalState","client","resolvers","fragmentMatcher","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","resolveDocument","then","localResult","getFragmentMatcher","clientQuery","serverQuery","prepareContext","getCacheKey","addExportedVariables","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","Directive","enter","some","arg","rootValue","mainDefinition","definitionOperation","defaultOperationType","execContext","operation","resolveSelectionSet","resultsToMerge","execute","resolveField","fieldResult","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directive","resolveSubSelectedArray","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","cancelNotifyTimeout","clearTimeout","QueryInfo","queryManager","queryId","generateQueryId","lastRequestId","subscriptions","stopped","observableQuery","networkStatus","networkError","graphQLErrors","setObservableQuery","getDiff","getDiffOptions","updateWatch","oq","fetchPolicy","updateLastDiff","setDiff","oldDiff","notifyTimeout","setTimeout","notify","oqListener","shouldNotify","stop","cancel","sub","unsubscribe","stopPolling","watchOptions","watcher","lastWatch","resetLastWrite","lastWrite","shouldWrite","dmCount","markResult","cacheWriteBehavior","errors","incremental","mergedData_1","merger_1","parent_1","isNaN","shouldWriteResult","errorPolicy","diffOptions","markReady","markError","error","ignoreErrors","writeWithErrors","QueryManager","link","defaultOptions","queryDeduplication","onBroadcast","ssrMode","clientAwareness","localState","assumeImmutableResults","queries","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","mutationStore","_info","stopQueryNoBroadcast","cancelPendingFetches","mutate","mutation","optimisticResponse","updateQueries","refetchQueries","_e","awaitRefetchQueries","updateWithProxyFn","onQueryUpdated","_f","_g","keepRootFields","mutationId","_h","hasClientExports","mutationStoreValue","self","_j","label","generateMutationId","getVariables","sent","loading","markMutationOptimistic","broadcastQueries","reject","asyncMap","getObservableFromLink","storeResult","markMutationResult","subscribe","next","err","cacheWrites","skipCache","updateQueries_1","queryName","updater","currentQueryResult","nextQueryResult","mutationResult","queryVariables","results_1","updateCache","asQuery","include","fetchQuery","fetchQueryObservable","promise","getQueryStore","resetErrors","queryInfo","undefined","transformed","noConnection","cacheEntry_1","hasForcedResolvers","defaultVars","definitions","doc","watchQuery","notifyOnNetworkStatusChange","observable","ObservableQuery","pollInterval","finally","stopQuery","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","getObservableQueries","queryNamesAndDocs","legacyQueryOptions","desc","hasObservers","makeUniqueId","getQuery","included","nameOrDoc","reFetchObservableQueries","includeStandby","observableQueryPromises","resetLastResults","refetch","startGraphQLSubscription","makeObservable","observablePromise_1","observer","removeQuery","getLocalState","deduplication","inFlightLinkObservables_1","operationName","forceFetch","byVariables_1","varJson_1","concast","Concast","beforeNext","getResultsFromLink","requestId","linkDocument","incrementalResult","hasErrors","aqr","defaults","normalized","fromVariables","concastSources","fetchQueryByPolicy","cleanupCancelFn","reason","includedQueriesById","results","refetchWritePolicy","oldNetworkStatus","readCache","resultsFromCache","fromData","partial","resolved","resultsFromLink","newContext","hasSuggestedDevtools","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","window","__APOLLO_CLIENT__","typeDefs","clientAwarenessName","clientAwarenessVersion","version","HttpLink","ApolloLink","disableNetworkFetches","bind","resetStore","top","__APOLLO_DEVTOOLS_GLOBAL_HOOK__","nav","navigator","ua","userAgent","url","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","mergeOptions","__actionHookForDevTools","cb","__requestRaw","payload","fn","onResetStore","onClearStore","obsQuery","catch","serializedState","setLocalStateFragmentMatcher","setLink","newLink","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","observers","last","reobserve","tearDownQuery","isTornDown","defaultFetchPolicy","initialFetchPolicy","opDef","defineProperty","enumerable","configurable","subscription","getCurrentResult","saveAsLastResult","lastResult","getLastResult","partialRefetch","logMissingFieldErrors","updateLastResult","isDifferentFromLastResult","newResult","getLast","variablesMustMatch","getLastError","resetQueryStoreErrors","reobserveOptions","queryDef","variableDefinitions","v","variable","fetchMore","fetchMoreOptions","combinedOptions","qid","originalNetworkStatus","observe","updatedQuerySet","fetchMoreResult","previous","reobserveCacheFirst","subscribeToMore","subscriptionData","onError","setOptions","newOptions","setVariables","mapFn","startPolling","updatePolling","applyNextFetchPolicy","nextFetchPolicy","fetch","newNetworkStatus","pollingInfo","interval","maybeFetch","poll","timeout","useDisposableConcast","oldVariables","oldFetchPolicy","mergedOptions","reportResult","reportError","removeObserver","addObserver","lastError","errorResult","stack","Cache","split","toPromise","completed","fromPromise","NetworkStatus","isNetworkRequestInFlight","isApolloError","ApolloError","clientErrors","errorMessage","extraInfo","passthrough","op","forward","toLink","handler","isTerminating","request","LinkError","links","x","y","test","leftLink","rightLink","starting","createOperation","transformedOperation","extensions","transformOperation","OPERATION_FIELDS","_i","validateOperation","second","firstLink","nextLink","setOnError","checkFetcher","fetcher","backupFetch","createHttpLink","linkOptions","preferredFetch","print","includeExtensions","preserveHeaderCase","useGETForQueries","includeUnusedVariables","requestOptions","linkConfig","http","fetchOptions","chosenURI","getContext","clientAwarenessHeaders","name_1","controller","contextHeaders","contextConfig","body","unusedNames_1","Variable","_key","signal","_controller","method","accept","newURI","parseError","response","setContext","ctype","abort","createSignalIfSupported","AbortController","readerIterator","iterator","Symbol","asyncIterator","responseIterator","getReader","isReadableStream","stream","isStreamableBlob","arrayBuffer","isBlob","done","promiseIterator","pipe","isNodeReadableStream","cleanup","waiting","onData","chunk","shiftedArr","shift","pair","onEnd","removeListener","on","nodeStreamIterator","readMultipartBody","decoder","contentType","delimiter","boundaryVal","boundary","buffer","running","bi","contentType_1","TextDecoder","trim","decode","parseHeaders","toLowerCase","parseJsonBody","handleError","headerText","headersInit","line","bodyText","status","throwServerError","parse","getResult","statusCode","readJsonBody","parseAndCheckHttpResponse","operations","text","rewriteURIForGET","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","fallbackHttpConfig","includeQuery","defaultPrinter","ast","printer","selectHttpOptionsAndBody","fallbackConfig","configs","unshift","selectHttpOptionsAndBodyInternal","removeDuplicateHeaders","normalizedHeaders_1","headerData","originalName","normalizedHeaders","selectURI","fallbackURI","serializeFetchParameter","serialized","fromError","errorValue","docCache","fragmentSourceMap","printFragmentWarnings","experimentalFragmentVariables","string","parseDocument","source","seenKeys","parsed","allowLegacyFragmentVariables","loc","startToken","endToken","stripLoc","fragmentDefinition","sourceKey","start","end","sourceKeySet","console","warn","gql","literals","resetCaches","disableFragmentWarnings","enableExperimentalFragmentVariables","disableExperimentalFragmentVariables","gql_1","extras","extendStatics","b","setPrototypeOf","__extends","TypeError","__","constructor","__assign","t","n","__rest","getOwnPropertySymbols","propertyIsEnumerable","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","__generator","f","g","trys","ops","verb","__spreadArray","to","pack","ar","l","contextKey","for","getApolloContext","writable","displayName","ApolloProvider","children","ApolloContext","Consumer","Provider","useApolloClient","override","useContext","EAGER_METHODS","useLazyQuery","internalState","execOptionsRef","useRef","current","useQueryResult","useQuery","skip","getDefaultFetchPolicy","called","eagerMethods","useMemo","_loop_1","forceUpdate","EAGER_METHODS_1","useCallback","executeOptions","asyncUpdate","queryResult","useMutation","useState","setResult","isMounted","baseOptions","ignoreResults","clientOptions","onCompleted","result_2","useEffect","didWarnUncachedGetSnapshot","useSyncExternalStore","getSnapshot","getServerSnapshot","inst","checkIfSnapshotChanged","useInternalState","stateRef","InternalState","setTick","tick","asyncResolveFns","optionsToIgnoreOnce","ssrDisabledResult","skipStandbyResult","toQueryResultCache","previousResult","previousData","watchQueryOptions","renderPromises","useOptions","useObservableQuery","onNext","unsafeHandlePartialRefetch","toQueryResult","createWatchQueryOptions","queryHookOptions","currentWatchQueryOptions","getObsQueryOptions","ssr","globalDefaults","otherOptions","getSSRObservable","obsQueryFields","ssrAllowed","registerSSRObservable","addObservableQueryPromise","nextResult","handleErrorOrCompleted","resultWithoutPartial","useReactiveVar","setValue","probablySameValue","DocumentType","type","Query","Mutation","Subscription","verifyDocumentType","cached","definition","parser","requiredOperationName","usedOperationName","isNonEmptyArray","canUseWeakMap","product","canUseWeakSet","canUseSymbol","canUseAsyncIteratorSymbol","canUseDOM","createElement","usingJSDOM","canUseLayoutEffect","toString","cloneDeepHelper","val","seen","copy_1","copy_2","objects","graphQLResultHasError","prefixCounts","prefix","Math","random","isFrozen","shallowFreeze","getOwnPropertyNames","sources","mergeDeepArray","target","DeepMerger","defaultReconciler","reconciler","isObject","pastCopies","targetValue","shallowCopyForMerge","isNonNullObject","undefId","maybe","thunk","globalThis","global","GLOBAL_KEY","invariant","DEV","shouldInclude","getInclusionDirectives","ifArgument","evaledValue","getDirectiveNames","names","hasAnyDirectives","hasDirectives","hasAllDirectives","nameSet","uniqueCount","directiveArguments","directiveName","ifValue","getFragmentQueryDocument","actualFragmentName","createFragmentMap","symTable","getFragmentFromSelection","checkDocument","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","getDefaultValues","defaultValues","defs","defaultValue","makeReference","isDocumentNode","valueToObjectRepresentation","argObj","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","isVariable","variableValue","isListValue","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","filterKeys","filteredArgs_1","completeFieldName","stringifiedArgs","setStringify","stringifyReplacer","argumentsObjectFromField","argObj_1","resultKeyNameFromField","alias","getTypenameFromResult","isField","isInlineFragment","filterInPlace","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getDirectiveMatcher","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Field","remove","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","added","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","FragmentDefinition","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","concatPagination","offsetLimitPagination","offset","relayStylePagination","edges","firstEdgeCursor","lastEdgeCursor","edge","cursor","pageInfo","startCursor","endCursor","getExtras","hasPreviousPage","hasNextPage","incomingEdges","pageInfo_1","firstEdge","lastEdge","firstCursor","lastCursor","after","index","findIndex","before","notExtras","isPromiseLike","handlers","obs","nextResultListeners","iterable","deliverLastMessage","nextOrError","catchFn","activeCallbackCount","promiseQueue","makeCallback","examiner","delegate","both","caught","iterateObserversSafely","observersWithMethod","fixObservableSubclass","subclass","species"],"mappings":"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","file":"npm.apollo.56c2b17f4c6268517a04.react.bundle.js","sourcesContent":["import { __assign, __rest } from \"tslib\";\nimport { wrap } from 'optimism';\nimport { getFragmentQueryDocument, } from \"../../utilities/index.js\";\nvar ApolloCache = (function () {\n    function ApolloCache() {\n        this.getFragmentDoc = wrap(getFragmentQueryDocument);\n    }\n    ApolloCache.prototype.batch = function (options) {\n        var _this = this;\n        var optimisticId = typeof options.optimistic === \"string\" ? options.optimistic :\n            options.optimistic === false ? null : void 0;\n        var updateResult;\n        this.performTransaction(function () { return updateResult = options.update(_this); }, optimisticId);\n        return updateResult;\n    };\n    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {\n        this.performTransaction(transaction, optimisticId);\n    };\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.identify = function (object) {\n        return;\n    };\n    ApolloCache.prototype.gc = function () {\n        return [];\n    };\n    ApolloCache.prototype.modify = function (options) {\n        return false;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { rootId: options.id || 'ROOT_QUERY', optimistic: optimistic }));\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));\n    };\n    ApolloCache.prototype.writeQuery = function (_a) {\n        var id = _a.id, data = _a.data, options = __rest(_a, [\"id\", \"data\"]);\n        return this.write(Object.assign(options, {\n            dataId: id || 'ROOT_QUERY',\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.writeFragment = function (_a) {\n        var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = __rest(_a, [\"id\", \"data\", \"fragment\", \"fragmentName\"]);\n        return this.write(Object.assign(options, {\n            query: this.getFragmentDoc(fragment, fragmentName),\n            dataId: id,\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.updateQuery = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readQuery(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeQuery(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    ApolloCache.prototype.updateFragment = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readFragment(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeFragment(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    return ApolloCache;\n}());\nexport { ApolloCache };\n//# sourceMappingURL=cache.js.map","import { __extends } from \"tslib\";\nvar MissingFieldError = (function (_super) {\n    __extends(MissingFieldError, _super);\n    function MissingFieldError(message, path, query, variables) {\n        var _a;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.path = path;\n        _this.query = query;\n        _this.variables = variables;\n        if (Array.isArray(_this.path)) {\n            _this.missing = _this.message;\n            for (var i = _this.path.length - 1; i >= 0; --i) {\n                _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);\n            }\n        }\n        else {\n            _this.missing = _this.path;\n        }\n        _this.__proto__ = MissingFieldError.prototype;\n        return _this;\n    }\n    return MissingFieldError;\n}(Error));\nexport { MissingFieldError };\n//# sourceMappingURL=common.js.map","import { isReference, isField, DeepMerger, resultKeyNameFromField, shouldInclude, isNonNullObject, compact, createFragmentMap, getFragmentDefinitions, } from \"../../utilities/index.js\";\nexport var hasOwn = Object.prototype.hasOwnProperty;\nexport function isNullish(value) {\n    return value === null || value === void 0;\n}\nexport var isArray = Array.isArray;\nexport function defaultDataIdFromObject(_a, context) {\n    var __typename = _a.__typename, id = _a.id, _id = _a._id;\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                !isNullish(id) ? { id: id } :\n                    !isNullish(_id) ? { _id: _id } :\n                        void 0;\n        }\n        if (isNullish(id) && !isNullish(_id)) {\n            id = _id;\n        }\n        if (!isNullish(id)) {\n            return \"\".concat(__typename, \":\").concat((typeof id === \"number\" ||\n                typeof id === \"string\") ? id : JSON.stringify(id));\n        }\n    }\n}\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    canonizeResults: false,\n};\nexport function normalizeConfig(config) {\n    return compact(defaultConfig, config);\n}\nexport function shouldCanonizeResults(config) {\n    var value = config.canonizeResults;\n    return value === void 0 ? defaultConfig.canonizeResults : value;\n}\nexport function getTypenameFromStoreObject(store, objectOrReference) {\n    return isReference(objectOrReference)\n        ? store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nexport var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;\nexport function fieldNameFromStoreName(storeFieldName) {\n    var match = storeFieldName.match(TypeOrFieldNameRegExp);\n    return match ? match[0] : storeFieldName;\n}\nexport function selectionSetMatchesResult(selectionSet, result, variables) {\n    if (isNonNullObject(result)) {\n        return isArray(result)\n            ? result.every(function (item) { return selectionSetMatchesResult(selectionSet, item, variables); })\n            : selectionSet.selections.every(function (field) {\n                if (isField(field) && shouldInclude(field, variables)) {\n                    var key = resultKeyNameFromField(field);\n                    return hasOwn.call(result, key) &&\n                        (!field.selectionSet ||\n                            selectionSetMatchesResult(field.selectionSet, result[key], variables));\n                }\n                return true;\n            });\n    }\n    return false;\n}\nexport function storeValueIsStoreObject(value) {\n    return isNonNullObject(value) &&\n        !isReference(value) &&\n        !isArray(value);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger;\n}\nexport function extractFragmentContext(document, fragments) {\n    var fragmentMap = createFragmentMap(getFragmentDefinitions(document));\n    return {\n        fragmentMap: fragmentMap,\n        lookupFragment: function (name) {\n            var def = fragmentMap[name];\n            if (!def && fragments) {\n                def = fragments.lookup(name);\n            }\n            return def || null;\n        },\n    };\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __extends, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { dep } from 'optimism';\nimport { equal } from '@wry/equality';\nimport { Trie } from '@wry/trie';\nimport { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName } from \"./helpers.js\";\nvar DELETE = Object.create(null);\nvar delModifier = function () { return DELETE; };\nvar INVALIDATE = Object.create(null);\nvar EntityStore = (function () {\n    function EntityStore(policies, group) {\n        var _this = this;\n        this.policies = policies;\n        this.group = group;\n        this.data = Object.create(null);\n        this.rootIds = Object.create(null);\n        this.refs = Object.create(null);\n        this.getFieldValue = function (objectOrReference, storeFieldName) { return maybeDeepFreeze(isReference(objectOrReference)\n            ? _this.get(objectOrReference.__ref, storeFieldName)\n            : objectOrReference && objectOrReference[storeFieldName]); };\n        this.canRead = function (objOrRef) {\n            return isReference(objOrRef)\n                ? _this.has(objOrRef.__ref)\n                : typeof objOrRef === \"object\";\n        };\n        this.toReference = function (objOrIdOrRef, mergeIntoStore) {\n            if (typeof objOrIdOrRef === \"string\") {\n                return makeReference(objOrIdOrRef);\n            }\n            if (isReference(objOrIdOrRef)) {\n                return objOrIdOrRef;\n            }\n            var id = _this.policies.identify(objOrIdOrRef)[0];\n            if (id) {\n                var ref = makeReference(id);\n                if (mergeIntoStore) {\n                    _this.merge(id, objOrIdOrRef);\n                }\n                return ref;\n            }\n        };\n    }\n    EntityStore.prototype.toObject = function () {\n        return __assign({}, this.data);\n    };\n    EntityStore.prototype.has = function (dataId) {\n        return this.lookup(dataId, true) !== void 0;\n    };\n    EntityStore.prototype.get = function (dataId, fieldName) {\n        this.group.depend(dataId, fieldName);\n        if (hasOwn.call(this.data, dataId)) {\n            var storeObject = this.data[dataId];\n            if (storeObject && hasOwn.call(storeObject, fieldName)) {\n                return storeObject[fieldName];\n            }\n        }\n        if (fieldName === \"__typename\" &&\n            hasOwn.call(this.policies.rootTypenamesById, dataId)) {\n            return this.policies.rootTypenamesById[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.get(dataId, fieldName);\n        }\n    };\n    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        if (hasOwn.call(this.data, dataId)) {\n            return this.data[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.lookup(dataId, dependOnExistence);\n        }\n        if (this.policies.rootTypenamesById[dataId]) {\n            return Object.create(null);\n        }\n    };\n    EntityStore.prototype.merge = function (older, newer) {\n        var _this = this;\n        var dataId;\n        if (isReference(older))\n            older = older.__ref;\n        if (isReference(newer))\n            newer = newer.__ref;\n        var existing = typeof older === \"string\"\n            ? this.lookup(dataId = older)\n            : older;\n        var incoming = typeof newer === \"string\"\n            ? this.lookup(dataId = newer)\n            : newer;\n        if (!incoming)\n            return;\n        __DEV__ ? invariant(typeof dataId === \"string\", \"store.merge expects a string ID\") : invariant(typeof dataId === \"string\", 1);\n        var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);\n        this.data[dataId] = merged;\n        if (merged !== existing) {\n            delete this.refs[dataId];\n            if (this.group.caching) {\n                var fieldsToDirty_1 = Object.create(null);\n                if (!existing)\n                    fieldsToDirty_1.__exists = 1;\n                Object.keys(incoming).forEach(function (storeFieldName) {\n                    if (!existing || existing[storeFieldName] !== merged[storeFieldName]) {\n                        fieldsToDirty_1[storeFieldName] = 1;\n                        var fieldName = fieldNameFromStoreName(storeFieldName);\n                        if (fieldName !== storeFieldName &&\n                            !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {\n                            fieldsToDirty_1[fieldName] = 1;\n                        }\n                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                if (fieldsToDirty_1.__typename &&\n                    !(existing && existing.__typename) &&\n                    this.policies.rootTypenamesById[dataId] === merged.__typename) {\n                    delete fieldsToDirty_1.__typename;\n                }\n                Object.keys(fieldsToDirty_1).forEach(function (fieldName) { return _this.group.dirty(dataId, fieldName); });\n            }\n        }\n    };\n    EntityStore.prototype.modify = function (dataId, fields) {\n        var _this = this;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var changedFields_1 = Object.create(null);\n            var needToMerge_1 = false;\n            var allDeleted_1 = true;\n            var sharedDetails_1 = {\n                DELETE: DELETE,\n                INVALIDATE: INVALIDATE,\n                isReference: isReference,\n                toReference: this.toReference,\n                canRead: this.canRead,\n                readField: function (fieldNameOrOptions, from) { return _this.policies.readField(typeof fieldNameOrOptions === \"string\" ? {\n                    fieldName: fieldNameOrOptions,\n                    from: from || makeReference(dataId),\n                } : fieldNameOrOptions, { store: _this }); },\n            };\n            Object.keys(storeObject).forEach(function (storeFieldName) {\n                var fieldName = fieldNameFromStoreName(storeFieldName);\n                var fieldValue = storeObject[storeFieldName];\n                if (fieldValue === void 0)\n                    return;\n                var modify = typeof fields === \"function\"\n                    ? fields\n                    : fields[storeFieldName] || fields[fieldName];\n                if (modify) {\n                    var newValue = modify === delModifier ? DELETE :\n                        modify(maybeDeepFreeze(fieldValue), __assign(__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) }));\n                    if (newValue === INVALIDATE) {\n                        _this.group.dirty(dataId, storeFieldName);\n                    }\n                    else {\n                        if (newValue === DELETE)\n                            newValue = void 0;\n                        if (newValue !== fieldValue) {\n                            changedFields_1[storeFieldName] = newValue;\n                            needToMerge_1 = true;\n                            fieldValue = newValue;\n                        }\n                    }\n                }\n                if (fieldValue !== void 0) {\n                    allDeleted_1 = false;\n                }\n            });\n            if (needToMerge_1) {\n                this.merge(dataId, changedFields_1);\n                if (allDeleted_1) {\n                    if (this instanceof Layer) {\n                        this.data[dataId] = void 0;\n                    }\n                    else {\n                        delete this.data[dataId];\n                    }\n                    this.group.dirty(dataId, \"__exists\");\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    EntityStore.prototype.delete = function (dataId, fieldName, args) {\n        var _a;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var typename = this.getFieldValue(storeObject, \"__typename\");\n            var storeFieldName = fieldName && args\n                ? this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ? (_a = {},\n                _a[storeFieldName] = delModifier,\n                _a) : delModifier);\n        }\n        return false;\n    };\n    EntityStore.prototype.evict = function (options, limit) {\n        var evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer && this !== limit) {\n                evicted = this.parent.evict(options, limit) || evicted;\n            }\n            if (options.fieldName || evicted) {\n                this.group.dirty(options.id, options.fieldName || \"__exists\");\n            }\n        }\n        return evicted;\n    };\n    EntityStore.prototype.clear = function () {\n        this.replace(null);\n    };\n    EntityStore.prototype.extract = function () {\n        var _this = this;\n        var obj = this.toObject();\n        var extraRootIds = [];\n        this.getRootIdSet().forEach(function (id) {\n            if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {\n                extraRootIds.push(id);\n            }\n        });\n        if (extraRootIds.length) {\n            obj.__META = { extraRootIds: extraRootIds.sort() };\n        }\n        return obj;\n    };\n    EntityStore.prototype.replace = function (newData) {\n        var _this = this;\n        Object.keys(this.data).forEach(function (dataId) {\n            if (!(newData && hasOwn.call(newData, dataId))) {\n                _this.delete(dataId);\n            }\n        });\n        if (newData) {\n            var __META = newData.__META, rest_1 = __rest(newData, [\"__META\"]);\n            Object.keys(rest_1).forEach(function (dataId) {\n                _this.merge(dataId, rest_1[dataId]);\n            });\n            if (__META) {\n                __META.extraRootIds.forEach(this.retain, this);\n            }\n        }\n    };\n    EntityStore.prototype.retain = function (rootId) {\n        return this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1;\n    };\n    EntityStore.prototype.release = function (rootId) {\n        if (this.rootIds[rootId] > 0) {\n            var count = --this.rootIds[rootId];\n            if (!count)\n                delete this.rootIds[rootId];\n            return count;\n        }\n        return 0;\n    };\n    EntityStore.prototype.getRootIdSet = function (ids) {\n        if (ids === void 0) { ids = new Set(); }\n        Object.keys(this.rootIds).forEach(ids.add, ids);\n        if (this instanceof Layer) {\n            this.parent.getRootIdSet(ids);\n        }\n        else {\n            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);\n        }\n        return ids;\n    };\n    EntityStore.prototype.gc = function () {\n        var _this = this;\n        var ids = this.getRootIdSet();\n        var snapshot = this.toObject();\n        ids.forEach(function (id) {\n            if (hasOwn.call(snapshot, id)) {\n                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);\n                delete snapshot[id];\n            }\n        });\n        var idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            var root_1 = this;\n            while (root_1 instanceof Layer)\n                root_1 = root_1.parent;\n            idsToRemove.forEach(function (id) { return root_1.delete(id); });\n        }\n        return idsToRemove;\n    };\n    EntityStore.prototype.findChildRefIds = function (dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            var found_1 = this.refs[dataId] = Object.create(null);\n            var root = this.data[dataId];\n            if (!root)\n                return found_1;\n            var workSet_1 = new Set([root]);\n            workSet_1.forEach(function (obj) {\n                if (isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                }\n                if (isNonNullObject(obj)) {\n                    Object.keys(obj).forEach(function (key) {\n                        var child = obj[key];\n                        if (isNonNullObject(child)) {\n                            workSet_1.add(child);\n                        }\n                    });\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        return this.group.keyMaker.lookupArray(arguments);\n    };\n    return EntityStore;\n}());\nexport { EntityStore };\nvar CacheGroup = (function () {\n    function CacheGroup(caching, parent) {\n        if (parent === void 0) { parent = null; }\n        this.caching = caching;\n        this.parent = parent;\n        this.d = null;\n        this.resetCaching();\n    }\n    CacheGroup.prototype.resetCaching = function () {\n        this.d = this.caching ? dep() : null;\n        this.keyMaker = new Trie(canUseWeakMap);\n    };\n    CacheGroup.prototype.depend = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n            var fieldName = fieldNameFromStoreName(storeFieldName);\n            if (fieldName !== storeFieldName) {\n                this.d(makeDepKey(dataId, fieldName));\n            }\n            if (this.parent) {\n                this.parent.depend(dataId, storeFieldName);\n            }\n        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName), storeFieldName === \"__exists\" ? \"forget\" : \"setDirty\");\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    return storeFieldName + '#' + dataId;\n}\nexport function maybeDependOnExistenceOfEntity(store, entityId) {\n    if (supportsResultCaching(store)) {\n        store.group.depend(entityId, \"__exists\");\n    }\n}\n(function (EntityStore) {\n    var Root = (function (_super) {\n        __extends(Root, _super);\n        function Root(_a) {\n            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;\n            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;\n            _this.stump = new Stump(_this);\n            _this.storageTrie = new Trie(canUseWeakMap);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            return this.stump.addLayer(layerId, replay);\n        };\n        Root.prototype.removeLayer = function () {\n            return this;\n        };\n        Root.prototype.getStorage = function () {\n            return this.storageTrie.lookupArray(arguments);\n        };\n        return Root;\n    }(EntityStore));\n    EntityStore.Root = Root;\n})(EntityStore || (EntityStore = {}));\nvar Layer = (function (_super) {\n    __extends(Layer, _super);\n    function Layer(id, parent, replay, group) {\n        var _this = _super.call(this, parent.policies, group) || this;\n        _this.id = id;\n        _this.parent = parent;\n        _this.replay = replay;\n        _this.group = group;\n        replay(_this);\n        return _this;\n    }\n    Layer.prototype.addLayer = function (layerId, replay) {\n        return new Layer(layerId, this, replay, this.group);\n    };\n    Layer.prototype.removeLayer = function (layerId) {\n        var _this = this;\n        var parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                Object.keys(this.data).forEach(function (dataId) {\n                    var ownStoreObject = _this.data[dataId];\n                    var parentStoreObject = parent[\"lookup\"](dataId);\n                    if (!parentStoreObject) {\n                        _this.delete(dataId);\n                    }\n                    else if (!ownStoreObject) {\n                        _this.group.dirty(dataId, \"__exists\");\n                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {\n                            _this.group.dirty(dataId, storeFieldName);\n                        });\n                    }\n                    else if (ownStoreObject !== parentStoreObject) {\n                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {\n                            if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {\n                                _this.group.dirty(dataId, storeFieldName);\n                            }\n                        });\n                    }\n                });\n            }\n            return parent;\n        }\n        if (parent === this.parent)\n            return this;\n        return parent.addLayer(this.id, this.replay);\n    };\n    Layer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    Layer.prototype.findChildRefIds = function (dataId) {\n        var fromParent = this.parent.findChildRefIds(dataId);\n        return hasOwn.call(this.data, dataId) ? __assign(__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;\n    };\n    Layer.prototype.getStorage = function () {\n        var p = this.parent;\n        while (p.parent)\n            p = p.parent;\n        return p.getStorage.apply(p, arguments);\n    };\n    return Layer;\n}(EntityStore));\nvar Stump = (function (_super) {\n    __extends(Stump, _super);\n    function Stump(root) {\n        return _super.call(this, \"EntityStore.Stump\", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;\n    }\n    Stump.prototype.removeLayer = function () {\n        return this;\n    };\n    Stump.prototype.merge = function () {\n        return this.parent.merge.apply(this.parent, arguments);\n    };\n    return Stump;\n}(Layer));\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    var existingValue = existingObject[property];\n    var incomingValue = incomingObject[property];\n    return equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nexport function supportsResultCaching(store) {\n    return !!(store instanceof EntityStore && store.group.caching);\n}\n//# sourceMappingURL=entityStore.js.map","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from \"../../utilities/globals/index.js\";\nimport { Kind, } from 'graphql';\nimport { wrap } from 'optimism';\nimport { isField, resultKeyNameFromField, isReference, makeReference, shouldInclude, addTypenameToDocument, getDefaultValues, getMainDefinition, getQueryDefinition, getFragmentFromSelection, maybeDeepFreeze, mergeDeepArray, DeepMerger, isNonNullObject, canUseWeakMap, compact, } from \"../../utilities/index.js\";\nimport { maybeDependOnExistenceOfEntity, supportsResultCaching } from \"./entityStore.js\";\nimport { isArray, extractFragmentContext, getTypenameFromStoreObject, shouldCanonizeResults } from \"./helpers.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { canonicalStringify, ObjectCanon } from \"./object-canon.js\";\n;\nfunction execSelectionSetKeyArgs(options) {\n    return [\n        options.selectionSet,\n        options.objectOrReference,\n        options.context,\n        options.context.canonizeResults,\n    ];\n}\nvar StoreReader = (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.knownResults = new (canUseWeakMap ? WeakMap : Map)();\n        this.config = compact(config, {\n            addTypename: config.addTypename !== false,\n            canonizeResults: shouldCanonizeResults(config),\n        });\n        this.canon = config.canon || new ObjectCanon;\n        this.executeSelectionSet = wrap(function (options) {\n            var _a;\n            var canonizeResults = options.context.canonizeResults;\n            var peekArgs = execSelectionSetKeyArgs(options);\n            peekArgs[3] = !canonizeResults;\n            var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);\n            if (other) {\n                if (canonizeResults) {\n                    return __assign(__assign({}, other), { result: _this.canon.admit(other.result) });\n                }\n                return other;\n            }\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSelectionSetImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize,\n            keyArgs: execSelectionSetKeyArgs,\n            makeCacheKey: function (selectionSet, parent, context, canonizeResults) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);\n                }\n            }\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize,\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, context = _a.context;\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(field, array, context.varString);\n                }\n            }\n        });\n    }\n    StoreReader.prototype.resetCanon = function () {\n        this.canon = new ObjectCanon;\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? 'ROOT_QUERY' : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c, _d = _a.canonizeResults, canonizeResults = _d === void 0 ? this.config.canonizeResults : _d;\n        var policies = this.config.cache.policies;\n        variables = __assign(__assign({}, getDefaultValues(getQueryDefinition(query))), variables);\n        var rootRef = makeReference(rootId);\n        var execResult = this.executeSelectionSet({\n            selectionSet: getMainDefinition(query).selectionSet,\n            objectOrReference: rootRef,\n            enclosingRef: rootRef,\n            context: __assign({ store: store, query: query, policies: policies, variables: variables, varString: canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),\n        });\n        var missing;\n        if (execResult.missing) {\n            missing = [new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables)];\n            if (!returnPartialData) {\n                throw missing[0];\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !missing,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {\n        if (supportsResultCaching(context.store) &&\n            this.knownResults.get(result) === selectionSet) {\n            var latest = this.executeSelectionSet.peek(selectionSet, parent, context, this.canon.isKnown(result));\n            if (latest && result === latest.result) {\n                return true;\n            }\n        }\n        return false;\n    };\n    StoreReader.prototype.execSelectionSetImpl = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;\n        if (isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: this.canon.empty,\n                missing: \"Dangling reference to missing \".concat(objectOrReference.__ref, \" object\"),\n            };\n        }\n        var variables = context.variables, policies = context.policies, store = context.store;\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        var objectsToMerge = [];\n        var missing;\n        var missingMerger = new DeepMerger();\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            objectsToMerge.push({ __typename: typename });\n        }\n        function handleMissing(result, resultName) {\n            var _a;\n            if (result.missing) {\n                missing = missingMerger.merge(missing, (_a = {}, _a[resultName] = result.missing, _a));\n            }\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a, _b;\n            if (!shouldInclude(selection, variables))\n                return;\n            if (isField(selection)) {\n                var fieldValue = policies.readField({\n                    fieldName: selection.name.value,\n                    field: selection,\n                    variables: context.variables,\n                    from: objectOrReference,\n                }, context);\n                var resultName = resultKeyNameFromField(selection);\n                if (fieldValue === void 0) {\n                    if (!addTypenameToDocument.added(selection)) {\n                        missing = missingMerger.merge(missing, (_a = {},\n                            _a[resultName] = \"Can't find field '\".concat(selection.name.value, \"' on \").concat(isReference(objectOrReference)\n                                ? objectOrReference.__ref + \" object\"\n                                : \"object \" + JSON.stringify(objectOrReference, null, 2)),\n                            _a));\n                    }\n                }\n                else if (isArray(fieldValue)) {\n                    fieldValue = handleMissing(_this.executeSubSelectedArray({\n                        field: selection,\n                        array: fieldValue,\n                        enclosingRef: enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                else if (!selection.selectionSet) {\n                    if (context.canonizeResults) {\n                        fieldValue = _this.canon.pass(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        enclosingRef: isReference(fieldValue) ? fieldValue : enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                    throw __DEV__ ? new InvariantError(\"No fragment named \".concat(selection.name.value)) : new InvariantError(5);\n                }\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        var result = mergeDeepArray(objectsToMerge);\n        var finalResult = { result: result, missing: missing };\n        var frozen = context.canonizeResults\n            ? this.canon.admit(finalResult)\n            : maybeDeepFreeze(finalResult);\n        if (frozen.result) {\n            this.knownResults.set(frozen.result, selectionSet);\n        }\n        return frozen;\n    };\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;\n        var missing;\n        var missingMerger = new DeepMerger();\n        function handleMissing(childResult, i) {\n            var _a;\n            if (childResult.missing) {\n                missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));\n            }\n            return childResult.result;\n        }\n        if (field.selectionSet) {\n            array = array.filter(context.store.canRead);\n        }\n        array = array.map(function (item, i) {\n            if (item === null) {\n                return null;\n            }\n            if (isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    enclosingRef: enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    enclosingRef: isReference(item) ? item : enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (__DEV__) {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            return item;\n        });\n        return {\n            result: context.canonizeResults ? this.canon.admit(array) : array,\n            missing: missing,\n        };\n    };\n    return StoreReader;\n}());\nexport { StoreReader };\nfunction firstMissing(tree) {\n    try {\n        JSON.stringify(tree, function (_, value) {\n            if (typeof value === \"string\")\n                throw value;\n            return value;\n        });\n    }\n    catch (result) {\n        return result;\n    }\n}\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (isNonNullObject(value)) {\n                __DEV__ ? invariant(!isReference(value), \"Missing selection set for object of type \".concat(getTypenameFromStoreObject(store, value), \" returned for query field \").concat(field.name.value)) : invariant(!isReference(value), 6);\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n//# sourceMappingURL=readFromStore.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport { argumentsObjectFromField, DeepMerger, isNonEmptyArray, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, isArray } from \"./helpers.js\";\nvar specifierInfoCache = Object.create(null);\nfunction lookupSpecifierInfo(spec) {\n    var cacheKey = JSON.stringify(spec);\n    return specifierInfoCache[cacheKey] ||\n        (specifierInfoCache[cacheKey] = Object.create(null));\n}\nexport function keyFieldsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {\n        var extract = function (from, key) { return context.readField(key, from); };\n        var keyObject = context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {\n            var extracted = extractKeyPath(context.storeObject, schemaKeyPath, extract);\n            if (extracted === void 0 &&\n                object !== context.storeObject &&\n                hasOwn.call(object, schemaKeyPath[0])) {\n                extracted = extractKeyPath(object, schemaKeyPath, extractKey);\n            }\n            __DEV__ ? invariant(extracted !== void 0, \"Missing field '\".concat(schemaKeyPath.join('.'), \"' while extracting keyFields from \").concat(JSON.stringify(object))) : invariant(extracted !== void 0, 2);\n            return extracted;\n        });\n        return \"\".concat(context.typename, \":\").concat(JSON.stringify(keyObject));\n    });\n}\nexport function keyArgsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return info.keyArgsFn || (info.keyArgsFn = function (args, _a) {\n        var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;\n        var collected = collectSpecifierPaths(specifier, function (keyPath) {\n            var firstKey = keyPath[0];\n            var firstChar = firstKey.charAt(0);\n            if (firstChar === \"@\") {\n                if (field && isNonEmptyArray(field.directives)) {\n                    var directiveName_1 = firstKey.slice(1);\n                    var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });\n                    var directiveArgs = d && argumentsObjectFromField(d, variables);\n                    return directiveArgs && extractKeyPath(directiveArgs, keyPath.slice(1));\n                }\n                return;\n            }\n            if (firstChar === \"$\") {\n                var variableName = firstKey.slice(1);\n                if (variables && hasOwn.call(variables, variableName)) {\n                    var varKeyPath = keyPath.slice(0);\n                    varKeyPath[0] = variableName;\n                    return extractKeyPath(variables, varKeyPath);\n                }\n                return;\n            }\n            if (args) {\n                return extractKeyPath(args, keyPath);\n            }\n        });\n        var suffix = JSON.stringify(collected);\n        if (args || suffix !== \"{}\") {\n            fieldName += \":\" + suffix;\n        }\n        return fieldName;\n    });\n}\nexport function collectSpecifierPaths(specifier, extractor) {\n    var merger = new DeepMerger;\n    return getSpecifierPaths(specifier).reduce(function (collected, path) {\n        var _a;\n        var toMerge = extractor(path);\n        if (toMerge !== void 0) {\n            for (var i = path.length - 1; i >= 0; --i) {\n                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);\n            }\n            collected = merger.merge(collected, toMerge);\n        }\n        return collected;\n    }, Object.create(null));\n}\nexport function getSpecifierPaths(spec) {\n    var info = lookupSpecifierInfo(spec);\n    if (!info.paths) {\n        var paths_1 = info.paths = [];\n        var currentPath_1 = [];\n        spec.forEach(function (s, i) {\n            if (isArray(s)) {\n                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });\n                currentPath_1.length = 0;\n            }\n            else {\n                currentPath_1.push(s);\n                if (!isArray(spec[i + 1])) {\n                    paths_1.push(currentPath_1.slice(0));\n                    currentPath_1.length = 0;\n                }\n            }\n        });\n    }\n    return info.paths;\n}\nfunction extractKey(object, key) {\n    return object[key];\n}\nexport function extractKeyPath(object, path, extract) {\n    extract = extract || extractKey;\n    return normalize(path.reduce(function reducer(obj, key) {\n        return isArray(obj)\n            ? obj.map(function (child) { return reducer(child, key); })\n            : obj && extract(obj, key);\n    }, object));\n}\nfunction normalize(value) {\n    if (isNonNullObject(value)) {\n        if (isArray(value)) {\n            return value.map(normalize);\n        }\n        return collectSpecifierPaths(Object.keys(value).sort(), function (path) { return extractKeyPath(value, path); });\n    }\n    return value;\n}\n//# sourceMappingURL=key-extractor.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant, InvariantError } from \"../../utilities/globals/index.js\";\nimport { storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, isNonNullObject, stringifyForDisplay, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName, storeValueIsStoreObject, selectionSetMatchesResult, TypeOrFieldNameRegExp, defaultDataIdFromObject, isArray, } from \"./helpers.js\";\nimport { cacheSlot } from \"./reactiveVars.js\";\nimport { canonicalStringify } from \"./object-canon.js\";\nimport { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier } from \"./key-extractor.js\";\ngetStoreKeyName.setStringify(canonicalStringify);\nfunction argsFromFieldSpecifier(spec) {\n    return spec.args !== void 0 ? spec.args :\n        spec.field ? argumentsObjectFromField(spec.field, spec.variables) : null;\n}\nvar nullKeyFieldsFn = function () { return void 0; };\nvar simpleKeyArgsFn = function (_args, context) { return context.fieldName; };\nvar mergeTrueFn = function (existing, incoming, _a) {\n    var mergeObjects = _a.mergeObjects;\n    return mergeObjects(existing, incoming);\n};\nvar mergeFalseFn = function (_, incoming) { return incoming; };\nvar Policies = (function () {\n    function Policies(config) {\n        this.config = config;\n        this.typePolicies = Object.create(null);\n        this.toBeAdded = Object.create(null);\n        this.supertypeMap = new Map();\n        this.fuzzySubtypes = new Map();\n        this.rootIdsByTypename = Object.create(null);\n        this.rootTypenamesById = Object.create(null);\n        this.usingPossibleTypes = false;\n        this.config = __assign({ dataIdFromObject: defaultDataIdFromObject }, config);\n        this.cache = this.config.cache;\n        this.setRootTypename(\"Query\");\n        this.setRootTypename(\"Mutation\");\n        this.setRootTypename(\"Subscription\");\n        if (config.possibleTypes) {\n            this.addPossibleTypes(config.possibleTypes);\n        }\n        if (config.typePolicies) {\n            this.addTypePolicies(config.typePolicies);\n        }\n    }\n    Policies.prototype.identify = function (object, partialContext) {\n        var _a;\n        var policies = this;\n        var typename = partialContext && (partialContext.typename ||\n            ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename)) || object.__typename;\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        var storeObject = partialContext && partialContext.storeObject || object;\n        var context = __assign(__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: partialContext && partialContext.readField || function () {\n                var options = normalizeReadFieldOptions(arguments, storeObject);\n                return policies.readField(options, {\n                    store: policies.cache[\"data\"],\n                    variables: options.variables,\n                });\n            } });\n        var id;\n        var policy = typename && this.getTypePolicy(typename);\n        var keyFn = policy && policy.keyFn || this.config.dataIdFromObject;\n        while (keyFn) {\n            var specifierOrId = keyFn(object, context);\n            if (isArray(specifierOrId)) {\n                keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n            }\n            else {\n                id = specifierOrId;\n                break;\n            }\n        }\n        id = id ? String(id) : void 0;\n        return context.keyObject ? [id, context.keyObject] : [id];\n    };\n    Policies.prototype.addTypePolicies = function (typePolicies) {\n        var _this = this;\n        Object.keys(typePolicies).forEach(function (typename) {\n            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = __rest(_a, [\"queryType\", \"mutationType\", \"subscriptionType\"]);\n            if (queryType)\n                _this.setRootTypename(\"Query\", typename);\n            if (mutationType)\n                _this.setRootTypename(\"Mutation\", typename);\n            if (subscriptionType)\n                _this.setRootTypename(\"Subscription\", typename);\n            if (hasOwn.call(_this.toBeAdded, typename)) {\n                _this.toBeAdded[typename].push(incoming);\n            }\n            else {\n                _this.toBeAdded[typename] = [incoming];\n            }\n        });\n    };\n    Policies.prototype.updateTypePolicy = function (typename, incoming) {\n        var _this = this;\n        var existing = this.getTypePolicy(typename);\n        var keyFields = incoming.keyFields, fields = incoming.fields;\n        function setMerge(existing, merge) {\n            existing.merge =\n                typeof merge === \"function\" ? merge :\n                    merge === true ? mergeTrueFn :\n                        merge === false ? mergeFalseFn :\n                            existing.merge;\n        }\n        setMerge(existing, incoming.merge);\n        existing.keyFn =\n            keyFields === false ? nullKeyFieldsFn :\n                isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields) :\n                    typeof keyFields === \"function\" ? keyFields :\n                        existing.keyFn;\n        if (fields) {\n            Object.keys(fields).forEach(function (fieldName) {\n                var existing = _this.getFieldPolicy(typename, fieldName, true);\n                var incoming = fields[fieldName];\n                if (typeof incoming === \"function\") {\n                    existing.read = incoming;\n                }\n                else {\n                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;\n                    existing.keyFn =\n                        keyArgs === false ? simpleKeyArgsFn :\n                            isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs) :\n                                typeof keyArgs === \"function\" ? keyArgs :\n                                    existing.keyFn;\n                    if (typeof read === \"function\") {\n                        existing.read = read;\n                    }\n                    setMerge(existing, merge);\n                }\n                if (existing.read && existing.merge) {\n                    existing.keyFn = existing.keyFn || simpleKeyArgsFn;\n                }\n            });\n        }\n    };\n    Policies.prototype.setRootTypename = function (which, typename) {\n        if (typename === void 0) { typename = which; }\n        var rootId = \"ROOT_\" + which.toUpperCase();\n        var old = this.rootTypenamesById[rootId];\n        if (typename !== old) {\n            __DEV__ ? invariant(!old || old === which, \"Cannot change root \".concat(which, \" __typename more than once\")) : invariant(!old || old === which, 3);\n            if (old)\n                delete this.rootIdsByTypename[old];\n            this.rootIdsByTypename[typename] = rootId;\n            this.rootTypenamesById[rootId] = typename;\n        }\n    };\n    Policies.prototype.addPossibleTypes = function (possibleTypes) {\n        var _this = this;\n        this.usingPossibleTypes = true;\n        Object.keys(possibleTypes).forEach(function (supertype) {\n            _this.getSupertypeSet(supertype, true);\n            possibleTypes[supertype].forEach(function (subtype) {\n                _this.getSupertypeSet(subtype, true).add(supertype);\n                var match = subtype.match(TypeOrFieldNameRegExp);\n                if (!match || match[0] !== subtype) {\n                    _this.fuzzySubtypes.set(subtype, new RegExp(subtype));\n                }\n            });\n        });\n    };\n    Policies.prototype.getTypePolicy = function (typename) {\n        var _this = this;\n        if (!hasOwn.call(this.typePolicies, typename)) {\n            var policy_1 = this.typePolicies[typename] = Object.create(null);\n            policy_1.fields = Object.create(null);\n            var supertypes = this.supertypeMap.get(typename);\n            if (supertypes && supertypes.size) {\n                supertypes.forEach(function (supertype) {\n                    var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = __rest(_a, [\"fields\"]);\n                    Object.assign(policy_1, rest);\n                    Object.assign(policy_1.fields, fields);\n                });\n            }\n        }\n        var inbox = this.toBeAdded[typename];\n        if (inbox && inbox.length) {\n            inbox.splice(0).forEach(function (policy) {\n                _this.updateTypePolicy(typename, policy);\n            });\n        }\n        return this.typePolicies[typename];\n    };\n    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {\n        if (typename) {\n            var fieldPolicies = this.getTypePolicy(typename).fields;\n            return fieldPolicies[fieldName] || (createIfMissing && (fieldPolicies[fieldName] = Object.create(null)));\n        }\n    };\n    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {\n        var supertypeSet = this.supertypeMap.get(subtype);\n        if (!supertypeSet && createIfMissing) {\n            this.supertypeMap.set(subtype, supertypeSet = new Set());\n        }\n        return supertypeSet;\n    };\n    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {\n        var _this = this;\n        if (!fragment.typeCondition)\n            return true;\n        if (!typename)\n            return false;\n        var supertype = fragment.typeCondition.name.value;\n        if (typename === supertype)\n            return true;\n        if (this.usingPossibleTypes &&\n            this.supertypeMap.has(supertype)) {\n            var typenameSupertypeSet = this.getSupertypeSet(typename, true);\n            var workQueue_1 = [typenameSupertypeSet];\n            var maybeEnqueue_1 = function (subtype) {\n                var supertypeSet = _this.getSupertypeSet(subtype, false);\n                if (supertypeSet &&\n                    supertypeSet.size &&\n                    workQueue_1.indexOf(supertypeSet) < 0) {\n                    workQueue_1.push(supertypeSet);\n                }\n            };\n            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);\n            var checkingFuzzySubtypes = false;\n            for (var i = 0; i < workQueue_1.length; ++i) {\n                var supertypeSet = workQueue_1[i];\n                if (supertypeSet.has(supertype)) {\n                    if (!typenameSupertypeSet.has(supertype)) {\n                        if (checkingFuzzySubtypes) {\n                            __DEV__ && invariant.warn(\"Inferring subtype \".concat(typename, \" of supertype \").concat(supertype));\n                        }\n                        typenameSupertypeSet.add(supertype);\n                    }\n                    return true;\n                }\n                supertypeSet.forEach(maybeEnqueue_1);\n                if (needToCheckFuzzySubtypes &&\n                    i === workQueue_1.length - 1 &&\n                    selectionSetMatchesResult(fragment.selectionSet, result, variables)) {\n                    needToCheckFuzzySubtypes = false;\n                    checkingFuzzySubtypes = true;\n                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {\n                        var match = typename.match(regExp);\n                        if (match && match[0] === typename) {\n                            maybeEnqueue_1(fuzzyString);\n                        }\n                    });\n                }\n            }\n        }\n        return false;\n    };\n    Policies.prototype.hasKeyArgs = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return !!(policy && policy.keyFn);\n    };\n    Policies.prototype.getStoreFieldName = function (fieldSpec) {\n        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        var storeFieldName;\n        var keyFn = policy && policy.keyFn;\n        if (keyFn && typename) {\n            var context = {\n                typename: typename,\n                fieldName: fieldName,\n                field: fieldSpec.field || null,\n                variables: fieldSpec.variables,\n            };\n            var args = argsFromFieldSpecifier(fieldSpec);\n            while (keyFn) {\n                var specifierOrString = keyFn(args, context);\n                if (isArray(specifierOrString)) {\n                    keyFn = keyArgsFnFromSpecifier(specifierOrString);\n                }\n                else {\n                    storeFieldName = specifierOrString || fieldName;\n                    break;\n                }\n            }\n        }\n        if (storeFieldName === void 0) {\n            storeFieldName = fieldSpec.field\n                ? storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n                : getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n        }\n        if (storeFieldName === false) {\n            return fieldName;\n        }\n        return fieldName === fieldNameFromStoreName(storeFieldName)\n            ? storeFieldName\n            : fieldName + \":\" + storeFieldName;\n    };\n    Policies.prototype.readField = function (options, context) {\n        var objectOrReference = options.from;\n        if (!objectOrReference)\n            return;\n        var nameOrField = options.field || options.fieldName;\n        if (!nameOrField)\n            return;\n        if (options.typename === void 0) {\n            var typename = context.store.getFieldValue(objectOrReference, \"__typename\");\n            if (typename)\n                options.typename = typename;\n        }\n        var storeFieldName = this.getStoreFieldName(options);\n        var fieldName = fieldNameFromStoreName(storeFieldName);\n        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);\n        var policy = this.getFieldPolicy(options.typename, fieldName, false);\n        var read = policy && policy.read;\n        if (read) {\n            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference)\n                ? objectOrReference.__ref\n                : objectOrReference, storeFieldName));\n            return cacheSlot.withValue(this.cache, read, [existing, readOptions]);\n        }\n        return existing;\n    };\n    Policies.prototype.getReadFunction = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return policy && policy.read;\n    };\n    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {\n        var policy = this.getFieldPolicy(parentTypename, fieldName, false);\n        var merge = policy && policy.merge;\n        if (!merge && childTypename) {\n            policy = this.getTypePolicy(childTypename);\n            merge = policy && policy.merge;\n        }\n        return merge;\n    };\n    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {\n        var field = _a.field, typename = _a.typename, merge = _a.merge;\n        if (merge === mergeTrueFn) {\n            return makeMergeObjectsFunction(context.store)(existing, incoming);\n        }\n        if (merge === mergeFalseFn) {\n            return incoming;\n        }\n        if (context.overwrite) {\n            existing = void 0;\n        }\n        return merge(existing, incoming, makeFieldFunctionOptions(this, void 0, { typename: typename, fieldName: field.name.value, field: field, variables: context.variables }, context, storage || Object.create(null)));\n    };\n    return Policies;\n}());\nexport { Policies };\nfunction makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {\n    var storeFieldName = policies.getStoreFieldName(fieldSpec);\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var variables = fieldSpec.variables || context.variables;\n    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;\n    return {\n        args: argsFromFieldSpecifier(fieldSpec),\n        field: fieldSpec.field || null,\n        fieldName: fieldName,\n        storeFieldName: storeFieldName,\n        variables: variables,\n        isReference: isReference,\n        toReference: toReference,\n        storage: storage,\n        cache: policies.cache,\n        canRead: canRead,\n        readField: function () {\n            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);\n        },\n        mergeObjects: makeMergeObjectsFunction(context.store),\n    };\n}\nexport function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {\n    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;\n    var options;\n    if (typeof fieldNameOrOptions === \"string\") {\n        options = {\n            fieldName: fieldNameOrOptions,\n            from: argc > 1 ? from : objectOrReference,\n        };\n    }\n    else {\n        options = __assign({}, fieldNameOrOptions);\n        if (!hasOwn.call(options, \"from\")) {\n            options.from = objectOrReference;\n        }\n    }\n    if (__DEV__ && options.from === void 0) {\n        __DEV__ && invariant.warn(\"Undefined 'from' passed to readField with arguments \".concat(stringifyForDisplay(Array.from(readFieldArgs))));\n    }\n    if (void 0 === options.variables) {\n        options.variables = variables;\n    }\n    return options;\n}\nfunction makeMergeObjectsFunction(store) {\n    return function mergeObjects(existing, incoming) {\n        if (isArray(existing) || isArray(incoming)) {\n            throw __DEV__ ? new InvariantError(\"Cannot automatically merge arrays\") : new InvariantError(4);\n        }\n        if (isNonNullObject(existing) &&\n            isNonNullObject(incoming)) {\n            var eType = store.getFieldValue(existing, \"__typename\");\n            var iType = store.getFieldValue(incoming, \"__typename\");\n            var typesDiffer = eType && iType && eType !== iType;\n            if (typesDiffer) {\n                return incoming;\n            }\n            if (isReference(existing) &&\n                storeValueIsStoreObject(incoming)) {\n                store.merge(existing.__ref, incoming);\n                return existing;\n            }\n            if (storeValueIsStoreObject(existing) &&\n                isReference(incoming)) {\n                store.merge(existing, incoming.__ref);\n                return incoming;\n            }\n            if (storeValueIsStoreObject(existing) &&\n                storeValueIsStoreObject(incoming)) {\n                return __assign(__assign({}, existing), incoming);\n            }\n        }\n        return incoming;\n    };\n}\n//# sourceMappingURL=policies.js.map","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from \"../../utilities/globals/index.js\";\nimport { equal } from '@wry/equality';\nimport { Trie } from '@wry/trie';\nimport { Kind, } from 'graphql';\nimport { getFragmentFromSelection, getDefaultValues, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, cloneDeep, addTypenameToDocument, isNonEmptyArray, argumentsObjectFromField, } from \"../../utilities/index.js\";\nimport { isArray, makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject, extractFragmentContext } from \"./helpers.js\";\nimport { canonicalStringify } from \"./object-canon.js\";\nimport { normalizeReadFieldOptions } from \"./policies.js\";\n;\nfunction getContextFlavor(context, clientOnly, deferred) {\n    var key = \"\".concat(clientOnly).concat(deferred);\n    var flavored = context.flavors.get(key);\n    if (!flavored) {\n        context.flavors.set(key, flavored = (context.clientOnly === clientOnly &&\n            context.deferred === deferred) ? context : __assign(__assign({}, context), { clientOnly: clientOnly, deferred: deferred }));\n    }\n    return flavored;\n}\nvar StoreWriter = (function () {\n    function StoreWriter(cache, reader, fragments) {\n        this.cache = cache;\n        this.reader = reader;\n        this.fragments = fragments;\n    }\n    StoreWriter.prototype.writeToStore = function (store, _a) {\n        var _this = this;\n        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;\n        var operationDefinition = getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);\n        var context = __assign(__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {\n                return merger.merge(existing, incoming);\n            }, variables: variables, varString: canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map, clientOnly: false, deferred: false, flavors: new Map });\n        var ref = this.processSelectionSet({\n            result: result || Object.create(null),\n            dataId: dataId,\n            selectionSet: operationDefinition.selectionSet,\n            mergeTree: { map: new Map },\n            context: context,\n        });\n        if (!isReference(ref)) {\n            throw __DEV__ ? new InvariantError(\"Could not identify object \".concat(JSON.stringify(result))) : new InvariantError(7);\n        }\n        context.incomingById.forEach(function (_a, dataId) {\n            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;\n            var entityRef = makeReference(dataId);\n            if (mergeTree && mergeTree.map.size) {\n                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);\n                if (isReference(applied)) {\n                    return;\n                }\n                storeObject = applied;\n            }\n            if (__DEV__ && !context.overwrite) {\n                var fieldsWithSelectionSets_1 = Object.create(null);\n                fieldNodeSet.forEach(function (field) {\n                    if (field.selectionSet) {\n                        fieldsWithSelectionSets_1[field.name.value] = true;\n                    }\n                });\n                var hasSelectionSet_1 = function (storeFieldName) {\n                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] === true;\n                };\n                var hasMergeFunction_1 = function (storeFieldName) {\n                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(storeObject).forEach(function (storeFieldName) {\n                    if (hasSelectionSet_1(storeFieldName) &&\n                        !hasMergeFunction_1(storeFieldName)) {\n                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);\n                    }\n                });\n            }\n            store.merge(dataId, storeObject);\n        });\n        store.retain(ref.__ref);\n        return ref;\n    };\n    StoreWriter.prototype.processSelectionSet = function (_a) {\n        var _this = this;\n        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, mergeTree = _a.mergeTree;\n        var policies = this.cache.policies;\n        var incoming = Object.create(null);\n        var typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            incoming.__typename = typename;\n        }\n        var readField = function () {\n            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);\n            if (isReference(options.from)) {\n                var info = context.incomingById.get(options.from.__ref);\n                if (info) {\n                    var result_1 = policies.readField(__assign(__assign({}, options), { from: info.storeObject }), context);\n                    if (result_1 !== void 0) {\n                        return result_1;\n                    }\n                }\n            }\n            return policies.readField(options, context);\n        };\n        var fieldNodeSet = new Set();\n        this.flattenFields(selectionSet, result, context, typename).forEach(function (context, field) {\n            var _a;\n            var resultFieldKey = resultKeyNameFromField(field);\n            var value = result[resultFieldKey];\n            fieldNodeSet.add(field);\n            if (value !== void 0) {\n                var storeFieldName = policies.getStoreFieldName({\n                    typename: typename,\n                    fieldName: field.name.value,\n                    field: field,\n                    variables: context.variables,\n                });\n                var childTree = getChildMergeTree(mergeTree, storeFieldName);\n                var incomingValue = _this.processFieldValue(value, field, field.selectionSet\n                    ? getContextFlavor(context, false, false)\n                    : context, childTree);\n                var childTypename = void 0;\n                if (field.selectionSet &&\n                    (isReference(incomingValue) ||\n                        storeValueIsStoreObject(incomingValue))) {\n                    childTypename = readField(\"__typename\", incomingValue);\n                }\n                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);\n                if (merge) {\n                    childTree.info = {\n                        field: field,\n                        typename: typename,\n                        merge: merge,\n                    };\n                }\n                else {\n                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                }\n                incoming = context.merge(incoming, (_a = {},\n                    _a[storeFieldName] = incomingValue,\n                    _a));\n            }\n            else if (__DEV__ &&\n                !context.clientOnly &&\n                !context.deferred &&\n                !addTypenameToDocument.added(field) &&\n                !policies.getReadFunction(typename, field.name.value)) {\n                __DEV__ && invariant.error(\"Missing field '\".concat(resultKeyNameFromField(field), \"' while writing result \").concat(JSON.stringify(result, null, 2)).substring(0, 1000));\n            }\n        });\n        try {\n            var _b = policies.identify(result, {\n                typename: typename,\n                selectionSet: selectionSet,\n                fragmentMap: context.fragmentMap,\n                storeObject: incoming,\n                readField: readField,\n            }), id = _b[0], keyObject = _b[1];\n            dataId = dataId || id;\n            if (keyObject) {\n                incoming = context.merge(incoming, keyObject);\n            }\n        }\n        catch (e) {\n            if (!dataId)\n                throw e;\n        }\n        if (\"string\" === typeof dataId) {\n            var dataRef = makeReference(dataId);\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            if (sets.indexOf(selectionSet) >= 0)\n                return dataRef;\n            sets.push(selectionSet);\n            if (this.reader && this.reader.isFresh(result, dataRef, selectionSet, context)) {\n                return dataRef;\n            }\n            var previous_1 = context.incomingById.get(dataId);\n            if (previous_1) {\n                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);\n                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);\n                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });\n            }\n            else {\n                context.incomingById.set(dataId, {\n                    storeObject: incoming,\n                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,\n                    fieldNodeSet: fieldNodeSet,\n                });\n            }\n            return dataRef;\n        }\n        return incoming;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            return __DEV__ ? cloneDeep(value) : value;\n        }\n        if (isArray(value)) {\n            return value.map(function (item, i) {\n                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));\n                maybeRecycleChildMergeTree(mergeTree, i);\n                return value;\n            });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context: context,\n            mergeTree: mergeTree,\n        });\n    };\n    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {\n        if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }\n        var fieldMap = new Map();\n        var policies = this.cache.policies;\n        var limitingTrie = new Trie(false);\n        (function flatten(selectionSet, inheritedContext) {\n            var visitedNode = limitingTrie.lookup(selectionSet, inheritedContext.clientOnly, inheritedContext.deferred);\n            if (visitedNode.visited)\n                return;\n            visitedNode.visited = true;\n            selectionSet.selections.forEach(function (selection) {\n                if (!shouldInclude(selection, context.variables))\n                    return;\n                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;\n                if (!(clientOnly && deferred) &&\n                    isNonEmptyArray(selection.directives)) {\n                    selection.directives.forEach(function (dir) {\n                        var name = dir.name.value;\n                        if (name === \"client\")\n                            clientOnly = true;\n                        if (name === \"defer\") {\n                            var args = argumentsObjectFromField(dir, context.variables);\n                            if (!args || args.if !== false) {\n                                deferred = true;\n                            }\n                        }\n                    });\n                }\n                if (isField(selection)) {\n                    var existing = fieldMap.get(selection);\n                    if (existing) {\n                        clientOnly = clientOnly && existing.clientOnly;\n                        deferred = deferred && existing.deferred;\n                    }\n                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));\n                }\n                else {\n                    var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                    if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                        throw __DEV__ ? new InvariantError(\"No fragment named \".concat(selection.name.value)) : new InvariantError(8);\n                    }\n                    if (fragment &&\n                        policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));\n                    }\n                }\n            });\n        })(selectionSet, context);\n        return fieldMap;\n    };\n    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {\n        var _a;\n        var _this = this;\n        if (mergeTree.map.size && !isReference(incoming)) {\n            var e_1 = (!isArray(incoming) &&\n                (isReference(existing) || storeValueIsStoreObject(existing))) ? existing : void 0;\n            var i_1 = incoming;\n            if (e_1 && !getStorageArgs) {\n                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];\n            }\n            var changedFields_1;\n            var getValue_1 = function (from, name) {\n                return isArray(from)\n                    ? (typeof name === \"number\" ? from[name] : void 0)\n                    : context.store.getFieldValue(from, String(name));\n            };\n            mergeTree.map.forEach(function (childTree, storeFieldName) {\n                var eVal = getValue_1(e_1, storeFieldName);\n                var iVal = getValue_1(i_1, storeFieldName);\n                if (void 0 === iVal)\n                    return;\n                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);\n                if (aVal !== iVal) {\n                    changedFields_1 = changedFields_1 || new Map;\n                    changedFields_1.set(storeFieldName, aVal);\n                }\n                if (getStorageArgs) {\n                    invariant(getStorageArgs.pop() === storeFieldName);\n                }\n            });\n            if (changedFields_1) {\n                incoming = (isArray(i_1) ? i_1.slice(0) : __assign({}, i_1));\n                changedFields_1.forEach(function (value, name) {\n                    incoming[name] = value;\n                });\n            }\n        }\n        if (mergeTree.info) {\n            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));\n        }\n        return incoming;\n    };\n    return StoreWriter;\n}());\nexport { StoreWriter };\nvar emptyMergeTreePool = [];\nfunction getChildMergeTree(_a, name) {\n    var map = _a.map;\n    if (!map.has(name)) {\n        map.set(name, emptyMergeTreePool.pop() || { map: new Map });\n    }\n    return map.get(name);\n}\nfunction mergeMergeTrees(left, right) {\n    if (left === right || !right || mergeTreeIsEmpty(right))\n        return left;\n    if (!left || mergeTreeIsEmpty(left))\n        return right;\n    var info = left.info && right.info ? __assign(__assign({}, left.info), right.info) : left.info || right.info;\n    var needToMergeMaps = left.map.size && right.map.size;\n    var map = needToMergeMaps ? new Map :\n        left.map.size ? left.map : right.map;\n    var merged = { info: info, map: map };\n    if (needToMergeMaps) {\n        var remainingRightKeys_1 = new Set(right.map.keys());\n        left.map.forEach(function (leftTree, key) {\n            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));\n            remainingRightKeys_1.delete(key);\n        });\n        remainingRightKeys_1.forEach(function (key) {\n            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));\n        });\n    }\n    return merged;\n}\nfunction mergeTreeIsEmpty(tree) {\n    return !tree || !(tree.info || tree.map.size);\n}\nfunction maybeRecycleChildMergeTree(_a, name) {\n    var map = _a.map;\n    var childTree = map.get(name);\n    if (childTree && mergeTreeIsEmpty(childTree)) {\n        emptyMergeTreePool.push(childTree);\n        map.delete(name);\n    }\n}\nvar warnings = new Set();\nfunction warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {\n    var getChild = function (objOrRef) {\n        var child = store.getFieldValue(objOrRef, storeFieldName);\n        return typeof child === \"object\" && child;\n    };\n    var existing = getChild(existingRef);\n    if (!existing)\n        return;\n    var incoming = getChild(incomingObj);\n    if (!incoming)\n        return;\n    if (isReference(existing))\n        return;\n    if (equal(existing, incoming))\n        return;\n    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {\n        return;\n    }\n    var parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var typeDotName = \"\".concat(parentType, \".\").concat(fieldName);\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    if (!isArray(existing) &&\n        !isArray(incoming)) {\n        [existing, incoming].forEach(function (child) {\n            var typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" &&\n                !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    __DEV__ && invariant.warn(\"Cache data may be lost when replacing the \".concat(fieldName, \" field of a \").concat(parentType, \" object.\\n\\nTo address this problem (which is not a bug in Apollo Client), \").concat(childTypenames.length\n        ? \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") + \" have an ID or a custom merge function, or \"\n        : \"\", \"define a custom merge function for the \").concat(typeDotName, \" field, so InMemoryCache can safely merge these objects:\\n\\n  existing: \").concat(JSON.stringify(existing).slice(0, 1000), \"\\n  incoming: \").concat(JSON.stringify(incoming).slice(0, 1000), \"\\n\\nFor more information about these options, please refer to the documentation:\\n\\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\\n\"));\n}\n//# sourceMappingURL=writeToStore.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport \"./fixPolyfills.js\";\nimport { wrap } from 'optimism';\nimport { equal } from '@wry/equality';\nimport { ApolloCache } from \"../core/cache.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { addTypenameToDocument, isReference, } from \"../../utilities/index.js\";\nimport { StoreReader } from \"./readFromStore.js\";\nimport { StoreWriter } from \"./writeToStore.js\";\nimport { EntityStore, supportsResultCaching } from \"./entityStore.js\";\nimport { makeVar, forgetCache, recallCache } from \"./reactiveVars.js\";\nimport { Policies } from \"./policies.js\";\nimport { hasOwn, normalizeConfig, shouldCanonizeResults } from \"./helpers.js\";\nimport { canonicalStringify } from \"./object-canon.js\";\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.makeVar = makeVar;\n        _this.txCount = 0;\n        _this.config = normalizeConfig(config);\n        _this.addTypename = !!_this.config.addTypename;\n        _this.policies = new Policies({\n            cache: _this,\n            dataIdFromObject: _this.config.dataIdFromObject,\n            possibleTypes: _this.config.possibleTypes,\n            typePolicies: _this.config.typePolicies,\n        });\n        _this.init();\n        return _this;\n    }\n    InMemoryCache.prototype.init = function () {\n        var rootStore = this.data = new EntityStore.Root({\n            policies: this.policies,\n            resultCaching: this.config.resultCaching,\n        });\n        this.optimisticData = rootStore.stump;\n        this.resetResultCache();\n    };\n    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {\n        var _this = this;\n        var previousReader = this.storeReader;\n        var fragments = this.config.fragments;\n        this.storeWriter = new StoreWriter(this, this.storeReader = new StoreReader({\n            cache: this,\n            addTypename: this.addTypename,\n            resultCacheMaxSize: this.config.resultCacheMaxSize,\n            canonizeResults: shouldCanonizeResults(this.config),\n            canon: resetResultIdentities\n                ? void 0\n                : previousReader && previousReader.canon,\n            fragments: fragments,\n        }), fragments);\n        this.maybeBroadcastWatch = wrap(function (c, options) {\n            return _this.broadcastWatch(c, options);\n        }, {\n            max: this.config.resultCacheMaxSize,\n            makeCacheKey: function (c) {\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, id = c.id, variables = c.variables;\n                    return store.makeCacheKey(c.query, c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));\n                }\n            }\n        });\n        new Set([\n            this.data.group,\n            this.optimisticData.group,\n        ]).forEach(function (group) { return group.resetCaching(); });\n    };\n    InMemoryCache.prototype.restore = function (data) {\n        this.init();\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).extract();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        var _a = options.returnPartialData, returnPartialData = _a === void 0 ? false : _a;\n        try {\n            return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null;\n        }\n        catch (e) {\n            if (e instanceof MissingFieldError) {\n                return null;\n            }\n            throw e;\n        }\n    };\n    InMemoryCache.prototype.write = function (options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore(this.data, options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.modify = function (options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            return false;\n        }\n        var store = options.optimistic\n            ? this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.diff = function (options) {\n        return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || \"ROOT_QUERY\", config: this.config }));\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        if (!this.watches.size) {\n            recallCache(this);\n        }\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return function () {\n            if (_this.watches.delete(watch) && !_this.watches.size) {\n                forgetCache(_this);\n            }\n            _this.maybeBroadcastWatch.forget(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function (options) {\n        canonicalStringify.reset();\n        var ids = this.optimisticData.gc();\n        if (options && !this.txCount) {\n            if (options.resetResultCache) {\n                this.resetResultCache(options.resetResultIdentities);\n            }\n            else if (options.resetResultIdentities) {\n                this.storeReader.resetCanon();\n            }\n        }\n        return ids;\n    };\n    InMemoryCache.prototype.retain = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    };\n    InMemoryCache.prototype.release = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    };\n    InMemoryCache.prototype.identify = function (object) {\n        if (isReference(object))\n            return object.__ref;\n        try {\n            return this.policies.identify(object)[0];\n        }\n        catch (e) {\n            __DEV__ && invariant.warn(e);\n        }\n    };\n    InMemoryCache.prototype.evict = function (options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                return false;\n            }\n            options = __assign(__assign({}, options), { id: \"ROOT_QUERY\" });\n        }\n        try {\n            ++this.txCount;\n            return this.optimisticData.evict(options, this.data);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function (options) {\n        var _this = this;\n        this.init();\n        canonicalStringify.reset();\n        if (options && options.discardWatches) {\n            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });\n            this.watches.clear();\n            forgetCache(this);\n        }\n        else {\n            this.broadcastWatches();\n        }\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.batch = function (options) {\n        var _this = this;\n        var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;\n        var updateResult;\n        var perform = function (layer) {\n            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;\n            ++_this.txCount;\n            if (layer) {\n                _this.data = _this.optimisticData = layer;\n            }\n            try {\n                return updateResult = update(_this);\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        var alreadyDirty = new Set();\n        if (onWatchUpdated && !this.txCount) {\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch) {\n                    alreadyDirty.add(watch);\n                    return false;\n                } }));\n        }\n        if (typeof optimistic === 'string') {\n            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n        }\n        else if (optimistic === false) {\n            perform(this.data);\n        }\n        else {\n            perform();\n        }\n        if (typeof removeOptimistic === \"string\") {\n            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n        }\n        if (onWatchUpdated && alreadyDirty.size) {\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {\n                    var result = onWatchUpdated.call(this, watch, diff);\n                    if (result !== false) {\n                        alreadyDirty.delete(watch);\n                    }\n                    return result;\n                } }));\n            if (alreadyDirty.size) {\n                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });\n            }\n        }\n        else {\n            this.broadcastWatches(options);\n        }\n        return updateResult;\n    };\n    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {\n        return this.batch({\n            update: update,\n            optimistic: optimisticId || (optimisticId !== null),\n        });\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.transformForLink = function (document) {\n        var fragments = this.config.fragments;\n        return fragments\n            ? fragments.transform(document)\n            : document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function (options) {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });\n        }\n    };\n    InMemoryCache.prototype.broadcastWatch = function (c, options) {\n        var lastDiff = c.lastDiff;\n        var diff = this.diff(c);\n        if (options) {\n            if (c.optimistic &&\n                typeof options.optimistic === \"string\") {\n                diff.fromOptimisticTransaction = true;\n            }\n            if (options.onWatchUpdated &&\n                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n                return;\n            }\n        }\n        if (!lastDiff || !equal(lastDiff.result, diff.result)) {\n            c.callback(c.lastDiff = diff, lastDiff);\n        }\n    };\n    return InMemoryCache;\n}(ApolloCache));\nexport { InMemoryCache };\n//# sourceMappingURL=inMemoryCache.js.map","import { __assign } from \"tslib\";\nimport \"../../utilities/globals/index.js\";\nimport { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet, isNonNullObject as isObjectOrArray, } from \"../../utilities/index.js\";\nimport { isArray } from \"./helpers.js\";\nfunction shallowCopy(value) {\n    if (isObjectOrArray(value)) {\n        return isArray(value)\n            ? value.slice(0)\n            : __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n    }\n    return value;\n}\nvar ObjectCanon = (function () {\n    function ObjectCanon() {\n        this.known = new (canUseWeakSet ? WeakSet : Set)();\n        this.pool = new Trie(canUseWeakMap);\n        this.passes = new WeakMap();\n        this.keysByJSON = new Map();\n        this.empty = this.admit({});\n    }\n    ObjectCanon.prototype.isKnown = function (value) {\n        return isObjectOrArray(value) && this.known.has(value);\n    };\n    ObjectCanon.prototype.pass = function (value) {\n        if (isObjectOrArray(value)) {\n            var copy = shallowCopy(value);\n            this.passes.set(copy, value);\n            return copy;\n        }\n        return value;\n    };\n    ObjectCanon.prototype.admit = function (value) {\n        var _this = this;\n        if (isObjectOrArray(value)) {\n            var original = this.passes.get(value);\n            if (original)\n                return original;\n            var proto = Object.getPrototypeOf(value);\n            switch (proto) {\n                case Array.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var array = value.map(this.admit, this);\n                    var node = this.pool.lookupArray(array);\n                    if (!node.array) {\n                        this.known.add(node.array = array);\n                        if (__DEV__) {\n                            Object.freeze(array);\n                        }\n                    }\n                    return node.array;\n                }\n                case null:\n                case Object.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var proto_1 = Object.getPrototypeOf(value);\n                    var array_1 = [proto_1];\n                    var keys = this.sortedKeys(value);\n                    array_1.push(keys.json);\n                    var firstValueIndex_1 = array_1.length;\n                    keys.sorted.forEach(function (key) {\n                        array_1.push(_this.admit(value[key]));\n                    });\n                    var node = this.pool.lookupArray(array_1);\n                    if (!node.object) {\n                        var obj_1 = node.object = Object.create(proto_1);\n                        this.known.add(obj_1);\n                        keys.sorted.forEach(function (key, i) {\n                            obj_1[key] = array_1[firstValueIndex_1 + i];\n                        });\n                        if (__DEV__) {\n                            Object.freeze(obj_1);\n                        }\n                    }\n                    return node.object;\n                }\n            }\n        }\n        return value;\n    };\n    ObjectCanon.prototype.sortedKeys = function (obj) {\n        var keys = Object.keys(obj);\n        var node = this.pool.lookupArray(keys);\n        if (!node.keys) {\n            keys.sort();\n            var json = JSON.stringify(keys);\n            if (!(node.keys = this.keysByJSON.get(json))) {\n                this.keysByJSON.set(json, node.keys = { sorted: keys, json: json });\n            }\n        }\n        return node.keys;\n    };\n    return ObjectCanon;\n}());\nexport { ObjectCanon };\nexport var canonicalStringify = Object.assign(function (value) {\n    if (isObjectOrArray(value)) {\n        if (stringifyCanon === void 0) {\n            resetCanonicalStringify();\n        }\n        var canonical = stringifyCanon.admit(value);\n        var json = stringifyCache.get(canonical);\n        if (json === void 0) {\n            stringifyCache.set(canonical, json = JSON.stringify(canonical));\n        }\n        return json;\n    }\n    return JSON.stringify(value);\n}, {\n    reset: resetCanonicalStringify,\n});\nvar stringifyCanon;\nvar stringifyCache;\nfunction resetCanonicalStringify() {\n    stringifyCanon = new ObjectCanon;\n    stringifyCache = new (canUseWeakMap ? WeakMap : Map)();\n}\n//# sourceMappingURL=object-canon.js.map","import { dep } from \"optimism\";\nimport { Slot } from \"@wry/context\";\nexport var cacheSlot = new Slot();\nvar cacheInfoMap = new WeakMap();\nfunction getCacheInfo(cache) {\n    var info = cacheInfoMap.get(cache);\n    if (!info) {\n        cacheInfoMap.set(cache, info = {\n            vars: new Set,\n            dep: dep(),\n        });\n    }\n    return info;\n}\nexport function forgetCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });\n}\nexport function recallCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });\n}\nexport function makeVar(value) {\n    var caches = new Set();\n    var listeners = new Set();\n    var rv = function (newValue) {\n        if (arguments.length > 0) {\n            if (value !== newValue) {\n                value = newValue;\n                caches.forEach(function (cache) {\n                    getCacheInfo(cache).dep.dirty(rv);\n                    broadcast(cache);\n                });\n                var oldListeners = Array.from(listeners);\n                listeners.clear();\n                oldListeners.forEach(function (listener) { return listener(value); });\n            }\n        }\n        else {\n            var cache = cacheSlot.getValue();\n            if (cache) {\n                attach(cache);\n                getCacheInfo(cache).dep(rv);\n            }\n        }\n        return value;\n    };\n    rv.onNextChange = function (listener) {\n        listeners.add(listener);\n        return function () {\n            listeners.delete(listener);\n        };\n    };\n    var attach = rv.attachCache = function (cache) {\n        caches.add(cache);\n        getCacheInfo(cache).vars.add(rv);\n        return rv;\n    };\n    rv.forgetCache = function (cache) { return caches.delete(cache); };\n    return rv;\n}\nfunction broadcast(cache) {\n    if (cache.broadcastWatches) {\n        cache.broadcastWatches();\n    }\n}\n//# sourceMappingURL=reactiveVars.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { visit, BREAK, } from 'graphql';\nimport { argumentsObjectFromField, buildQueryFromSelectionSet, createFragmentMap, getFragmentDefinitions, getMainDefinition, hasDirectives, isField, isInlineFragment, mergeDeep, mergeDeepArray, removeClientSetsFromDocument, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\nimport { cacheSlot } from \"../cache/index.js\";\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        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return removeClientSetsFromDocument(document);\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        var cache = this.cache;\n        return __assign(__assign({}, context), { cache: cache, getCacheKey: function (obj) {\n                return cache.identify(obj);\n            } });\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                    ? definitionOperation.charAt(0).toUpperCase() +\n                        definitionOperation.slice(1)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache, 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                            __DEV__ ? invariant(fragment, \"No fragment named \".concat(selection.name.value)) : invariant(fragment, 11);\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(cacheSlot.withValue(this.cache, resolve, [\n                                rootValue,\n                                argumentsObjectFromField(field, variables),\n                                execContext.context,\n                                { field: field, fragmentMap: execContext.fragmentMap },\n                            ]));\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}());\nexport { LocalState };\n//# sourceMappingURL=LocalState.js.map","import { __assign } from \"tslib\";\nimport { equal } from \"@wry/equality\";\nimport { DeepMerger } from \"../utilities/index.js\";\nimport { reobserveCacheFirst } from \"./ObservableQuery.js\";\nimport { isNonEmptyArray, graphQLResultHasError, canUseWeakMap, } from \"../utilities/index.js\";\nimport { NetworkStatus, isNetworkRequestInFlight, } from \"./networkStatus.js\";\n;\nvar destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();\nfunction wrapDestructiveCacheMethod(cache, methodName) {\n    var original = cache[methodName];\n    if (typeof original === \"function\") {\n        cache[methodName] = function () {\n            destructiveMethodCounts.set(cache, (destructiveMethodCounts.get(cache) + 1) % 1e15);\n            return original.apply(this, arguments);\n        };\n    }\n}\nfunction cancelNotifyTimeout(info) {\n    if (info[\"notifyTimeout\"]) {\n        clearTimeout(info[\"notifyTimeout\"]);\n        info[\"notifyTimeout\"] = void 0;\n    }\n}\nvar QueryInfo = (function () {\n    function QueryInfo(queryManager, queryId) {\n        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }\n        this.queryId = queryId;\n        this.listeners = new Set();\n        this.document = null;\n        this.lastRequestId = 1;\n        this.subscriptions = new Set();\n        this.stopped = false;\n        this.dirty = false;\n        this.observableQuery = null;\n        var cache = this.cache = queryManager.cache;\n        if (!destructiveMethodCounts.has(cache)) {\n            destructiveMethodCounts.set(cache, 0);\n            wrapDestructiveCacheMethod(cache, \"evict\");\n            wrapDestructiveCacheMethod(cache, \"modify\");\n            wrapDestructiveCacheMethod(cache, \"reset\");\n        }\n    }\n    QueryInfo.prototype.init = function (query) {\n        var networkStatus = query.networkStatus || NetworkStatus.loading;\n        if (this.variables &&\n            this.networkStatus !== NetworkStatus.loading &&\n            !equal(this.variables, query.variables)) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        if (!equal(query.variables, this.variables)) {\n            this.lastDiff = void 0;\n        }\n        Object.assign(this, {\n            document: query.document,\n            variables: query.variables,\n            networkError: null,\n            graphQLErrors: this.graphQLErrors || [],\n            networkStatus: networkStatus,\n        });\n        if (query.observableQuery) {\n            this.setObservableQuery(query.observableQuery);\n        }\n        if (query.lastRequestId) {\n            this.lastRequestId = query.lastRequestId;\n        }\n        return this;\n    };\n    QueryInfo.prototype.reset = function () {\n        cancelNotifyTimeout(this);\n        this.dirty = false;\n    };\n    QueryInfo.prototype.getDiff = function (variables) {\n        if (variables === void 0) { variables = this.variables; }\n        var options = this.getDiffOptions(variables);\n        if (this.lastDiff && equal(options, this.lastDiff.options)) {\n            return this.lastDiff.diff;\n        }\n        this.updateWatch(this.variables = variables);\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return { complete: false };\n        }\n        var diff = this.cache.diff(options);\n        this.updateLastDiff(diff, options);\n        return diff;\n    };\n    QueryInfo.prototype.updateLastDiff = function (diff, options) {\n        this.lastDiff = diff ? {\n            diff: diff,\n            options: options || this.getDiffOptions(),\n        } : void 0;\n    };\n    QueryInfo.prototype.getDiffOptions = function (variables) {\n        var _a;\n        if (variables === void 0) { variables = this.variables; }\n        return {\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,\n        };\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var oldDiff = this.lastDiff && this.lastDiff.diff;\n        this.updateLastDiff(diff);\n        if (!this.dirty &&\n            !equal(oldDiff && oldDiff.result, diff && diff.result)) {\n            this.dirty = true;\n            if (!this.notifyTimeout) {\n                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);\n            }\n        }\n    };\n    QueryInfo.prototype.setObservableQuery = function (oq) {\n        var _this = this;\n        if (oq === this.observableQuery)\n            return;\n        if (this.oqListener) {\n            this.listeners.delete(this.oqListener);\n        }\n        this.observableQuery = oq;\n        if (oq) {\n            oq[\"queryInfo\"] = this;\n            this.listeners.add(this.oqListener = function () {\n                var diff = _this.getDiff();\n                if (diff.fromOptimisticTransaction) {\n                    oq[\"observe\"]();\n                }\n                else {\n                    reobserveCacheFirst(oq);\n                }\n            });\n        }\n        else {\n            delete this.oqListener;\n        }\n    };\n    QueryInfo.prototype.notify = function () {\n        var _this = this;\n        cancelNotifyTimeout(this);\n        if (this.shouldNotify()) {\n            this.listeners.forEach(function (listener) { return listener(_this); });\n        }\n        this.dirty = false;\n    };\n    QueryInfo.prototype.shouldNotify = function () {\n        if (!this.dirty || !this.listeners.size) {\n            return false;\n        }\n        if (isNetworkRequestInFlight(this.networkStatus) &&\n            this.observableQuery) {\n            var fetchPolicy = this.observableQuery.options.fetchPolicy;\n            if (fetchPolicy !== \"cache-only\" &&\n                fetchPolicy !== \"cache-and-network\") {\n                return false;\n            }\n        }\n        return true;\n    };\n    QueryInfo.prototype.stop = function () {\n        if (!this.stopped) {\n            this.stopped = true;\n            this.reset();\n            this.cancel();\n            this.cancel = QueryInfo.prototype.cancel;\n            this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n            var oq = this.observableQuery;\n            if (oq)\n                oq.stopPolling();\n        }\n    };\n    QueryInfo.prototype.cancel = function () { };\n    QueryInfo.prototype.updateWatch = function (variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return;\n        }\n        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });\n        if (!this.lastWatch ||\n            !equal(watchOptions, this.lastWatch)) {\n            this.cancel();\n            this.cancel = this.cache.watch(this.lastWatch = watchOptions);\n        }\n    };\n    QueryInfo.prototype.resetLastWrite = function () {\n        this.lastWrite = void 0;\n    };\n    QueryInfo.prototype.shouldWrite = function (result, variables) {\n        var lastWrite = this.lastWrite;\n        return !(lastWrite &&\n            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&\n            equal(variables, lastWrite.variables) &&\n            equal(result.data, lastWrite.result.data));\n    };\n    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {\n        var _this = this;\n        var graphQLErrors = isNonEmptyArray(result.errors)\n            ? result.errors.slice(0)\n            : [];\n        this.reset();\n        if ('incremental' in result && isNonEmptyArray(result.incremental)) {\n            var mergedData_1 = this.getDiff().result;\n            var merger_1 = new DeepMerger();\n            result.incremental.forEach(function (_a) {\n                var data = _a.data, path = _a.path, errors = _a.errors;\n                for (var i = path.length - 1; i >= 0; --i) {\n                    var key = path[i];\n                    var isNumericKey = !isNaN(+key);\n                    var parent_1 = isNumericKey ? [] : {};\n                    parent_1[key] = data;\n                    data = parent_1;\n                }\n                if (errors) {\n                    graphQLErrors.push.apply(graphQLErrors, errors);\n                }\n                mergedData_1 = merger_1.merge(mergedData_1, data);\n            });\n            result.data = mergedData_1;\n        }\n        this.graphQLErrors = graphQLErrors;\n        if (options.fetchPolicy === 'no-cache') {\n            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));\n        }\n        else if (cacheWriteBehavior !== 0) {\n            if (shouldWriteResult(result, options.errorPolicy)) {\n                this.cache.performTransaction(function (cache) {\n                    if (_this.shouldWrite(result, options.variables)) {\n                        cache.writeQuery({\n                            query: document,\n                            data: result.data,\n                            variables: options.variables,\n                            overwrite: cacheWriteBehavior === 1,\n                        });\n                        _this.lastWrite = {\n                            result: result,\n                            variables: options.variables,\n                            dmCount: destructiveMethodCounts.get(_this.cache),\n                        };\n                    }\n                    else {\n                        if (_this.lastDiff &&\n                            _this.lastDiff.diff.complete) {\n                            result.data = _this.lastDiff.diff.result;\n                            return;\n                        }\n                    }\n                    var diffOptions = _this.getDiffOptions(options.variables);\n                    var diff = cache.diff(diffOptions);\n                    if (!_this.stopped) {\n                        _this.updateWatch(options.variables);\n                    }\n                    _this.updateLastDiff(diff, diffOptions);\n                    if (diff.complete) {\n                        result.data = diff.result;\n                    }\n                });\n            }\n            else {\n                this.lastWrite = void 0;\n            }\n        }\n    };\n    QueryInfo.prototype.markReady = function () {\n        this.networkError = null;\n        return this.networkStatus = NetworkStatus.ready;\n    };\n    QueryInfo.prototype.markError = function (error) {\n        this.networkStatus = NetworkStatus.error;\n        this.lastWrite = void 0;\n        this.reset();\n        if (error.graphQLErrors) {\n            this.graphQLErrors = error.graphQLErrors;\n        }\n        if (error.networkError) {\n            this.networkError = error.networkError;\n        }\n        return error;\n    };\n    return QueryInfo;\n}());\nexport { QueryInfo };\nexport function shouldWriteResult(result, errorPolicy) {\n    if (errorPolicy === void 0) { errorPolicy = \"none\"; }\n    var ignoreErrors = errorPolicy === \"ignore\" ||\n        errorPolicy === \"all\";\n    var writeWithErrors = !graphQLResultHasError(result);\n    if (!writeWithErrors && ignoreErrors && result.data) {\n        writeWithErrors = true;\n    }\n    return writeWithErrors;\n}\n//# sourceMappingURL=QueryInfo.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant, InvariantError } from \"../utilities/globals/index.js\";\nimport { equal } from '@wry/equality';\nimport { execute } from \"../link/core/index.js\";\nimport { isExecutionPatchIncrementalResult } from \"../utilities/common/incrementalResult.js\";\nimport { canonicalStringify } from \"../cache/index.js\";\nimport { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, removeConnectionDirectiveFromDocument, canUseWeakMap, Observable, asyncMap, isNonEmptyArray, Concast, makeUniqueId, isDocumentNode, isNonNullObject, cloneDeep, } from \"../utilities/index.js\";\nimport { ApolloError, isApolloError } from \"../errors/index.js\";\nimport { ObservableQuery, logMissingFieldErrors } from \"./ObservableQuery.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { LocalState } from \"./LocalState.js\";\nimport { QueryInfo, shouldWriteResult, } from \"./QueryInfo.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = (function () {\n    function QueryManager(_a) {\n        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, onBroadcast = _a.onBroadcast, _c = _a.ssrMode, ssrMode = _c === void 0 ? false : _c, _d = _a.clientAwareness, clientAwareness = _d === void 0 ? {} : _d, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;\n        this.clientAwareness = {};\n        this.queries = new Map();\n        this.fetchCancelFns = new Map();\n        this.transformCache = new (canUseWeakMap ? WeakMap : Map)();\n        this.queryIdCounter = 1;\n        this.requestIdCounter = 1;\n        this.mutationIdCounter = 1;\n        this.inFlightLinkObservables = new Map();\n        this.cache = cache;\n        this.link = link;\n        this.defaultOptions = defaultOptions || Object.create(null);\n        this.queryDeduplication = queryDeduplication;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: cache });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = !!assumeImmutableResults;\n        if ((this.onBroadcast = onBroadcast)) {\n            this.mutationStore = Object.create(null);\n        }\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.cancelPendingFetches(__DEV__ ? new InvariantError('QueryManager stopped while query was in flight') : new InvariantError(13));\n    };\n    QueryManager.prototype.cancelPendingFetches = function (error) {\n        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });\n        this.fetchCancelFns.clear();\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var _b, _c;\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _d = _a.refetchQueries, refetchQueries = _d === void 0 ? [] : _d, _e = _a.awaitRefetchQueries, awaitRefetchQueries = _e === void 0 ? false : _e, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _f = _a.fetchPolicy, fetchPolicy = _f === void 0 ? ((_b = this.defaultOptions.mutate) === null || _b === void 0 ? void 0 : _b.fetchPolicy) || \"network-only\" : _f, _g = _a.errorPolicy, errorPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.errorPolicy) || \"none\" : _g, keepRootFields = _a.keepRootFields, context = _a.context;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, _h, document, hasClientExports, mutationStoreValue, self;\n            return __generator(this, function (_j) {\n                switch (_j.label) {\n                    case 0:\n                        __DEV__ ? invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.') : invariant(mutation, 14);\n                        __DEV__ ? invariant(fetchPolicy === 'network-only' ||\n                            fetchPolicy === 'no-cache', \"Mutations support only 'network-only' or 'no-cache' fetchPolicy strings. The default `network-only` behavior automatically writes mutation results to the cache. Passing `no-cache` skips the cache write.\") : invariant(fetchPolicy === 'network-only' ||\n                            fetchPolicy === 'no-cache', 15);\n                        mutationId = this.generateMutationId();\n                        _h = this.transform(mutation), document = _h.document, hasClientExports = _h.hasClientExports;\n                        mutation = this.cache.transformForLink(document);\n                        variables = this.getVariables(mutation, variables);\n                        if (!hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = (_j.sent());\n                        _j.label = 2;\n                    case 2:\n                        mutationStoreValue = this.mutationStore &&\n                            (this.mutationStore[mutationId] = {\n                                mutation: mutation,\n                                variables: variables,\n                                loading: true,\n                                error: null,\n                            });\n                        if (optimisticResponse) {\n                            this.markMutationOptimistic(optimisticResponse, {\n                                mutationId: mutationId,\n                                document: mutation,\n                                variables: variables,\n                                fetchPolicy: fetchPolicy,\n                                errorPolicy: errorPolicy,\n                                context: context,\n                                updateQueries: updateQueries,\n                                update: updateWithProxyFn,\n                                keepRootFields: keepRootFields,\n                            });\n                        }\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false), function (result) {\n                                    if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                        throw new ApolloError({\n                                            graphQLErrors: result.errors,\n                                        });\n                                    }\n                                    if (mutationStoreValue) {\n                                        mutationStoreValue.loading = false;\n                                        mutationStoreValue.error = null;\n                                    }\n                                    var storeResult = __assign({}, result);\n                                    if (typeof refetchQueries === \"function\") {\n                                        refetchQueries = refetchQueries(storeResult);\n                                    }\n                                    if (errorPolicy === 'ignore' &&\n                                        graphQLResultHasError(storeResult)) {\n                                        delete storeResult.errors;\n                                    }\n                                    return self.markMutationResult({\n                                        mutationId: mutationId,\n                                        result: storeResult,\n                                        document: mutation,\n                                        variables: variables,\n                                        fetchPolicy: fetchPolicy,\n                                        errorPolicy: errorPolicy,\n                                        context: context,\n                                        update: updateWithProxyFn,\n                                        updateQueries: updateQueries,\n                                        awaitRefetchQueries: awaitRefetchQueries,\n                                        refetchQueries: refetchQueries,\n                                        removeOptimistic: optimisticResponse ? mutationId : void 0,\n                                        onQueryUpdated: onQueryUpdated,\n                                        keepRootFields: keepRootFields,\n                                    });\n                                }).subscribe({\n                                    next: function (storeResult) {\n                                        self.broadcastQueries();\n                                        resolve(storeResult);\n                                    },\n                                    error: function (err) {\n                                        if (mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = err;\n                                        }\n                                        if (optimisticResponse) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        reject(err instanceof ApolloError ? err : new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markMutationResult = function (mutation, cache) {\n        var _this = this;\n        if (cache === void 0) { cache = this.cache; }\n        var result = mutation.result;\n        var cacheWrites = [];\n        var skipCache = mutation.fetchPolicy === \"no-cache\";\n        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {\n            cacheWrites.push({\n                result: 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                this.queries.forEach(function (_a, queryId) {\n                    var observableQuery = _a.observableQuery;\n                    var queryName = observableQuery && observableQuery.queryName;\n                    if (!queryName || !hasOwnProperty.call(updateQueries_1, queryName)) {\n                        return;\n                    }\n                    var updater = updateQueries_1[queryName];\n                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;\n                    var _c = cache.diff({\n                        query: document,\n                        variables: variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _c.result, complete = _c.complete;\n                    if (complete && currentQueryResult) {\n                        var nextQueryResult = updater(currentQueryResult, {\n                            mutationResult: result,\n                            queryName: document && getOperationName(document) || void 0,\n                            queryVariables: variables,\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites.push({\n                                result: nextQueryResult,\n                                dataId: 'ROOT_QUERY',\n                                query: document,\n                                variables: variables,\n                            });\n                        }\n                    }\n                });\n            }\n        }\n        if (cacheWrites.length > 0 ||\n            mutation.refetchQueries ||\n            mutation.update ||\n            mutation.onQueryUpdated ||\n            mutation.removeOptimistic) {\n            var results_1 = [];\n            this.refetchQueries({\n                updateCache: function (cache) {\n                    if (!skipCache) {\n                        cacheWrites.forEach(function (write) { return cache.write(write); });\n                    }\n                    var update = mutation.update;\n                    if (update) {\n                        if (!skipCache) {\n                            var diff = cache.diff({\n                                id: \"ROOT_MUTATION\",\n                                query: _this.transform(mutation.document).asQuery,\n                                variables: mutation.variables,\n                                optimistic: false,\n                                returnPartialData: true,\n                            });\n                            if (diff.complete && !(isExecutionPatchIncrementalResult(result))) {\n                                result = __assign(__assign({}, result), { data: diff.result });\n                            }\n                        }\n                        update(cache, result, {\n                            context: mutation.context,\n                            variables: mutation.variables,\n                        });\n                    }\n                    if (!skipCache && !mutation.keepRootFields) {\n                        cache.modify({\n                            id: 'ROOT_MUTATION',\n                            fields: function (value, _a) {\n                                var fieldName = _a.fieldName, DELETE = _a.DELETE;\n                                return fieldName === \"__typename\" ? value : DELETE;\n                            },\n                        });\n                    }\n                },\n                include: mutation.refetchQueries,\n                optimistic: false,\n                removeOptimistic: mutation.removeOptimistic,\n                onQueryUpdated: mutation.onQueryUpdated || null,\n            }).forEach(function (result) { return results_1.push(result); });\n            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {\n                return Promise.all(results_1).then(function () { return result; });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {\n        var _this = this;\n        var data = typeof optimisticResponse === \"function\"\n            ? optimisticResponse(mutation.variables)\n            : optimisticResponse;\n        return this.cache.recordOptimisticTransaction(function (cache) {\n            try {\n                _this.markMutationResult(__assign(__assign({}, mutation), { result: { data: data } }), cache);\n            }\n            catch (error) {\n                __DEV__ && invariant.error(error);\n            }\n        }, mutation.mutationId);\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {\n        return this.fetchQueryObservable(queryId, options, networkStatus).promise;\n    };\n    QueryManager.prototype.getQueryStore = function () {\n        var store = Object.create(null);\n        this.queries.forEach(function (info, queryId) {\n            store[queryId] = {\n                variables: info.variables,\n                networkStatus: info.networkStatus,\n                networkError: info.networkError,\n                graphQLErrors: info.graphQLErrors,\n            };\n        });\n        return store;\n    };\n    QueryManager.prototype.resetErrors = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo) {\n            queryInfo.networkError = undefined;\n            queryInfo.graphQLErrors = [];\n        }\n    };\n    QueryManager.prototype.transform = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var transformed = this.cache.transformDocument(document);\n            var noConnection = removeConnectionDirectiveFromDocument(transformed);\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = noConnection && this.localState.serverQuery(noConnection);\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                asQuery: __assign(__assign({}, transformed), { definitions: transformed.definitions.map(function (def) {\n                        if (def.kind === \"OperationDefinition\" &&\n                            def.operation !== \"query\") {\n                            return __assign(__assign({}, def), { operation: \"query\" });\n                        }\n                        return def;\n                    }) })\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) {\n        options = __assign(__assign({}, options), { variables: this.getVariables(options.query, options.variables) });\n        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var queryInfo = new QueryInfo(this);\n        var observable = new ObservableQuery({\n            queryManager: this,\n            queryInfo: queryInfo,\n            options: options,\n        });\n        this.queries.set(observable.queryId, queryInfo);\n        queryInfo.init({\n            document: observable.query,\n            observableQuery: observable,\n            variables: observable.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options, queryId) {\n        var _this = this;\n        if (queryId === void 0) { queryId = this.generateQueryId(); }\n        __DEV__ ? invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.') : invariant(options.query, 16);\n        __DEV__ ? invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.') : invariant(options.query.kind === 'Document', 17);\n        __DEV__ ? invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.') : invariant(!options.returnPartialData, 18);\n        __DEV__ ? invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.') : invariant(!options.pollInterval, 19);\n        return this.fetchQuery(queryId, options).finally(function () { return _this.stopQuery(queryId); });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.queryIdCounter++);\n    };\n    QueryManager.prototype.generateRequestId = function () {\n        return this.requestIdCounter++;\n    };\n    QueryManager.prototype.generateMutationId = function () {\n        return String(this.mutationIdCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo)\n            queryInfo.stop();\n    };\n    QueryManager.prototype.clearStore = function (options) {\n        if (options === void 0) { options = {\n            discardWatches: true,\n        }; }\n        this.cancelPendingFetches(__DEV__ ? new InvariantError('Store reset while query was in flight (not completed in link chain)') : new InvariantError(20));\n        this.queries.forEach(function (queryInfo) {\n            if (queryInfo.observableQuery) {\n                queryInfo.networkStatus = NetworkStatus.loading;\n            }\n            else {\n                queryInfo.stop();\n            }\n        });\n        if (this.mutationStore) {\n            this.mutationStore = Object.create(null);\n        }\n        return this.cache.reset(options);\n    };\n    QueryManager.prototype.getObservableQueries = function (include) {\n        var _this = this;\n        if (include === void 0) { include = \"active\"; }\n        var queries = new Map();\n        var queryNamesAndDocs = new Map();\n        var legacyQueryOptions = new Set();\n        if (Array.isArray(include)) {\n            include.forEach(function (desc) {\n                if (typeof desc === \"string\") {\n                    queryNamesAndDocs.set(desc, false);\n                }\n                else if (isDocumentNode(desc)) {\n                    queryNamesAndDocs.set(_this.transform(desc).document, false);\n                }\n                else if (isNonNullObject(desc) && desc.query) {\n                    legacyQueryOptions.add(desc);\n                }\n            });\n        }\n        this.queries.forEach(function (_a, queryId) {\n            var oq = _a.observableQuery, document = _a.document;\n            if (oq) {\n                if (include === \"all\") {\n                    queries.set(queryId, oq);\n                    return;\n                }\n                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;\n                if (fetchPolicy === \"standby\" ||\n                    (include === \"active\" && !oq.hasObservers())) {\n                    return;\n                }\n                if (include === \"active\" ||\n                    (queryName && queryNamesAndDocs.has(queryName)) ||\n                    (document && queryNamesAndDocs.has(document))) {\n                    queries.set(queryId, oq);\n                    if (queryName)\n                        queryNamesAndDocs.set(queryName, true);\n                    if (document)\n                        queryNamesAndDocs.set(document, true);\n                }\n            }\n        });\n        if (legacyQueryOptions.size) {\n            legacyQueryOptions.forEach(function (options) {\n                var queryId = makeUniqueId(\"legacyOneTimeQuery\");\n                var queryInfo = _this.getQuery(queryId).init({\n                    document: options.query,\n                    variables: options.variables,\n                });\n                var oq = new ObservableQuery({\n                    queryManager: _this,\n                    queryInfo: queryInfo,\n                    options: __assign(__assign({}, options), { fetchPolicy: \"network-only\" }),\n                });\n                invariant(oq.queryId === queryId);\n                queryInfo.setObservableQuery(oq);\n                queries.set(queryId, oq);\n            });\n        }\n        if (__DEV__ && queryNamesAndDocs.size) {\n            queryNamesAndDocs.forEach(function (included, nameOrDoc) {\n                if (!included) {\n                    __DEV__ && invariant.warn(\"Unknown query \".concat(typeof nameOrDoc === \"string\" ? \"named \" : \"\").concat(JSON.stringify(nameOrDoc, null, 2), \" requested in refetchQueries options.include array\"));\n                }\n            });\n        }\n        return queries;\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.getObservableQueries(includeStandby ? \"all\" : \"active\").forEach(function (observableQuery, queryId) {\n            var fetchPolicy = observableQuery.options.fetchPolicy;\n            observableQuery.resetLastResults();\n            if (includeStandby ||\n                (fetchPolicy !== \"standby\" &&\n                    fetchPolicy !== \"cache-only\")) {\n                observableQueryPromises.push(observableQuery.refetch());\n            }\n            _this.getQuery(queryId).setDiff(null);\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.setObservableQuery = function (observableQuery) {\n        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, errorPolicy = _a.errorPolicy, variables = _a.variables, _b = _a.context, context = _b === void 0 ? {} : _b;\n        query = this.transform(query).document;\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, context, variables).map(function (result) {\n                if (fetchPolicy !== 'no-cache') {\n                    if (shouldWriteResult(result, errorPolicy)) {\n                        _this.cache.write({\n                            query: query,\n                            result: result.data,\n                            dataId: 'ROOT_SUBSCRIPTION',\n                            variables: variables,\n                        });\n                    }\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, context).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.fetchCancelFns.delete(queryId);\n        if (this.queries.has(queryId)) {\n            this.getQuery(queryId).stop();\n            this.queries.delete(queryId);\n        }\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        if (this.onBroadcast)\n            this.onBroadcast();\n        this.queries.forEach(function (info) { return info.notify(); });\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        var _a;\n        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }\n        var observable;\n        var serverQuery = this.transform(query).serverQuery;\n        if (serverQuery) {\n            var _b = this, inFlightLinkObservables_1 = _b.inFlightLinkObservables, link = _b.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 = canonicalStringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    var concast = new Concast([\n                        execute(link, operation)\n                    ]);\n                    byVariables_1.set(varJson_1, observable = concast);\n                    concast.beforeNext(function () {\n                        if (byVariables_1.delete(varJson_1) &&\n                            byVariables_1.size < 1) {\n                            inFlightLinkObservables_1.delete(serverQuery);\n                        }\n                    });\n                }\n            }\n            else {\n                observable = new Concast([\n                    execute(link, operation)\n                ]);\n            }\n        }\n        else {\n            observable = new Concast([\n                Observable.of({ data: {} })\n            ]);\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.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {\n        var requestId = queryInfo.lastRequestId = this.generateRequestId();\n        options = cloneDeep(options);\n        var linkDocument = this.cache.transformForLink(this.transform(queryInfo.document).document);\n        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {\n            var graphQLErrors = isNonEmptyArray(result.errors)\n                ? result.errors.slice(0)\n                : [];\n            if ('incremental' in result && isNonEmptyArray(result.incremental)) {\n                result.incremental.forEach(function (incrementalResult) {\n                    if (incrementalResult.errors) {\n                        graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);\n                    }\n                });\n            }\n            var hasErrors = isNonEmptyArray(graphQLErrors);\n            if (requestId >= queryInfo.lastRequestId) {\n                if (hasErrors && options.errorPolicy === \"none\") {\n                    throw queryInfo.markError(new ApolloError({\n                        graphQLErrors: graphQLErrors,\n                    }));\n                }\n                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: NetworkStatus.ready,\n            };\n            if (hasErrors && options.errorPolicy !== \"ignore\") {\n                aqr.errors = graphQLErrors;\n                aqr.networkStatus = NetworkStatus.error;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = isApolloError(networkError)\n                ? networkError\n                : new ApolloError({ networkError: networkError });\n            if (requestId >= queryInfo.lastRequestId) {\n                queryInfo.markError(error);\n            }\n            throw error;\n        });\n    };\n    QueryManager.prototype.fetchQueryObservable = function (queryId, options, networkStatus) {\n        var _this = this;\n        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }\n        var query = this.transform(options.query).document;\n        var variables = this.getVariables(query, options.variables);\n        var queryInfo = this.getQuery(queryId);\n        var defaults = this.defaultOptions.watchQuery;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? defaults && defaults.fetchPolicy || \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? defaults && defaults.errorPolicy || \"none\" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;\n        var normalized = Object.assign({}, options, {\n            query: query,\n            variables: variables,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n            returnPartialData: returnPartialData,\n            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,\n            context: context,\n        });\n        var fromVariables = function (variables) {\n            normalized.variables = variables;\n            var concastSources = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n            if (normalized.fetchPolicy !== \"standby\" &&\n                concastSources.length > 0 &&\n                queryInfo.observableQuery) {\n                queryInfo.observableQuery[\"applyNextFetchPolicy\"](\"after-fetch\", options);\n            }\n            return concastSources;\n        };\n        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };\n        this.fetchCancelFns.set(queryId, function (reason) {\n            cleanupCancelFn();\n            setTimeout(function () { return concast.cancel(reason); });\n        });\n        var concast = new Concast(this.transform(normalized.query).hasClientExports\n            ? this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context).then(fromVariables)\n            : fromVariables(normalized.variables));\n        concast.promise.then(cleanupCancelFn, cleanupCancelFn);\n        return concast;\n    };\n    QueryManager.prototype.refetchQueries = function (_a) {\n        var _this = this;\n        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId(\"refetchQueries\") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;\n        var includedQueriesById = new Map();\n        if (include) {\n            this.getObservableQueries(include).forEach(function (oq, queryId) {\n                includedQueriesById.set(queryId, {\n                    oq: oq,\n                    lastDiff: _this.getQuery(queryId).getDiff(),\n                });\n            });\n        }\n        var results = new Map;\n        if (updateCache) {\n            this.cache.batch({\n                update: updateCache,\n                optimistic: optimistic && removeOptimistic || false,\n                removeOptimistic: removeOptimistic,\n                onWatchUpdated: function (watch, diff, lastDiff) {\n                    var oq = watch.watcher instanceof QueryInfo &&\n                        watch.watcher.observableQuery;\n                    if (oq) {\n                        if (onQueryUpdated) {\n                            includedQueriesById.delete(oq.queryId);\n                            var result = onQueryUpdated(oq, diff, lastDiff);\n                            if (result === true) {\n                                result = oq.refetch();\n                            }\n                            if (result !== false) {\n                                results.set(oq, result);\n                            }\n                            return result;\n                        }\n                        if (onQueryUpdated !== null) {\n                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });\n                        }\n                    }\n                },\n            });\n        }\n        if (includedQueriesById.size) {\n            includedQueriesById.forEach(function (_a, queryId) {\n                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;\n                var result;\n                if (onQueryUpdated) {\n                    if (!diff) {\n                        var info = oq[\"queryInfo\"];\n                        info.reset();\n                        diff = info.getDiff();\n                    }\n                    result = onQueryUpdated(oq, diff, lastDiff);\n                }\n                if (!onQueryUpdated || result === true) {\n                    result = oq.refetch();\n                }\n                if (result !== false) {\n                    results.set(oq, result);\n                }\n                if (queryId.indexOf(\"legacyOneTimeQuery\") >= 0) {\n                    _this.stopQueryNoBroadcast(queryId);\n                }\n            });\n        }\n        if (removeOptimistic) {\n            this.cache.removeOptimistic(removeOptimistic);\n        }\n        return results;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, networkStatus) {\n        var _this = this;\n        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;\n        var oldNetworkStatus = queryInfo.networkStatus;\n        queryInfo.init({\n            document: this.transform(query).document,\n            variables: variables,\n            networkStatus: networkStatus,\n        });\n        var readCache = function () { return queryInfo.getDiff(variables); };\n        var resultsFromCache = function (diff, networkStatus) {\n            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }\n            var data = diff.result;\n            if (__DEV__ &&\n                !returnPartialData &&\n                !equal(data, {})) {\n                logMissingFieldErrors(diff.missing);\n            }\n            var fromData = function (data) { return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true }))); };\n            if (data && _this.transform(query).hasForcedResolvers) {\n                return _this.localState.runResolvers({\n                    document: query,\n                    remoteResult: { data: data },\n                    context: context,\n                    variables: variables,\n                    onlyRunForcedResolvers: true,\n                }).then(function (resolved) { return fromData(resolved.data || void 0); });\n            }\n            return fromData(data);\n        };\n        var cacheWriteBehavior = fetchPolicy === \"no-cache\" ? 0 :\n            (networkStatus === NetworkStatus.refetch &&\n                refetchWritePolicy !== \"merge\") ? 1\n                : 2;\n        var resultsFromLink = function () { return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {\n            variables: variables,\n            context: context,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n        }); };\n        var shouldNotify = notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus);\n        switch (fetchPolicy) {\n            default:\n            case \"cache-first\": {\n                var diff = readCache();\n                if (diff.complete) {\n                    return [\n                        resultsFromCache(diff, queryInfo.markReady()),\n                    ];\n                }\n                if (returnPartialData || shouldNotify) {\n                    return [\n                        resultsFromCache(diff),\n                        resultsFromLink(),\n                    ];\n                }\n                return [\n                    resultsFromLink(),\n                ];\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData || shouldNotify) {\n                    return [\n                        resultsFromCache(diff),\n                        resultsFromLink(),\n                    ];\n                }\n                return [\n                    resultsFromLink(),\n                ];\n            }\n            case \"cache-only\":\n                return [\n                    resultsFromCache(readCache(), queryInfo.markReady()),\n                ];\n            case \"network-only\":\n                if (shouldNotify) {\n                    return [\n                        resultsFromCache(readCache()),\n                        resultsFromLink(),\n                    ];\n                }\n                return [resultsFromLink()];\n            case \"no-cache\":\n                if (shouldNotify) {\n                    return [\n                        resultsFromCache(queryInfo.getDiff()),\n                        resultsFromLink(),\n                    ];\n                }\n                return [resultsFromLink()];\n            case \"standby\":\n                return [];\n        }\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        if (queryId && !this.queries.has(queryId)) {\n            this.queries.set(queryId, new QueryInfo(this, queryId));\n        }\n        return this.queries.get(queryId);\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    return QueryManager;\n}());\nexport { QueryManager };\n//# sourceMappingURL=QueryManager.js.map","export function isExecutionPatchIncrementalResult(value) {\n    return !!value.incremental;\n}\n//# sourceMappingURL=incrementalResult.js.map","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from \"../utilities/globals/index.js\";\nimport { ApolloLink, execute } from \"../link/core/index.js\";\nimport { version } from \"../version.js\";\nimport { HttpLink } from \"../link/http/index.js\";\nimport { QueryManager } from \"./QueryManager.js\";\nimport { LocalState, } from \"./LocalState.js\";\nvar hasSuggestedDevtools = false;\nimport { mergeOptions } from \"../utilities/index.js\";\nexport { mergeOptions };\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, _c = options.connectToDevTools, connectToDevTools = _c === void 0 ? typeof window === 'object' &&\n            !window.__APOLLO_CLIENT__ &&\n            __DEV__ : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? false : _e, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;\n        var link = options.link;\n        if (!link) {\n            link = uri\n                ? new HttpLink({ uri: uri, credentials: credentials, headers: headers })\n                : ApolloLink.empty();\n        }\n        if (!cache) {\n            throw __DEV__ ? new InvariantError(\"To initialize Apollo Client, you must specify a 'cache' property \" +\n                \"in the options object. \\n\" +\n                \"For more information, please visit: https://go.apollo.dev/c/docs\") : new InvariantError(9);\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || Object.create(null);\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        if (connectToDevTools && typeof window === 'object') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && __DEV__) {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self &&\n                !window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {\n                var nav = window.navigator;\n                var ua = nav && nav.userAgent;\n                var url = void 0;\n                if (typeof ua === \"string\") {\n                    if (ua.indexOf(\"Chrome/\") > -1) {\n                        url = \"https://chrome.google.com/webstore/detail/\" +\n                            \"apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm\";\n                    }\n                    else if (ua.indexOf(\"Firefox/\") > -1) {\n                        url = \"https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/\";\n                    }\n                }\n                if (url) {\n                    __DEV__ && invariant.log(\"Download the Apollo DevTools for a better development \" +\n                        \"experience: \" + url);\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            cache: this.cache,\n            link: this.link,\n            defaultOptions: this.defaultOptions,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: connectToDevTools ? function () {\n                if (_this.devToolsHookCb) {\n                    _this.devToolsHookCb({\n                        action: {},\n                        state: {\n                            queries: _this.queryManager.getQueryStore(),\n                            mutations: _this.queryManager.mutationStore || {},\n                        },\n                        dataWithOptimisticResults: _this.cache.extract(true),\n                    });\n                }\n            } : void 0,\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 = mergeOptions(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 = mergeOptions(this.defaultOptions.query, options);\n        }\n        __DEV__ ? 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.') : invariant(options.fetchPolicy !== 'cache-and-network', 10);\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 = mergeOptions(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        this.cache.writeQuery(options);\n        this.queryManager.broadcastQueries();\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        this.cache.writeFragment(options);\n        this.queryManager.broadcastQueries();\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.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore({\n            discardWatches: false,\n        }); })\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            discardWatches: true,\n        }); })\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.refetchQueries = function (options) {\n        var map = this.queryManager.refetchQueries(options);\n        var queries = [];\n        var results = [];\n        map.forEach(function (result, obsQuery) {\n            queries.push(obsQuery);\n            results.push(result);\n        });\n        var result = Promise.all(results);\n        result.queries = queries;\n        result.results = results;\n        result.catch(function (error) {\n            __DEV__ && invariant.debug(\"In client.refetchQueries, Promise.all promise rejected with error \".concat(error));\n        });\n        return result;\n    };\n    ApolloClient.prototype.getObservableQueries = function (include) {\n        if (include === void 0) { include = \"active\"; }\n        return this.queryManager.getObservableQueries(include);\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    ApolloClient.prototype.setLink = function (newLink) {\n        this.link = this.queryManager.link = newLink;\n    };\n    return ApolloClient;\n}());\nexport { ApolloClient };\n//# sourceMappingURL=ApolloClient.js.map","export var version = '3.7.0';\n//# sourceMappingURL=version.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { equal } from '@wry/equality';\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { cloneDeep, compact, getOperationDefinition, Observable, iterateObserversSafely, isNonEmptyArray, fixObservableSubclass, getQueryDefinition, } from \"../utilities/index.js\";\nvar assign = Object.assign, hasOwnProperty = Object.hasOwnProperty;\nvar ObservableQuery = (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;\n        var _this = _super.call(this, function (observer) {\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            var last = _this.last;\n            if (last && last.error) {\n                observer.error && observer.error(last.error);\n            }\n            else if (last && last.result) {\n                observer.next && observer.next(last.result);\n            }\n            if (first) {\n                _this.reobserve().catch(function () { });\n            }\n            return function () {\n                if (_this.observers.delete(observer) && !_this.observers.size) {\n                    _this.tearDownQuery();\n                }\n            };\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.queryInfo = queryInfo;\n        _this.queryManager = queryManager;\n        _this.isTornDown = false;\n        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? \"cache-first\" : _d;\n        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, _f = options.initialFetchPolicy, initialFetchPolicy = _f === void 0 ? (fetchPolicy === \"standby\" ? defaultFetchPolicy : fetchPolicy) : _f;\n        _this.options = __assign(__assign({}, options), { initialFetchPolicy: initialFetchPolicy, fetchPolicy: fetchPolicy });\n        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();\n        var opDef = getOperationDefinition(_this.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        return _this;\n    }\n    Object.defineProperty(ObservableQuery.prototype, \"query\", {\n        get: function () {\n            return this.queryManager.transform(this.options.query).document;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(ObservableQuery.prototype, \"variables\", {\n        get: function () {\n            return this.options.variables;\n        },\n        enumerable: false,\n        configurable: true\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.getCurrentResult = function (saveAsLastResult) {\n        if (saveAsLastResult === void 0) { saveAsLastResult = true; }\n        var lastResult = this.getLastResult(true);\n        var networkStatus = this.queryInfo.networkStatus ||\n            (lastResult && lastResult.networkStatus) ||\n            NetworkStatus.ready;\n        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a;\n        if (fetchPolicy === 'network-only' ||\n            fetchPolicy === 'no-cache' ||\n            fetchPolicy === 'standby' ||\n            this.queryManager.transform(this.options.query).hasForcedResolvers) {\n        }\n        else {\n            var diff = this.queryInfo.getDiff();\n            if (diff.complete || this.options.returnPartialData) {\n                result.data = diff.result;\n            }\n            if (equal(result.data, {})) {\n                result.data = void 0;\n            }\n            if (diff.complete) {\n                delete result.partial;\n                if (diff.complete &&\n                    result.networkStatus === NetworkStatus.loading &&\n                    (fetchPolicy === 'cache-first' ||\n                        fetchPolicy === 'cache-only')) {\n                    result.networkStatus = NetworkStatus.ready;\n                    result.loading = false;\n                }\n            }\n            else {\n                result.partial = true;\n            }\n            if (__DEV__ &&\n                !diff.complete &&\n                !this.options.partialRefetch &&\n                !result.loading &&\n                !result.data &&\n                !result.error) {\n                logMissingFieldErrors(diff.missing);\n            }\n        }\n        if (saveAsLastResult) {\n            this.updateLastResult(result);\n        }\n        return result;\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        return !this.last || !equal(this.last.result, newResult);\n    };\n    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {\n        var last = this.last;\n        if (last &&\n            last[key] &&\n            (!variablesMustMatch || equal(last.variables, this.variables))) {\n            return last[key];\n        }\n    };\n    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {\n        return this.getLast(\"result\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {\n        return this.getLast(\"error\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.last;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        this.queryManager.resetErrors(this.queryId);\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var _a;\n        var reobserveOptions = {\n            pollInterval: 0,\n        };\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === 'cache-and-network') {\n            reobserveOptions.fetchPolicy = fetchPolicy;\n        }\n        else if (fetchPolicy === 'no-cache') {\n            reobserveOptions.fetchPolicy = 'no-cache';\n        }\n        else {\n            reobserveOptions.fetchPolicy = 'network-only';\n        }\n        if (__DEV__ && variables && hasOwnProperty.call(variables, \"variables\")) {\n            var queryDef = getQueryDefinition(this.query);\n            var vars = queryDef.variableDefinitions;\n            if (!vars || !vars.some(function (v) { return v.variable.name.value === \"variables\"; })) {\n                __DEV__ && invariant.warn(\"Called refetch(\".concat(JSON.stringify(variables), \") for query \").concat(((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || JSON.stringify(queryDef), \", which does not declare a $variables variable.\\nDid you mean to call refetch(variables) instead of refetch({ variables })?\"));\n            }\n        }\n        if (variables && !equal(this.options.variables, variables)) {\n            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);\n        }\n        this.queryInfo.resetLastWrite();\n        return this.reobserve(reobserveOptions, NetworkStatus.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign(__assign({}, this.options), { query: this.query }), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) }))), { fetchPolicy: \"no-cache\" });\n        var qid = this.queryManager.generateQueryId();\n        var queryInfo = this.queryInfo;\n        var originalNetworkStatus = queryInfo.networkStatus;\n        queryInfo.networkStatus = NetworkStatus.fetchMore;\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            this.observe();\n        }\n        var updatedQuerySet = new Set();\n        return this.queryManager.fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore).then(function (fetchMoreResult) {\n            _this.queryManager.removeQuery(qid);\n            if (queryInfo.networkStatus === NetworkStatus.fetchMore) {\n                queryInfo.networkStatus = originalNetworkStatus;\n            }\n            _this.queryManager.cache.batch({\n                update: function (cache) {\n                    var updateQuery = fetchMoreOptions.updateQuery;\n                    if (updateQuery) {\n                        cache.updateQuery({\n                            query: _this.query,\n                            variables: _this.variables,\n                            returnPartialData: true,\n                            optimistic: false,\n                        }, function (previous) { return updateQuery(previous, {\n                            fetchMoreResult: fetchMoreResult.data,\n                            variables: combinedOptions.variables,\n                        }); });\n                    }\n                    else {\n                        cache.writeQuery({\n                            query: combinedOptions.query,\n                            variables: combinedOptions.variables,\n                            data: fetchMoreResult.data,\n                        });\n                    }\n                },\n                onWatchUpdated: function (watch) {\n                    updatedQuerySet.add(watch.query);\n                },\n            });\n            return fetchMoreResult;\n        }).finally(function () {\n            if (!updatedQuerySet.has(_this.query)) {\n                reobserveCacheFirst(_this);\n            }\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            context: options.context,\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                __DEV__ && 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 (newOptions) {\n        return this.reobserve(newOptions);\n    };\n    ObservableQuery.prototype.setVariables = function (variables) {\n        if (equal(this.variables, variables)) {\n            return this.observers.size\n                ? this.result()\n                : Promise.resolve();\n        }\n        this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.reobserve({\n            fetchPolicy: this.options.initialFetchPolicy,\n            variables: variables,\n        }, NetworkStatus.setVariables);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var result = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n        var newResult = mapFn(result, {\n            variables: this.variables,\n        });\n        if (newResult) {\n            queryManager.cache.writeQuery({\n                query: this.options.query,\n                data: newResult,\n                variables: this.variables,\n            });\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.options.pollInterval = pollInterval;\n        this.updatePolling();\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.options.pollInterval = 0;\n        this.updatePolling();\n    };\n    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, options) {\n        if (options.nextFetchPolicy) {\n            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;\n            if (fetchPolicy === \"standby\") {\n            }\n            else if (typeof options.nextFetchPolicy === \"function\") {\n                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {\n                    reason: reason,\n                    options: options,\n                    observable: this,\n                    initialFetchPolicy: initialFetchPolicy,\n                });\n            }\n            else if (reason === \"variables-changed\") {\n                options.fetchPolicy = initialFetchPolicy;\n            }\n            else {\n                options.fetchPolicy = options.nextFetchPolicy;\n            }\n        }\n        return options.fetchPolicy;\n    };\n    ObservableQuery.prototype.fetch = function (options, newNetworkStatus) {\n        this.queryManager.setObservableQuery(this);\n        return this.queryManager.fetchQueryObservable(this.queryId, options, newNetworkStatus);\n    };\n    ObservableQuery.prototype.updatePolling = function () {\n        var _this = this;\n        if (this.queryManager.ssrMode) {\n            return;\n        }\n        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;\n        if (!pollInterval) {\n            if (pollingInfo) {\n                clearTimeout(pollingInfo.timeout);\n                delete this.pollingInfo;\n            }\n            return;\n        }\n        if (pollingInfo &&\n            pollingInfo.interval === pollInterval) {\n            return;\n        }\n        __DEV__ ? invariant(pollInterval, 'Attempted to start a polling query without a polling interval.') : invariant(pollInterval, 12);\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            if (_this.pollingInfo) {\n                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus)) {\n                    _this.reobserve({\n                        fetchPolicy: _this.options.initialFetchPolicy === 'no-cache' ? 'no-cache' : 'network-only',\n                    }, NetworkStatus.poll).then(poll, poll);\n                }\n                else {\n                    poll();\n                }\n            }\n            ;\n        };\n        var poll = function () {\n            var info = _this.pollingInfo;\n            if (info) {\n                clearTimeout(info.timeout);\n                info.timeout = setTimeout(maybeFetch, info.interval);\n            }\n        };\n        poll();\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {\n        if (variables === void 0) { variables = this.variables; }\n        this.last = __assign(__assign({}, this.last), { result: this.queryManager.assumeImmutableResults\n                ? newResult\n                : cloneDeep(newResult), variables: variables });\n        if (!isNonEmptyArray(newResult.errors)) {\n            delete this.last.error;\n        }\n        return this.last;\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        var _this = this;\n        this.isTornDown = false;\n        var useDisposableConcast = newNetworkStatus === NetworkStatus.refetch ||\n            newNetworkStatus === NetworkStatus.fetchMore ||\n            newNetworkStatus === NetworkStatus.poll;\n        var oldVariables = this.options.variables;\n        var oldFetchPolicy = this.options.fetchPolicy;\n        var mergedOptions = compact(this.options, newOptions || {});\n        var options = useDisposableConcast\n            ? mergedOptions\n            : assign(this.options, mergedOptions);\n        if (!useDisposableConcast) {\n            this.updatePolling();\n            if (newOptions &&\n                newOptions.variables &&\n                !equal(newOptions.variables, oldVariables) &&\n                options.fetchPolicy !== \"standby\" &&\n                options.fetchPolicy === oldFetchPolicy) {\n                this.applyNextFetchPolicy(\"variables-changed\", options);\n                if (newNetworkStatus === void 0) {\n                    newNetworkStatus = NetworkStatus.setVariables;\n                }\n            }\n        }\n        var variables = options.variables && __assign({}, options.variables);\n        var concast = this.fetch(options, newNetworkStatus);\n        var observer = {\n            next: function (result) {\n                _this.reportResult(result, variables);\n            },\n            error: function (error) {\n                _this.reportError(error, variables);\n            },\n        };\n        if (!useDisposableConcast) {\n            if (this.concast && this.observer) {\n                this.concast.removeObserver(this.observer);\n            }\n            this.concast = concast;\n            this.observer = observer;\n        }\n        concast.addObserver(observer);\n        return concast.promise;\n    };\n    ObservableQuery.prototype.observe = function () {\n        this.reportResult(this.getCurrentResult(false), this.variables);\n    };\n    ObservableQuery.prototype.reportResult = function (result, variables) {\n        var lastError = this.getLastError();\n        if (lastError || this.isDifferentFromLastResult(result)) {\n            if (lastError || !result.partial || this.options.returnPartialData) {\n                this.updateLastResult(result, variables);\n            }\n            iterateObserversSafely(this.observers, 'next', result);\n        }\n    };\n    ObservableQuery.prototype.reportError = function (error, variables) {\n        var errorResult = __assign(__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false });\n        this.updateLastResult(errorResult, variables);\n        iterateObserversSafely(this.observers, 'error', this.last.error = error);\n    };\n    ObservableQuery.prototype.hasObservers = function () {\n        return this.observers.size > 0;\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        if (this.isTornDown)\n            return;\n        if (this.concast && this.observer) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n            delete this.observer;\n        }\n        this.stopPolling();\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        this.queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n        this.isTornDown = true;\n    };\n    return ObservableQuery;\n}(Observable));\nexport { ObservableQuery };\nfixObservableSubclass(ObservableQuery);\nexport function reobserveCacheFirst(obsQuery) {\n    var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;\n    if (fetchPolicy === \"cache-and-network\" ||\n        fetchPolicy === \"network-only\") {\n        return obsQuery.reobserve({\n            fetchPolicy: \"cache-first\",\n            nextFetchPolicy: function () {\n                this.nextFetchPolicy = nextFetchPolicy;\n                if (typeof nextFetchPolicy === \"function\") {\n                    return nextFetchPolicy.apply(this, arguments);\n                }\n                return fetchPolicy;\n            },\n        });\n    }\n    return obsQuery.reobserve();\n}\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    __DEV__ && invariant.error('Unhandled error', error.message, error.stack);\n}\nexport function logMissingFieldErrors(missing) {\n    if (__DEV__ && missing) {\n        __DEV__ && invariant.debug(\"Missing cache result fields: \".concat(JSON.stringify(missing)), missing);\n    }\n}\n//# sourceMappingURL=ObservableQuery.js.map","export var Cache;\n(function (Cache) {\n})(Cache || (Cache = {}));\n//# sourceMappingURL=Cache.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var empty = ApolloLink.empty;\n//# sourceMappingURL=empty.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var from = ApolloLink.from;\n//# sourceMappingURL=from.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var split = ApolloLink.split;\n//# sourceMappingURL=split.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var concat = ApolloLink.concat;\n//# sourceMappingURL=concat.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nexport function toPromise(observable) {\n    var completed = false;\n    return new Promise(function (resolve, reject) {\n        observable.subscribe({\n            next: function (data) {\n                if (completed) {\n                    __DEV__ && 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}\n//# sourceMappingURL=toPromise.js.map","import { Observable } from \"../../utilities/index.js\";\nexport function 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}\n//# sourceMappingURL=fromPromise.js.map","import { DEV } from \"../utilities/globals/index.js\";\nexport { ApolloClient, mergeOptions, } from \"./ApolloClient.js\";\nexport { ObservableQuery, } from \"./ObservableQuery.js\";\nexport { NetworkStatus } from \"./networkStatus.js\";\nexport * from \"./types.js\";\nexport { isApolloError, ApolloError } from \"../errors/index.js\";\nexport { Cache, ApolloCache, InMemoryCache, MissingFieldError, defaultDataIdFromObject, makeVar, } from \"../cache/index.js\";\nexport * from \"../cache/inmemory/types.js\";\nexport * from \"../link/core/index.js\";\nexport * from \"../link/http/index.js\";\nexport { fromError, toPromise, fromPromise, throwServerError, } from \"../link/utils/index.js\";\nexport { Observable, isReference, makeReference, } from \"../utilities/index.js\";\nimport { setVerbosity } from \"ts-invariant\";\nexport { setVerbosity as setLogVerbosity };\nsetVerbosity(DEV ? \"log\" : \"silent\");\nexport { gql, resetCaches, disableFragmentWarnings, enableExperimentalFragmentVariables, disableExperimentalFragmentVariables, } from 'graphql-tag';\n//# sourceMappingURL=index.js.map","export var 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 = {}));\nexport function isNetworkRequestInFlight(networkStatus) {\n    return networkStatus ? networkStatus < 7 : false;\n}\n//# sourceMappingURL=networkStatus.js.map","import { __extends } from \"tslib\";\nimport \"../utilities/globals/index.js\";\nimport { isNonEmptyArray } from \"../utilities/index.js\";\nexport function isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (isNonEmptyArray(err.graphQLErrors) || isNonEmptyArray(err.clientErrors)) {\n        var errors = (err.graphQLErrors || [])\n            .concat(err.clientErrors || []);\n        errors.forEach(function (error) {\n            var errorMessage = error\n                ? error.message\n                : 'Error message not found.';\n            message += \"\".concat(errorMessage, \"\\n\");\n        });\n    }\n    if (err.networkError) {\n        message += \"\".concat(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, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.clientErrors = clientErrors || [];\n        _this.networkError = networkError || null;\n        _this.message = errorMessage || generateErrorMessage(_this);\n        _this.extraInfo = extraInfo;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\nexport { ApolloError };\n//# sourceMappingURL=index.js.map","import { __extends } from \"tslib\";\nimport { InvariantError, invariant } from \"../../utilities/globals/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { validateOperation, createOperation, transformOperation, } from \"../utils/index.js\";\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 isTerminating(link) {\n    return link.request.length <= 1;\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));\nvar ApolloLink = (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.empty = function () {\n        return new ApolloLink(function () { return Observable.of(); });\n    };\n    ApolloLink.from = function (links) {\n        if (links.length === 0)\n            return ApolloLink.empty();\n        return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n    };\n    ApolloLink.split = function (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    };\n    ApolloLink.execute = function (link, operation) {\n        return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n    };\n    ApolloLink.concat = function (first, second) {\n        var firstLink = toLink(first);\n        if (isTerminating(firstLink)) {\n            __DEV__ && 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    };\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return ApolloLink.concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw __DEV__ ? new InvariantError('request is not implemented') : new InvariantError(21);\n    };\n    ApolloLink.prototype.onError = function (error, observer) {\n        if (observer && observer.error) {\n            observer.error(error);\n            return false;\n        }\n        throw error;\n    };\n    ApolloLink.prototype.setOnError = function (fn) {\n        this.onError = fn;\n        return this;\n    };\n    return ApolloLink;\n}());\nexport { ApolloLink };\n//# sourceMappingURL=ApolloLink.js.map","import { __assign } from \"tslib\";\nexport function createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === 'function') {\n            context = __assign(__assign({}, context), next(context));\n        }\n        else {\n            context = __assign(__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    return operation;\n}\n//# sourceMappingURL=createOperation.js.map","import { getOperationName } from \"../../utilities/index.js\";\nexport function 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) || undefined\n                : '';\n    }\n    return transformedOperation;\n}\n//# sourceMappingURL=transformOperation.js.map","import { InvariantError } from \"../../utilities/globals/index.js\";\nexport function 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 __DEV__ ? new InvariantError(\"illegal argument: \".concat(key)) : new InvariantError(26);\n        }\n    }\n    return operation;\n}\n//# sourceMappingURL=validateOperation.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var execute = ApolloLink.execute;\n//# sourceMappingURL=execute.js.map","import { __extends } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { createHttpLink } from \"./createHttpLink.js\";\nvar HttpLink = (function (_super) {\n    __extends(HttpLink, _super);\n    function HttpLink(options) {\n        if (options === void 0) { options = {}; }\n        var _this = _super.call(this, createHttpLink(options).request) || this;\n        _this.options = options;\n        return _this;\n    }\n    return HttpLink;\n}(ApolloLink));\nexport { HttpLink };\n//# sourceMappingURL=HttpLink.js.map","import { InvariantError } from \"../../utilities/globals/index.js\";\nexport var checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === 'undefined') {\n        throw __DEV__ ? new InvariantError(\"\\n\\\"fetch\\\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\\n\\nimport fetch from 'cross-fetch';\\nimport { ApolloClient, HttpLink } from '@apollo/client';\\nconst client = new ApolloClient({\\n  link: new HttpLink({ uri: '/graphql', fetch })\\n});\\n    \") : new InvariantError(22);\n    }\n};\n//# sourceMappingURL=checkFetcher.js.map","import { __assign, __rest } from \"tslib\";\nimport \"../../utilities/globals/index.js\";\nimport { visit } from 'graphql';\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable, hasDirectives } from \"../../utilities/index.js\";\nimport { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nimport { selectURI } from \"./selectURI.js\";\nimport { handleError, readMultipartBody, readJsonBody } from \"./parseAndCheckHttpResponse.js\";\nimport { checkFetcher } from \"./checkFetcher.js\";\nimport { selectHttpOptionsAndBodyInternal, defaultPrinter, fallbackHttpConfig } from \"./selectHttpOptionsAndBody.js\";\nimport { createSignalIfSupported } from \"./createSignalIfSupported.js\";\nimport { rewriteURIForGET } from \"./rewriteURIForGET.js\";\nimport { fromError } from \"../utils/index.js\";\nimport { maybe } from \"../../utilities/index.js\";\nvar backupFetch = maybe(function () { return fetch; });\nexport var createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, preserveHeaderCase = linkOptions.preserveHeaderCase, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"print\", \"includeExtensions\", \"preserveHeaderCase\", \"useGETForQueries\", \"includeUnusedVariables\"]);\n    if (__DEV__) {\n        checkFetcher(preferredFetch || backupFetch);\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions, preserveHeaderCase: preserveHeaderCase },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders['apollographql-client-name'] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders['apollographql-client-version'] = version;\n            }\n        }\n        var contextHeaders = __assign(__assign({}, clientAwarenessHeaders), context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        if (body.variables && !includeUnusedVariables) {\n            var unusedNames_1 = new Set(Object.keys(body.variables));\n            visit(operation.query, {\n                Variable: function (node, _key, parent) {\n                    if (parent && parent.kind !== 'VariableDefinition') {\n                        unusedNames_1.delete(node.name.value);\n                    }\n                },\n            });\n            if (unusedNames_1.size) {\n                body.variables = __assign({}, body.variables);\n                unusedNames_1.forEach(function (name) {\n                    delete body.variables[name];\n                });\n            }\n        }\n        var controller;\n        if (!options.signal) {\n            var _c = createSignalIfSupported(), _controller = _c.controller, signal = _c.signal;\n            controller = _controller;\n            if (controller)\n                options.signal = signal;\n        }\n        var definitionIsMutation = function (d) {\n            return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n        };\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = 'GET';\n        }\n        if (hasDirectives(['defer'], operation.query)) {\n            options.headers.accept = \"multipart/mixed; deferSpec=20220824, application/json\";\n        }\n        if (options.method === 'GET') {\n            var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, 'Payload');\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;\n            currentFetch(chosenURI, options)\n                .then(function (response) {\n                var _a;\n                operation.setContext({ response: response });\n                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type');\n                if (ctype !== null && /^multipart\\/mixed/i.test(ctype)) {\n                    return readMultipartBody(response, observer);\n                }\n                else {\n                    return readJsonBody(response, operation, observer);\n                }\n            })\n                .catch(function (err) { return handleError(err, observer); });\n            return function () {\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n//# sourceMappingURL=createHttpLink.js.map","export var 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};\n//# sourceMappingURL=createSignalIfSupported.js.map","import { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function readerIterator(reader) {\n    var iterator = {\n        next: function () {\n            return reader.read();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=reader.js.map","import { isAsyncIterableIterator, isBlob, isNodeResponse, isNodeReadableStream, isReadableStream, isStreamableBlob, } from \"../../utilities/common/responseIterator.js\";\nimport asyncIterator from \"./iterators/async.js\";\nimport nodeStreamIterator from \"./iterators/nodeStream.js\";\nimport promiseIterator from \"./iterators/promise.js\";\nimport readerIterator from \"./iterators/reader.js\";\nexport function responseIterator(response) {\n    var body = response;\n    if (isNodeResponse(response))\n        body = response.body;\n    if (isAsyncIterableIterator(body))\n        return asyncIterator(body);\n    if (isReadableStream(body))\n        return readerIterator(body.getReader());\n    if (isStreamableBlob(body)) {\n        return readerIterator(body.stream().getReader());\n    }\n    if (isBlob(body))\n        return promiseIterator(body.arrayBuffer());\n    if (isNodeReadableStream(body))\n        return nodeStreamIterator(body);\n    throw new Error(\"Unknown body type for responseIterator. Please pass a streamable response.\");\n}\n//# sourceMappingURL=responseIterator.js.map","export default function asyncIterator(source) {\n    var _a;\n    var iterator = source[Symbol.asyncIterator]();\n    return _a = {\n            next: function () {\n                return iterator.next();\n            }\n        },\n        _a[Symbol.asyncIterator] = function () {\n            return this;\n        },\n        _a;\n}\n//# sourceMappingURL=async.js.map","import { canUseAsyncIteratorSymbol } from \"./canUse.js\";\nexport function isNodeResponse(value) {\n    return !!value.body;\n}\nexport function isReadableStream(value) {\n    return !!value.getReader;\n}\nexport function isAsyncIterableIterator(value) {\n    return !!(canUseAsyncIteratorSymbol &&\n        value[Symbol.asyncIterator]);\n}\nexport function isStreamableBlob(value) {\n    return !!value.stream;\n}\nexport function isBlob(value) {\n    return !!value.arrayBuffer;\n}\nexport function isNodeReadableStream(value) {\n    return !!value.pipe;\n}\n//# sourceMappingURL=responseIterator.js.map","import { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function promiseIterator(promise) {\n    var resolved = false;\n    var iterator = {\n        next: function () {\n            if (resolved)\n                return Promise.resolve({\n                    value: undefined,\n                    done: true,\n                });\n            resolved = true;\n            return new Promise(function (resolve, reject) {\n                promise\n                    .then(function (value) {\n                    resolve({ value: value, done: false });\n                })\n                    .catch(reject);\n            });\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=promise.js.map","import { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function nodeStreamIterator(stream) {\n    var cleanup = null;\n    var error = null;\n    var done = false;\n    var data = [];\n    var waiting = [];\n    function onData(chunk) {\n        if (error)\n            return;\n        if (waiting.length) {\n            var shiftedArr = waiting.shift();\n            if (Array.isArray(shiftedArr) && shiftedArr[0]) {\n                return shiftedArr[0]({ value: chunk, done: false });\n            }\n        }\n        data.push(chunk);\n    }\n    function onError(err) {\n        error = err;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[1](err);\n        });\n        !cleanup || cleanup();\n    }\n    function onEnd() {\n        done = true;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[0]({ value: undefined, done: true });\n        });\n        !cleanup || cleanup();\n    }\n    cleanup = function () {\n        cleanup = null;\n        stream.removeListener(\"data\", onData);\n        stream.removeListener(\"error\", onError);\n        stream.removeListener(\"end\", onEnd);\n        stream.removeListener(\"finish\", onEnd);\n        stream.removeListener(\"close\", onEnd);\n    };\n    stream.on(\"data\", onData);\n    stream.on(\"error\", onError);\n    stream.on(\"end\", onEnd);\n    stream.on(\"finish\", onEnd);\n    stream.on(\"close\", onEnd);\n    function getNext() {\n        return new Promise(function (resolve, reject) {\n            if (error)\n                return reject(error);\n            if (data.length)\n                return resolve({ value: data.shift(), done: false });\n            if (done)\n                return resolve({ value: undefined, done: true });\n            waiting.push([resolve, reject]);\n        });\n    }\n    var iterator = {\n        next: function () {\n            return getNext();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=nodeStream.js.map","import { __awaiter, __generator } from \"tslib\";\nimport { responseIterator } from \"./responseIterator.js\";\nimport { throwServerError } from \"../utils/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function readMultipartBody(response, observer) {\n    var _a, _b, _c;\n    return __awaiter(this, void 0, void 0, function () {\n        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _d, value, done, chunk, bi, message, i, headers, contentType_1, body, result;\n        var _e;\n        return __generator(this, function (_f) {\n            switch (_f.label) {\n                case 0:\n                    if (TextDecoder === undefined) {\n                        throw new Error(\"TextDecoder must be defined in the environment: please import a polyfill.\");\n                    }\n                    decoder = new TextDecoder(\"utf-8\");\n                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type');\n                    delimiter = \"boundary=\";\n                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter))\n                        ? contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['\"]/g, \"\").replace(/\\;(.*)/gm, \"\").trim()\n                        : \"-\";\n                    boundary = \"--\".concat(boundaryVal);\n                    buffer = \"\";\n                    iterator = responseIterator(response);\n                    running = true;\n                    _f.label = 1;\n                case 1:\n                    if (!running) return [3, 3];\n                    return [4, iterator.next()];\n                case 2:\n                    _d = _f.sent(), value = _d.value, done = _d.done;\n                    chunk = typeof value === \"string\" ? value : decoder.decode(value);\n                    running = !done;\n                    buffer += chunk;\n                    bi = buffer.indexOf(boundary);\n                    while (bi > -1) {\n                        message = void 0;\n                        _e = [\n                            buffer.slice(0, bi),\n                            buffer.slice(bi + boundary.length),\n                        ], message = _e[0], buffer = _e[1];\n                        if (message.trim()) {\n                            i = message.indexOf(\"\\r\\n\\r\\n\");\n                            headers = parseHeaders(message.slice(0, i));\n                            contentType_1 = headers[\"content-type\"];\n                            if (contentType_1 &&\n                                contentType_1.toLowerCase().indexOf(\"application/json\") === -1) {\n                                throw new Error(\"Unsupported patch content type: application/json is required.\");\n                            }\n                            body = message.slice(i);\n                            try {\n                                result = parseJsonBody(response, body.replace(\"\\r\\n\", \"\"));\n                                if (Object.keys(result).length > 1 ||\n                                    \"data\" in result ||\n                                    \"incremental\" in result ||\n                                    \"errors\" in result) {\n                                    (_b = observer.next) === null || _b === void 0 ? void 0 : _b.call(observer, result);\n                                }\n                            }\n                            catch (err) {\n                                handleError(err, observer);\n                            }\n                        }\n                        bi = buffer.indexOf(boundary);\n                    }\n                    return [3, 1];\n                case 3:\n                    (_c = observer.complete) === null || _c === void 0 ? void 0 : _c.call(observer);\n                    return [2];\n            }\n        });\n    });\n}\nexport function parseHeaders(headerText) {\n    var headersInit = {};\n    headerText.split(\"\\n\").forEach(function (line) {\n        var i = line.indexOf(\":\");\n        if (i > -1) {\n            var name_1 = line.slice(0, i).trim().toLowerCase();\n            var value = line.slice(i + 1).trim();\n            headersInit[name_1] = value;\n        }\n    });\n    return headersInit;\n}\nexport function parseJsonBody(response, bodyText) {\n    if (response.status >= 300) {\n        var getResult = function () {\n            try {\n                return JSON.parse(bodyText);\n            }\n            catch (err) {\n                return bodyText;\n            }\n        };\n        throwServerError(response, getResult(), \"Response not successful: Received status code \".concat(response.status));\n    }\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        throw parseError;\n    }\n}\nexport function handleError(err, observer) {\n    var _a, _b;\n    if (err.name === \"AbortError\")\n        return;\n    if (err.result && err.result.errors && err.result.data) {\n        (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, err.result);\n    }\n    (_b = observer.error) === null || _b === void 0 ? void 0 : _b.call(observer, err);\n}\nexport function readJsonBody(response, operation, observer) {\n    parseAndCheckHttpResponse(operation)(response)\n        .then(function (result) {\n        var _a, _b;\n        (_a = observer.next) === null || _a === void 0 ? void 0 : _a.call(observer, result);\n        (_b = observer.complete) === null || _b === void 0 ? void 0 : _b.call(observer);\n    })\n        .catch(function (err) { return handleError(err, observer); });\n}\nexport function parseAndCheckHttpResponse(operations) {\n    return function (response) {\n        return response\n            .text()\n            .then(function (bodyText) { return parseJsonBody(response, bodyText); })\n            .then(function (result) {\n            if (response.status >= 300) {\n                throwServerError(response, result, \"Response not successful: Received status code \".concat(response.status));\n            }\n            if (!Array.isArray(result) &&\n                !hasOwnProperty.call(result, \"data\") &&\n                !hasOwnProperty.call(result, \"errors\")) {\n                throwServerError(response, result, \"Server response was missing for query '\".concat(Array.isArray(operations)\n                    ? operations.map(function (op) { return op.operationName; })\n                    : operations.operationName, \"'.\"));\n            }\n            return result;\n        });\n    };\n}\n//# sourceMappingURL=parseAndCheckHttpResponse.js.map","import { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nexport function rewriteURIForGET(chosenURI, body) {\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(\"\".concat(key, \"=\").concat(encodeURIComponent(value)));\n    };\n    if ('query' in body) {\n        addQueryParam('query', body.query);\n    }\n    if (body.operationName) {\n        addQueryParam('operationName', body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('variables', serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('extensions', serializedExtensions);\n    }\n    var fragment = '', preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf('#');\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n    var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n    return { newURI: newURI };\n}\n//# sourceMappingURL=rewriteURIForGET.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { print } from 'graphql';\n;\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n    preserveHeaderCase: false,\n};\nvar defaultHeaders = {\n    accept: '*/*',\n    'content-type': 'application/json',\n};\nvar defaultOptions = {\n    method: 'POST',\n};\nexport var fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nexport var defaultPrinter = function (ast, printer) { return printer(ast); };\nexport function selectHttpOptionsAndBody(operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    configs.unshift(fallbackConfig);\n    return selectHttpOptionsAndBodyInternal.apply(void 0, __spreadArray([operation,\n        defaultPrinter], configs, false));\n}\nexport function selectHttpOptionsAndBodyInternal(operation, printer) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = {};\n    var http = {};\n    configs.forEach(function (config) {\n        options = __assign(__assign(__assign({}, options), config.options), { headers: __assign(__assign({}, options.headers), config.headers) });\n        if (config.credentials) {\n            options.credentials = config.credentials;\n        }\n        http = __assign(__assign({}, http), config.http);\n    });\n    options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);\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 = printer(query, print);\n    return {\n        options: options,\n        body: body,\n    };\n}\n;\nfunction removeDuplicateHeaders(headers, preserveHeaderCase) {\n    if (!preserveHeaderCase) {\n        var normalizedHeaders_1 = Object.create(null);\n        Object.keys(Object(headers)).forEach(function (name) {\n            normalizedHeaders_1[name.toLowerCase()] = headers[name];\n        });\n        return normalizedHeaders_1;\n    }\n    var headerData = Object.create(null);\n    Object.keys(Object(headers)).forEach(function (name) {\n        headerData[name.toLowerCase()] = { originalName: name, value: headers[name] };\n    });\n    var normalizedHeaders = Object.create(null);\n    Object.keys(headerData).forEach(function (name) {\n        normalizedHeaders[headerData[name].originalName] = headerData[name].value;\n    });\n    return normalizedHeaders;\n}\n//# sourceMappingURL=selectHttpOptionsAndBody.js.map","export var 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//# sourceMappingURL=selectURI.js.map","import { InvariantError } from \"../../utilities/globals/index.js\";\nexport var serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = __DEV__ ? new InvariantError(\"Network request failed. \".concat(label, \" is not serializable: \").concat(e.message)) : new InvariantError(23);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n//# sourceMappingURL=serializeFetchParameter.js.map","import { Observable } from \"../../utilities/index.js\";\nexport function fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\n//# sourceMappingURL=fromError.js.map","export var 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};\n//# sourceMappingURL=throwServerError.js.map","import { __assign } from \"tslib\";\nimport { parse } from 'graphql';\nvar docCache = new Map();\nvar fragmentSourceMap = new Map();\nvar printFragmentWarnings = true;\nvar experimentalFragmentVariables = false;\nfunction normalize(string) {\n    return string.replace(/[\\s,]+/g, ' ').trim();\n}\nfunction cacheKeyFromLoc(loc) {\n    return normalize(loc.source.body.substring(loc.start, loc.end));\n}\nfunction processFragments(ast) {\n    var seenKeys = new Set();\n    var definitions = [];\n    ast.definitions.forEach(function (fragmentDefinition) {\n        if (fragmentDefinition.kind === 'FragmentDefinition') {\n            var fragmentName = fragmentDefinition.name.value;\n            var sourceKey = cacheKeyFromLoc(fragmentDefinition.loc);\n            var sourceKeySet = fragmentSourceMap.get(fragmentName);\n            if (sourceKeySet && !sourceKeySet.has(sourceKey)) {\n                if (printFragmentWarnings) {\n                    console.warn(\"Warning: fragment with name \" + fragmentName + \" already exists.\\n\"\n                        + \"graphql-tag enforces all fragment names across your application to be unique; read more about\\n\"\n                        + \"this in the docs: http://dev.apollodata.com/core/fragments.html#unique-names\");\n                }\n            }\n            else if (!sourceKeySet) {\n                fragmentSourceMap.set(fragmentName, sourceKeySet = new Set);\n            }\n            sourceKeySet.add(sourceKey);\n            if (!seenKeys.has(sourceKey)) {\n                seenKeys.add(sourceKey);\n                definitions.push(fragmentDefinition);\n            }\n        }\n        else {\n            definitions.push(fragmentDefinition);\n        }\n    });\n    return __assign(__assign({}, ast), { definitions: definitions });\n}\nfunction stripLoc(doc) {\n    var workSet = new Set(doc.definitions);\n    workSet.forEach(function (node) {\n        if (node.loc)\n            delete node.loc;\n        Object.keys(node).forEach(function (key) {\n            var value = node[key];\n            if (value && typeof value === 'object') {\n                workSet.add(value);\n            }\n        });\n    });\n    var loc = doc.loc;\n    if (loc) {\n        delete loc.startToken;\n        delete loc.endToken;\n    }\n    return doc;\n}\nfunction parseDocument(source) {\n    var cacheKey = normalize(source);\n    if (!docCache.has(cacheKey)) {\n        var parsed = parse(source, {\n            experimentalFragmentVariables: experimentalFragmentVariables,\n            allowLegacyFragmentVariables: experimentalFragmentVariables\n        });\n        if (!parsed || parsed.kind !== 'Document') {\n            throw new Error('Not a valid GraphQL document.');\n        }\n        docCache.set(cacheKey, stripLoc(processFragments(parsed)));\n    }\n    return docCache.get(cacheKey);\n}\nexport function gql(literals) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (typeof literals === 'string') {\n        literals = [literals];\n    }\n    var result = literals[0];\n    args.forEach(function (arg, i) {\n        if (arg && arg.kind === 'Document') {\n            result += arg.loc.source.body;\n        }\n        else {\n            result += arg;\n        }\n        result += literals[i + 1];\n    });\n    return parseDocument(result);\n}\nexport function resetCaches() {\n    docCache.clear();\n    fragmentSourceMap.clear();\n}\nexport function disableFragmentWarnings() {\n    printFragmentWarnings = false;\n}\nexport function enableExperimentalFragmentVariables() {\n    experimentalFragmentVariables = true;\n}\nexport function disableExperimentalFragmentVariables() {\n    experimentalFragmentVariables = false;\n}\nvar extras = {\n    gql: gql,\n    resetCaches: resetCaches,\n    disableFragmentWarnings: disableFragmentWarnings,\n    enableExperimentalFragmentVariables: enableExperimentalFragmentVariables,\n    disableExperimentalFragmentVariables: disableExperimentalFragmentVariables\n};\n(function (gql_1) {\n    gql_1.gql = extras.gql, gql_1.resetCaches = extras.resetCaches, gql_1.disableFragmentWarnings = extras.disableFragmentWarnings, gql_1.enableExperimentalFragmentVariables = extras.enableExperimentalFragmentVariables, gql_1.disableExperimentalFragmentVariables = extras.disableExperimentalFragmentVariables;\n})(gql || (gql = {}));\ngql[\"default\"] = gql;\nexport default gql;\n//# sourceMappingURL=index.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(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, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, 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\n/** @deprecated */\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\n/** @deprecated */\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 __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\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\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\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 (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, 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, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import * as React from 'react';\nimport { canUseSymbol } from \"../../utilities/index.js\";\nvar contextKey = canUseSymbol\n    ? Symbol.for('__APOLLO_CONTEXT__')\n    : '__APOLLO_CONTEXT__';\nexport function getApolloContext() {\n    var context = React.createContext[contextKey];\n    if (!context) {\n        Object.defineProperty(React.createContext, contextKey, {\n            value: context = React.createContext({}),\n            enumerable: false,\n            writable: false,\n            configurable: true,\n        });\n        context.displayName = 'ApolloContext';\n    }\n    return context;\n}\nexport { getApolloContext as resetApolloContext };\n//# sourceMappingURL=ApolloContext.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from 'react';\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloProvider = function (_a) {\n    var client = _a.client, children = _a.children;\n    var ApolloContext = getApolloContext();\n    return (React.createElement(ApolloContext.Consumer, null, function (context) {\n        if (context === void 0) { context = {}; }\n        if (client && context.client !== client) {\n            context = Object.assign({}, context, { client: client });\n        }\n        __DEV__ ? invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +\n            'sure you pass in your client via the \"client\" prop.') : invariant(context.client, 28);\n        return (React.createElement(ApolloContext.Provider, { value: context }, children));\n    }));\n};\n//# sourceMappingURL=ApolloProvider.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport { useContext } from 'react';\nimport { getApolloContext } from \"../context/index.js\";\nexport function useApolloClient(override) {\n    var context = useContext(getApolloContext());\n    var client = override || context.client;\n    __DEV__ ? invariant(!!client, 'Could not find \"client\" in the context or passed in as an option. ' +\n        'Wrap the root component in an <ApolloProvider>, or pass an ApolloClient ' +\n        'instance in via options.') : invariant(!!client, 31);\n    return client;\n}\n//# sourceMappingURL=useApolloClient.js.map","import { __assign } from \"tslib\";\nimport { useCallback, useMemo, useRef } from 'react';\nimport { mergeOptions } from \"../../utilities/index.js\";\nimport { useInternalState } from \"./useQuery.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nvar EAGER_METHODS = [\n    'refetch',\n    'reobserve',\n    'fetchMore',\n    'updateQuery',\n    'startPolling',\n    'subscribeToMore',\n];\nexport function useLazyQuery(query, options) {\n    var internalState = useInternalState(useApolloClient(options && options.client), query);\n    var execOptionsRef = useRef();\n    var merged = execOptionsRef.current\n        ? mergeOptions(options, execOptionsRef.current)\n        : options;\n    var useQueryResult = internalState.useQuery(__assign(__assign({}, merged), { skip: !execOptionsRef.current }));\n    var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||\n        internalState.getDefaultFetchPolicy();\n    var result = Object.assign(useQueryResult, {\n        called: !!execOptionsRef.current,\n    });\n    var eagerMethods = useMemo(function () {\n        var eagerMethods = {};\n        var _loop_1 = function (key) {\n            var method = result[key];\n            eagerMethods[key] = function () {\n                if (!execOptionsRef.current) {\n                    execOptionsRef.current = Object.create(null);\n                    internalState.forceUpdate();\n                }\n                return method.apply(this, arguments);\n            };\n        };\n        for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {\n            var key = EAGER_METHODS_1[_i];\n            _loop_1(key);\n        }\n        return eagerMethods;\n    }, []);\n    Object.assign(result, eagerMethods);\n    var execute = useCallback(function (executeOptions) {\n        execOptionsRef.current = executeOptions ? __assign(__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {\n            fetchPolicy: initialFetchPolicy,\n        };\n        var promise = internalState\n            .asyncUpdate()\n            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });\n        promise.catch(function () { });\n        return promise;\n    }, []);\n    return [execute, result];\n}\n//# sourceMappingURL=useLazyQuery.js.map","import { __assign } from \"tslib\";\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { mergeOptions, } from \"../../core/index.js\";\nimport { equal } from '@wry/equality';\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nexport function useMutation(mutation, options) {\n    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);\n    verifyDocumentType(mutation, DocumentType.Mutation);\n    var _a = useState({\n        called: false,\n        loading: false,\n        client: client,\n    }), result = _a[0], setResult = _a[1];\n    var ref = useRef({\n        result: result,\n        mutationId: 0,\n        isMounted: true,\n        client: client,\n        mutation: mutation,\n        options: options,\n    });\n    {\n        Object.assign(ref.current, { client: client, options: options, mutation: mutation });\n    }\n    var execute = useCallback(function (executeOptions) {\n        if (executeOptions === void 0) { executeOptions = {}; }\n        var _a = ref.current, client = _a.client, options = _a.options, mutation = _a.mutation;\n        var baseOptions = __assign(__assign({}, options), { mutation: mutation });\n        if (!ref.current.result.loading && !baseOptions.ignoreResults && ref.current.isMounted) {\n            setResult(ref.current.result = {\n                loading: true,\n                error: void 0,\n                data: void 0,\n                called: true,\n                client: client,\n            });\n        }\n        var mutationId = ++ref.current.mutationId;\n        var clientOptions = mergeOptions(baseOptions, executeOptions);\n        return client.mutate(clientOptions).then(function (response) {\n            var _a, _b, _c;\n            var data = response.data, errors = response.errors;\n            var error = errors && errors.length > 0\n                ? new ApolloError({ graphQLErrors: errors })\n                : void 0;\n            if (mutationId === ref.current.mutationId &&\n                !clientOptions.ignoreResults) {\n                var result_1 = {\n                    called: true,\n                    loading: false,\n                    data: data,\n                    error: error,\n                    client: client,\n                };\n                if (ref.current.isMounted && !equal(ref.current.result, result_1)) {\n                    setResult(ref.current.result = result_1);\n                }\n            }\n            (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onCompleted) === null || _b === void 0 ? void 0 : _b.call(_a, response.data, clientOptions);\n            (_c = executeOptions.onCompleted) === null || _c === void 0 ? void 0 : _c.call(executeOptions, response.data, clientOptions);\n            return response;\n        }).catch(function (error) {\n            var _a, _b, _c, _d;\n            if (mutationId === ref.current.mutationId &&\n                ref.current.isMounted) {\n                var result_2 = {\n                    loading: false,\n                    error: error,\n                    data: void 0,\n                    called: true,\n                    client: client,\n                };\n                if (!equal(ref.current.result, result_2)) {\n                    setResult(ref.current.result = result_2);\n                }\n            }\n            if (((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) || clientOptions.onError) {\n                (_c = (_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, clientOptions);\n                (_d = executeOptions.onError) === null || _d === void 0 ? void 0 : _d.call(executeOptions, error, clientOptions);\n                return { data: void 0, errors: error };\n            }\n            throw error;\n        });\n    }, []);\n    var reset = useCallback(function () {\n        if (ref.current.isMounted) {\n            setResult({ called: false, loading: false, client: client });\n        }\n    }, []);\n    useEffect(function () {\n        ref.current.isMounted = true;\n        return function () {\n            ref.current.isMounted = false;\n        };\n    }, []);\n    return [execute, __assign({ reset: reset }, result)];\n}\n//# sourceMappingURL=useMutation.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from 'react';\nimport { canUseLayoutEffect } from \"../../utilities/index.js\";\nvar didWarnUncachedGetSnapshot = false;\nvar uSESKey = \"useSyncExternalStore\";\nvar realHook = React[uSESKey];\nexport var useSyncExternalStore = realHook || (function (subscribe, getSnapshot, getServerSnapshot) {\n    var value = getSnapshot();\n    if (__DEV__ &&\n        !didWarnUncachedGetSnapshot &&\n        value !== getSnapshot()) {\n        didWarnUncachedGetSnapshot = true;\n        __DEV__ && invariant.error('The result of getSnapshot should be cached to avoid an infinite loop');\n    }\n    var _a = React.useState({ inst: { value: value, getSnapshot: getSnapshot } }), inst = _a[0].inst, forceUpdate = _a[1];\n    if (canUseLayoutEffect) {\n        React.useLayoutEffect(function () {\n            Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n            if (checkIfSnapshotChanged(inst)) {\n                forceUpdate({ inst: inst });\n            }\n        }, [subscribe, value, getSnapshot]);\n    }\n    else {\n        Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n    }\n    React.useEffect(function () {\n        if (checkIfSnapshotChanged(inst)) {\n            forceUpdate({ inst: inst });\n        }\n        return subscribe(function handleStoreChange() {\n            if (checkIfSnapshotChanged(inst)) {\n                forceUpdate({ inst: inst });\n            }\n        });\n    }, [subscribe]);\n    return value;\n});\nfunction checkIfSnapshotChanged(_a) {\n    var value = _a.value, getSnapshot = _a.getSnapshot;\n    try {\n        return value !== getSnapshot();\n    }\n    catch (_b) {\n        return true;\n    }\n}\n//# sourceMappingURL=useSyncExternalStore.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { useCallback, useContext, useMemo, useRef, useState, } from 'react';\nimport { useSyncExternalStore } from \"./useSyncExternalStore.js\";\nimport { equal } from '@wry/equality';\nimport { mergeOptions } from \"../../core/index.js\";\nimport { getApolloContext } from \"../context/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { NetworkStatus, } from \"../../core/index.js\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { canUseWeakMap, canUseWeakSet, compact, isNonEmptyArray, maybeDeepFreeze } from \"../../utilities/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function useQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return useInternalState(useApolloClient(options.client), query).useQuery(options);\n}\nexport function useInternalState(client, query) {\n    var stateRef = useRef();\n    if (!stateRef.current ||\n        client !== stateRef.current.client ||\n        query !== stateRef.current.query) {\n        stateRef.current = new InternalState(client, query, stateRef.current);\n    }\n    var state = stateRef.current;\n    var _a = useState(0), _tick = _a[0], setTick = _a[1];\n    state.forceUpdate = function () {\n        setTick(function (tick) { return tick + 1; });\n    };\n    return state;\n}\nvar InternalState = (function () {\n    function InternalState(client, query, previous) {\n        this.client = client;\n        this.query = query;\n        this.asyncResolveFns = new Set();\n        this.optionsToIgnoreOnce = new (canUseWeakSet ? WeakSet : Set)();\n        this.ssrDisabledResult = maybeDeepFreeze({\n            loading: true,\n            data: void 0,\n            error: void 0,\n            networkStatus: NetworkStatus.loading,\n        });\n        this.skipStandbyResult = maybeDeepFreeze({\n            loading: false,\n            data: void 0,\n            error: void 0,\n            networkStatus: NetworkStatus.ready,\n        });\n        this.toQueryResultCache = new (canUseWeakMap ? WeakMap : Map)();\n        verifyDocumentType(query, DocumentType.Query);\n        var previousResult = previous && previous.result;\n        var previousData = previousResult && previousResult.data;\n        if (previousData) {\n            this.previousData = previousData;\n        }\n    }\n    InternalState.prototype.forceUpdate = function () {\n        __DEV__ && invariant.warn(\"Calling default no-op implementation of InternalState#forceUpdate\");\n    };\n    InternalState.prototype.asyncUpdate = function () {\n        var _this = this;\n        return new Promise(function (resolve) {\n            _this.asyncResolveFns.add(resolve);\n            _this.optionsToIgnoreOnce.add(_this.watchQueryOptions);\n            _this.forceUpdate();\n        });\n    };\n    InternalState.prototype.useQuery = function (options) {\n        var _this = this;\n        this.renderPromises = useContext(getApolloContext()).renderPromises;\n        this.useOptions(options);\n        var obsQuery = this.useObservableQuery();\n        var result = useSyncExternalStore(useCallback(function () {\n            if (_this.renderPromises) {\n                return function () { };\n            }\n            var onNext = function () {\n                var previousResult = _this.result;\n                var result = obsQuery.getCurrentResult();\n                if (previousResult &&\n                    previousResult.loading === result.loading &&\n                    previousResult.networkStatus === result.networkStatus &&\n                    equal(previousResult.data, result.data)) {\n                    return;\n                }\n                _this.setResult(result);\n            };\n            var onError = function (error) {\n                var last = obsQuery[\"last\"];\n                subscription.unsubscribe();\n                try {\n                    obsQuery.resetLastResults();\n                    subscription = obsQuery.subscribe(onNext, onError);\n                }\n                finally {\n                    obsQuery[\"last\"] = last;\n                }\n                if (!hasOwnProperty.call(error, 'graphQLErrors')) {\n                    throw error;\n                }\n                var previousResult = _this.result;\n                if (!previousResult ||\n                    (previousResult && previousResult.loading) ||\n                    !equal(error, previousResult.error)) {\n                    _this.setResult({\n                        data: (previousResult && previousResult.data),\n                        error: error,\n                        loading: false,\n                        networkStatus: NetworkStatus.error,\n                    });\n                }\n            };\n            var subscription = obsQuery.subscribe(onNext, onError);\n            return function () { return subscription.unsubscribe(); };\n        }, [\n            obsQuery,\n            this.renderPromises,\n            this.client.disableNetworkFetches,\n        ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });\n        this.unsafeHandlePartialRefetch(result);\n        var queryResult = this.toQueryResult(result);\n        if (!queryResult.loading && this.asyncResolveFns.size) {\n            this.asyncResolveFns.forEach(function (resolve) { return resolve(queryResult); });\n            this.asyncResolveFns.clear();\n        }\n        return queryResult;\n    };\n    InternalState.prototype.useOptions = function (options) {\n        var _a;\n        var watchQueryOptions = this.createWatchQueryOptions(this.queryHookOptions = options);\n        var currentWatchQueryOptions = this.watchQueryOptions;\n        if (this.optionsToIgnoreOnce.has(currentWatchQueryOptions) ||\n            !equal(watchQueryOptions, currentWatchQueryOptions)) {\n            this.watchQueryOptions = watchQueryOptions;\n            if (currentWatchQueryOptions && this.observable) {\n                this.optionsToIgnoreOnce.delete(currentWatchQueryOptions);\n                this.observable.reobserve(this.getObsQueryOptions());\n                this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;\n                this.result = void 0;\n            }\n        }\n        this.onCompleted = options.onCompleted || InternalState.prototype.onCompleted;\n        this.onError = options.onError || InternalState.prototype.onError;\n        if ((this.renderPromises || this.client.disableNetworkFetches) &&\n            this.queryHookOptions.ssr === false &&\n            !this.queryHookOptions.skip) {\n            this.result = this.ssrDisabledResult;\n        }\n        else if (this.queryHookOptions.skip ||\n            this.watchQueryOptions.fetchPolicy === 'standby') {\n            this.result = this.skipStandbyResult;\n        }\n        else if (this.result === this.ssrDisabledResult ||\n            this.result === this.skipStandbyResult) {\n            this.result = void 0;\n        }\n    };\n    InternalState.prototype.getObsQueryOptions = function () {\n        var toMerge = [];\n        var globalDefaults = this.client.defaultOptions.watchQuery;\n        if (globalDefaults)\n            toMerge.push(globalDefaults);\n        if (this.queryHookOptions.defaultOptions) {\n            toMerge.push(this.queryHookOptions.defaultOptions);\n        }\n        toMerge.push(compact(this.observable && this.observable.options, this.watchQueryOptions));\n        return toMerge.reduce(mergeOptions);\n    };\n    InternalState.prototype.createWatchQueryOptions = function (_a) {\n        var _b;\n        if (_a === void 0) { _a = {}; }\n        var skip = _a.skip, ssr = _a.ssr, onCompleted = _a.onCompleted, onError = _a.onError, defaultOptions = _a.defaultOptions, otherOptions = __rest(_a, [\"skip\", \"ssr\", \"onCompleted\", \"onError\", \"defaultOptions\"]);\n        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });\n        if (this.renderPromises &&\n            (watchQueryOptions.fetchPolicy === 'network-only' ||\n                watchQueryOptions.fetchPolicy === 'cache-and-network')) {\n            watchQueryOptions.fetchPolicy = 'cache-first';\n        }\n        if (!watchQueryOptions.variables) {\n            watchQueryOptions.variables = {};\n        }\n        if (skip) {\n            var _c = watchQueryOptions.fetchPolicy, fetchPolicy = _c === void 0 ? this.getDefaultFetchPolicy() : _c, _d = watchQueryOptions.initialFetchPolicy, initialFetchPolicy = _d === void 0 ? fetchPolicy : _d;\n            Object.assign(watchQueryOptions, {\n                initialFetchPolicy: initialFetchPolicy,\n                fetchPolicy: 'standby',\n            });\n        }\n        else if (!watchQueryOptions.fetchPolicy) {\n            watchQueryOptions.fetchPolicy =\n                ((_b = this.observable) === null || _b === void 0 ? void 0 : _b.options.initialFetchPolicy) ||\n                    this.getDefaultFetchPolicy();\n        }\n        return watchQueryOptions;\n    };\n    InternalState.prototype.getDefaultFetchPolicy = function () {\n        var _a, _b;\n        return (((_a = this.queryHookOptions.defaultOptions) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n            ((_b = this.client.defaultOptions.watchQuery) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||\n            \"cache-first\");\n    };\n    InternalState.prototype.onCompleted = function (data) { };\n    InternalState.prototype.onError = function (error) { };\n    InternalState.prototype.useObservableQuery = function () {\n        var obsQuery = this.observable =\n            this.renderPromises\n                && this.renderPromises.getSSRObservable(this.watchQueryOptions)\n                || this.observable\n                || this.client.watchQuery(this.getObsQueryOptions());\n        this.obsQueryFields = useMemo(function () { return ({\n            refetch: obsQuery.refetch.bind(obsQuery),\n            reobserve: obsQuery.reobserve.bind(obsQuery),\n            fetchMore: obsQuery.fetchMore.bind(obsQuery),\n            updateQuery: obsQuery.updateQuery.bind(obsQuery),\n            startPolling: obsQuery.startPolling.bind(obsQuery),\n            stopPolling: obsQuery.stopPolling.bind(obsQuery),\n            subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),\n        }); }, [obsQuery]);\n        var ssrAllowed = !(this.queryHookOptions.ssr === false ||\n            this.queryHookOptions.skip);\n        if (this.renderPromises && ssrAllowed) {\n            this.renderPromises.registerSSRObservable(obsQuery);\n            if (obsQuery.getCurrentResult().loading) {\n                this.renderPromises.addObservableQueryPromise(obsQuery);\n            }\n        }\n        return obsQuery;\n    };\n    InternalState.prototype.setResult = function (nextResult) {\n        var previousResult = this.result;\n        if (previousResult && previousResult.data) {\n            this.previousData = previousResult.data;\n        }\n        this.result = nextResult;\n        this.forceUpdate();\n        this.handleErrorOrCompleted(nextResult);\n    };\n    InternalState.prototype.handleErrorOrCompleted = function (result) {\n        var _this = this;\n        if (!result.loading) {\n            Promise.resolve().then(function () {\n                if (result.error) {\n                    _this.onError(result.error);\n                }\n                else if (result.data) {\n                    _this.onCompleted(result.data);\n                }\n            }).catch(function (error) {\n                __DEV__ && invariant.warn(error);\n            });\n        }\n    };\n    InternalState.prototype.getCurrentResult = function () {\n        if (!this.result) {\n            this.handleErrorOrCompleted(this.result = this.observable.getCurrentResult());\n        }\n        return this.result;\n    };\n    InternalState.prototype.toQueryResult = function (result) {\n        var queryResult = this.toQueryResultCache.get(result);\n        if (queryResult)\n            return queryResult;\n        var data = result.data, partial = result.partial, resultWithoutPartial = __rest(result, [\"data\", \"partial\"]);\n        this.toQueryResultCache.set(result, queryResult = __assign(__assign(__assign({ data: data }, resultWithoutPartial), this.obsQueryFields), { client: this.client, observable: this.observable, variables: this.observable.variables, called: !this.queryHookOptions.skip, previousData: this.previousData }));\n        if (!queryResult.error && isNonEmptyArray(result.errors)) {\n            queryResult.error = new ApolloError({ graphQLErrors: result.errors });\n        }\n        return queryResult;\n    };\n    InternalState.prototype.unsafeHandlePartialRefetch = function (result) {\n        if (result.partial &&\n            this.queryHookOptions.partialRefetch &&\n            !result.loading &&\n            (!result.data || Object.keys(result.data).length === 0) &&\n            this.observable.options.fetchPolicy !== 'cache-only') {\n            Object.assign(result, {\n                loading: true,\n                networkStatus: NetworkStatus.refetch,\n            });\n            this.observable.refetch();\n        }\n    };\n    return InternalState;\n}());\n//# sourceMappingURL=useQuery.js.map","import { useEffect, useState } from 'react';\nexport function useReactiveVar(rv) {\n    var value = rv();\n    var setValue = useState(value)[1];\n    useEffect(function () {\n        var probablySameValue = rv();\n        if (value !== probablySameValue) {\n            setValue(probablySameValue);\n        }\n        else {\n            return rv.onNextChange(setValue);\n        }\n    }, [value]);\n    return value;\n}\n//# sourceMappingURL=useReactiveVar.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nexport var DocumentType;\n(function (DocumentType) {\n    DocumentType[DocumentType[\"Query\"] = 0] = \"Query\";\n    DocumentType[DocumentType[\"Mutation\"] = 1] = \"Mutation\";\n    DocumentType[DocumentType[\"Subscription\"] = 2] = \"Subscription\";\n})(DocumentType || (DocumentType = {}));\nvar cache = new Map();\nexport function operationName(type) {\n    var name;\n    switch (type) {\n        case DocumentType.Query:\n            name = 'Query';\n            break;\n        case DocumentType.Mutation:\n            name = 'Mutation';\n            break;\n        case DocumentType.Subscription:\n            name = 'Subscription';\n            break;\n    }\n    return name;\n}\nexport function parser(document) {\n    var cached = cache.get(document);\n    if (cached)\n        return cached;\n    var variables, type, name;\n    __DEV__ ? invariant(!!document && !!document.kind, \"Argument of \".concat(document, \" passed to parser was not a valid GraphQL \") +\n        \"DocumentNode. You may need to use 'graphql-tag' or another method \" +\n        \"to convert your operation into a document\") : invariant(!!document && !!document.kind, 32);\n    var fragments = [];\n    var queries = [];\n    var mutations = [];\n    var subscriptions = [];\n    for (var _i = 0, _a = document.definitions; _i < _a.length; _i++) {\n        var x = _a[_i];\n        if (x.kind === 'FragmentDefinition') {\n            fragments.push(x);\n            continue;\n        }\n        if (x.kind === 'OperationDefinition') {\n            switch (x.operation) {\n                case 'query':\n                    queries.push(x);\n                    break;\n                case 'mutation':\n                    mutations.push(x);\n                    break;\n                case 'subscription':\n                    subscriptions.push(x);\n                    break;\n            }\n        }\n    }\n    __DEV__ ? invariant(!fragments.length ||\n        (queries.length || mutations.length || subscriptions.length), \"Passing only a fragment to 'graphql' is not yet supported. \" +\n        \"You must include a query, subscription or mutation as well\") : invariant(!fragments.length ||\n        (queries.length || mutations.length || subscriptions.length), 33);\n    __DEV__ ? invariant(queries.length + mutations.length + subscriptions.length <= 1, \"react-apollo only supports a query, subscription, or a mutation per HOC. \" +\n        \"\".concat(document, \" had \").concat(queries.length, \" queries, \").concat(subscriptions.length, \" \") +\n        \"subscriptions and \".concat(mutations.length, \" mutations. \") +\n        \"You can use 'compose' to join multiple operation types to a component\") : invariant(queries.length + mutations.length + subscriptions.length <= 1, 34);\n    type = queries.length ? DocumentType.Query : DocumentType.Mutation;\n    if (!queries.length && !mutations.length)\n        type = DocumentType.Subscription;\n    var definitions = queries.length\n        ? queries\n        : mutations.length\n            ? mutations\n            : subscriptions;\n    __DEV__ ? invariant(definitions.length === 1, \"react-apollo only supports one definition per HOC. \".concat(document, \" had \") +\n        \"\".concat(definitions.length, \" definitions. \") +\n        \"You can use 'compose' to join multiple operation types to a component\") : invariant(definitions.length === 1, 35);\n    var definition = definitions[0];\n    variables = definition.variableDefinitions || [];\n    if (definition.name && definition.name.kind === 'Name') {\n        name = definition.name.value;\n    }\n    else {\n        name = 'data';\n    }\n    var payload = { name: name, type: type, variables: variables };\n    cache.set(document, payload);\n    return payload;\n}\nexport function verifyDocumentType(document, type) {\n    var operation = parser(document);\n    var requiredOperationName = operationName(type);\n    var usedOperationName = operationName(operation.type);\n    __DEV__ ? invariant(operation.type === type, \"Running a \".concat(requiredOperationName, \" requires a graphql \") +\n        \"\".concat(requiredOperationName, \", but a \").concat(usedOperationName, \" was used instead.\")) : invariant(operation.type === type, 36);\n}\n//# sourceMappingURL=index.js.map","export function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrays.js.map","import { maybe } from \"../globals/index.js\";\nexport var canUseWeakMap = typeof WeakMap === 'function' &&\n    maybe(function () { return navigator.product; }) !== 'ReactNative';\nexport var canUseWeakSet = typeof WeakSet === 'function';\nexport var canUseSymbol = typeof Symbol === 'function' &&\n    typeof Symbol.for === 'function';\nexport var canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;\nexport var canUseDOM = typeof maybe(function () { return window.document.createElement; }) === \"function\";\nvar usingJSDOM = maybe(function () { return navigator.userAgent.indexOf(\"jsdom\") >= 0; }) || false;\nexport var canUseLayoutEffect = canUseDOM && !usingJSDOM;\n//# sourceMappingURL=canUse.js.map","var toString = Object.prototype.toString;\nexport function cloneDeep(value) {\n    return cloneDeepHelper(value);\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            seen = seen || new Map;\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            seen = seen || new Map;\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//# sourceMappingURL=cloneDeep.js.map","export function compact() {\n    var objects = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        objects[_i] = arguments[_i];\n    }\n    var result = Object.create(null);\n    objects.forEach(function (obj) {\n        if (!obj)\n            return;\n        Object.keys(obj).forEach(function (key) {\n            var value = obj[key];\n            if (value !== void 0) {\n                result[key] = value;\n            }\n        });\n    });\n    return result;\n}\n//# sourceMappingURL=compact.js.map","export function graphQLResultHasError(result) {\n    return (result.errors && result.errors.length > 0) || false;\n}\n//# sourceMappingURL=errorHandling.js.map","var prefixCounts = new Map();\nexport function makeUniqueId(prefix) {\n    var count = prefixCounts.get(prefix) || 1;\n    prefixCounts.set(prefix, count + 1);\n    return \"\".concat(prefix, \":\").concat(count, \":\").concat(Math.random().toString(36).slice(2));\n}\n//# sourceMappingURL=makeUniqueId.js.map","import \"../globals/index.js\";\nimport { isNonNullObject } from \"./objects.js\";\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isNonNullObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nfunction shallowFreeze(obj) {\n    if (__DEV__ && !Object.isFrozen(obj)) {\n        try {\n            Object.freeze(obj);\n        }\n        catch (e) {\n            if (e instanceof TypeError)\n                return null;\n            throw e;\n        }\n    }\n    return obj;\n}\nexport function maybeDeepFreeze(obj) {\n    if (__DEV__) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n//# sourceMappingURL=maybeDeepFreeze.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { isNonNullObject } from \"./objects.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nexport function mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var merger = new DeepMerger();\n        for (var i = 1; i < count; ++i) {\n            target = merger.merge(target, sources[i]);\n        }\n    }\n    return target;\n}\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger = (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isNonNullObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, __spreadArray([target, source, sourceKey], context, false));\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\nexport { DeepMerger };\n//# sourceMappingURL=mergeDeep.js.map","import { __assign } from \"tslib\";\nimport { compact } from \"./compact.js\";\nexport function mergeOptions(defaults, options) {\n    return compact(defaults, options, options.variables && {\n        variables: __assign(__assign({}, (defaults && defaults.variables)), options.variables),\n    });\n}\n//# sourceMappingURL=mergeOptions.js.map","export function isNonNullObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\n//# sourceMappingURL=objects.js.map","import { makeUniqueId } from \"./makeUniqueId.js\";\nexport function stringifyForDisplay(value) {\n    var undefId = makeUniqueId(\"stringifyForDisplay\");\n    return JSON.stringify(value, function (key, value) {\n        return value === void 0 ? undefId : value;\n    }).split(JSON.stringify(undefId)).join(\"<undefined>\");\n}\n//# sourceMappingURL=stringifyForDisplay.js.map","export function maybe(thunk) {\n    try {\n        return thunk();\n    }\n    catch (_a) { }\n}\n//# sourceMappingURL=maybe.js.map","import { maybe } from \"./maybe.js\";\nexport default (maybe(function () { return globalThis; }) ||\n    maybe(function () { return window; }) ||\n    maybe(function () { return self; }) ||\n    maybe(function () { return global; }) || maybe(function () { return maybe.constructor(\"return this\")(); }));\n//# sourceMappingURL=global.js.map","import global from \"./global.js\";\nimport { maybe } from \"./maybe.js\";\nvar __ = \"__\";\nvar GLOBAL_KEY = [__, __].join(\"DEV\");\nfunction getDEV() {\n    try {\n        return Boolean(__DEV__);\n    }\n    catch (_a) {\n        Object.defineProperty(global, GLOBAL_KEY, {\n            value: maybe(function () { return process.env.NODE_ENV; }) !== \"production\",\n            enumerable: false,\n            configurable: true,\n            writable: true,\n        });\n        return global[GLOBAL_KEY];\n    }\n}\nexport default getDEV();\n//# sourceMappingURL=DEV.js.map","import { remove } from \"ts-invariant/process/index.js\";\nimport { Source } from 'graphql';\nexport function removeTemporaryGlobals() {\n    return typeof Source === \"function\" ? remove() : remove();\n}\n//# sourceMappingURL=fix-graphql.js.map","import { invariant, InvariantError } from \"ts-invariant\";\nimport DEV from \"./DEV.js\";\nexport { DEV };\nexport function checkDEV() {\n    __DEV__ ? invariant(\"boolean\" === typeof DEV, DEV) : invariant(\"boolean\" === typeof DEV, 38);\n}\nimport { removeTemporaryGlobals } from \"./fix-graphql.js\";\nremoveTemporaryGlobals();\nexport { maybe } from \"./maybe.js\";\nexport { default as global } from \"./global.js\";\nexport { invariant, InvariantError };\ncheckDEV();\n//# sourceMappingURL=index.js.map","import { invariant } from \"../globals/index.js\";\nimport { visit, BREAK, } from 'graphql';\nexport function shouldInclude(_a, variables) {\n    var directives = _a.directives;\n    if (!directives || !directives.length) {\n        return true;\n    }\n    return getInclusionDirectives(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 && variables[ifArgument.value.name.value];\n            __DEV__ ? invariant(evaledValue !== void 0, \"Invalid variable referenced in @\".concat(directive.name.value, \" directive.\")) : invariant(evaledValue !== void 0, 39);\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\nexport function getDirectiveNames(root) {\n    var names = [];\n    visit(root, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nexport var hasAnyDirectives = function (names, root) { return hasDirectives(names, root, false); };\nexport var hasAllDirectives = function (names, root) { return hasDirectives(names, root, true); };\nexport function hasDirectives(names, root, all) {\n    var nameSet = new Set(names);\n    var uniqueCount = nameSet.size;\n    visit(root, {\n        Directive: function (node) {\n            if (nameSet.delete(node.name.value) &&\n                (!all || !nameSet.size)) {\n                return BREAK;\n            }\n        },\n    });\n    return all ? !nameSet.size : nameSet.size < uniqueCount;\n}\nexport function hasClientExports(document) {\n    return document && hasDirectives(['client', 'export'], document, true);\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\nexport function getInclusionDirectives(directives) {\n    var result = [];\n    if (directives && directives.length) {\n        directives.forEach(function (directive) {\n            if (!isInclusionDirective(directive))\n                return;\n            var directiveArguments = directive.arguments;\n            var directiveName = directive.name.value;\n            __DEV__ ? invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\".concat(directiveName, \" directive.\")) : invariant(directiveArguments && directiveArguments.length === 1, 40);\n            var ifArgument = directiveArguments[0];\n            __DEV__ ? invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\".concat(directiveName, \" directive.\")) : invariant(ifArgument.name && ifArgument.name.value === 'if', 41);\n            var ifValue = ifArgument.value;\n            __DEV__ ? invariant(ifValue &&\n                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\".concat(directiveName, \" directive must be a variable or a boolean value.\")) : invariant(ifValue &&\n                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 42);\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\n//# sourceMappingURL=directives.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant, InvariantError } from \"../globals/index.js\";\nexport function getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === 'OperationDefinition') {\n            throw __DEV__ ? new InvariantError(\"Found a \".concat(definition.operation, \" operation\").concat(definition.name ? \" named '\".concat(definition.name.value, \"'\") : '', \". \") +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.') : new InvariantError(43);\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        __DEV__ ? invariant(fragments.length === 1, \"Found \".concat(fragments.length, \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\")) : invariant(fragments.length === 1, 44);\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArray([\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, true) });\n    return query;\n}\nexport function 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}\nexport function getFragmentFromSelection(selection, fragmentMap) {\n    switch (selection.kind) {\n        case 'InlineFragment':\n            return selection;\n        case 'FragmentSpread': {\n            var fragmentName = selection.name.value;\n            if (typeof fragmentMap === \"function\") {\n                return fragmentMap(fragmentName);\n            }\n            var fragment = fragmentMap && fragmentMap[fragmentName];\n            __DEV__ ? invariant(fragment, \"No fragment named \".concat(fragmentName)) : invariant(fragment, 45);\n            return fragment || null;\n        }\n        default:\n            return null;\n    }\n}\n//# sourceMappingURL=fragments.js.map","import { invariant, InvariantError } from \"../globals/index.js\";\nimport { valueToObjectRepresentation } from \"./storeUtils.js\";\nexport function checkDocument(doc) {\n    __DEV__ ? 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\") : invariant(doc && doc.kind === 'Document', 46);\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw __DEV__ ? new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\".concat(definition.kind, \"\\\"\")) : new InvariantError(47);\n        }\n        return definition;\n    });\n    __DEV__ ? invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \".concat(operations.length, \" operations\")) : invariant(operations.length <= 1, 48);\n    return doc;\n}\nexport function getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];\n}\nexport function 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}\nexport function getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });\n}\nexport function getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    __DEV__ ? invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.') : invariant(queryDef && queryDef.operation === 'query', 49);\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    __DEV__ ? 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\") : invariant(doc.kind === 'Document', 50);\n    __DEV__ ? invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.') : invariant(doc.definitions.length <= 1, 51);\n    var fragmentDef = doc.definitions[0];\n    __DEV__ ? invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.') : invariant(fragmentDef.kind === 'FragmentDefinition', 52);\n    return fragmentDef;\n}\nexport function 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 __DEV__ ? new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.') : new InvariantError(53);\n}\nexport function getDefaultValues(definition) {\n    var defaultValues = Object.create(null);\n    var defs = definition && definition.variableDefinitions;\n    if (defs && defs.length) {\n        defs.forEach(function (def) {\n            if (def.defaultValue) {\n                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);\n            }\n        });\n    }\n    return defaultValues;\n}\n//# sourceMappingURL=getFromAST.js.map","import { InvariantError } from \"../globals/index.js\";\nimport { isNonNullObject } from \"../common/objects.js\";\nimport { getFragmentFromSelection } from \"./fragments.js\";\nexport function makeReference(id) {\n    return { __ref: String(id) };\n}\nexport function isReference(obj) {\n    return Boolean(obj && typeof obj === 'object' && typeof obj.__ref === 'string');\n}\nexport function isDocumentNode(value) {\n    return (isNonNullObject(value) &&\n        value.kind === \"Document\" &&\n        Array.isArray(value.definitions));\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}\nexport function 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 __DEV__ ? new InvariantError(\"The inline argument \\\"\".concat(name.value, \"\\\" of kind \\\"\").concat(value.kind, \"\\\"\") +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.') : new InvariantError(54);\n    }\n}\nexport function 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];\nexport var getStoreKeyName = Object.assign(function (fieldName, args, directives) {\n    if (args &&\n        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 filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = args[key];\n            });\n            return \"\".concat(directives['connection']['key'], \"(\").concat(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 += \"(\".concat(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 += \"@\".concat(key, \"(\").concat(stringify(directives[key]), \")\");\n            }\n            else {\n                completeFieldName += \"@\".concat(key);\n            }\n        });\n    }\n    return completeFieldName;\n}, {\n    setStringify: function (s) {\n        var previous = stringify;\n        stringify = s;\n        return previous;\n    },\n});\nvar stringify = function defaultStringify(value) {\n    return JSON.stringify(value, stringifyReplacer);\n};\nfunction stringifyReplacer(_key, value) {\n    if (isNonNullObject(value) && !Array.isArray(value)) {\n        value = Object.keys(value).sort().reduce(function (copy, key) {\n            copy[key] = value[key];\n            return copy;\n        }, {});\n    }\n    return value;\n}\nexport function 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}\nexport function resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nexport function getTypenameFromResult(result, selectionSet, fragmentMap) {\n    if (typeof result.__typename === 'string') {\n        return result.__typename;\n    }\n    for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {\n        var selection = _a[_i];\n        if (isField(selection)) {\n            if (selection.name.value === '__typename') {\n                return result[resultKeyNameFromField(selection)];\n            }\n        }\n        else {\n            var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);\n            if (typeof typename === 'string') {\n                return typename;\n            }\n        }\n    }\n}\nexport function isField(selection) {\n    return selection.kind === 'Field';\n}\nexport function isInlineFragment(selection) {\n    return selection.kind === 'InlineFragment';\n}\n//# sourceMappingURL=storeUtils.js.map","export function 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//# sourceMappingURL=filterInPlace.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant } from \"../globals/index.js\";\nimport { visit, } from 'graphql';\nimport { checkDocument, getOperationDefinition, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, } from \"./getFromAST.js\";\nimport { filterInPlace } from \"../common/filterInPlace.js\";\nimport { isField, isInlineFragment } from \"./storeUtils.js\";\nimport { createFragmentMap, } from \"./fragments.js\";\nvar TYPENAME_FIELD = {\n    kind: 'Field',\n    name: {\n        kind: 'Name',\n        value: '__typename',\n    },\n};\nfunction isEmpty(op, fragmentMap) {\n    return !op || op.selectionSet.selections.every(function (selection) { return selection.kind === 'FragmentSpread' &&\n        isEmpty(fragmentMap[selection.name.value], fragmentMap); });\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}\nexport function 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 !!v.name && !variablesInUse[v.name]; }).length) {\n        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n    }\n    if (modifiedDoc &&\n        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !!fs.name && !fragmentSpreadsInUse[fs.name]; })\n            .length) {\n        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n    }\n    return modifiedDoc;\n}\nexport var addTypenameToDocument = Object.assign(function (doc) {\n    return visit(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: __spreadArray(__spreadArray([], selections, true), [TYPENAME_FIELD], false) });\n            },\n        },\n    });\n}, {\n    added: function (field) {\n        return field === TYPENAME_FIELD;\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                __DEV__ && 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};\nexport function 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 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}\nexport function 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 ? 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                    if (node.arguments) {\n                        node.arguments.forEach(function (arg) {\n                            if (argMatcher(arg)) {\n                                argMatchCount_1 += 1;\n                            }\n                        });\n                    }\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nexport function 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}\nexport function 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}\nexport function 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//# sourceMappingURL=transform.js.map","import { __assign, __rest as __rest_1, __spreadArray } from \"tslib\";\nimport { __rest } from \"tslib\";\nimport { mergeDeep } from \"../common/mergeDeep.js\";\nexport function concatPagination(keyArgs) {\n    if (keyArgs === void 0) { keyArgs = false; }\n    return {\n        keyArgs: keyArgs,\n        merge: function (existing, incoming) {\n            return existing ? __spreadArray(__spreadArray([], existing, true), incoming, true) : incoming;\n        },\n    };\n}\nexport function offsetLimitPagination(keyArgs) {\n    if (keyArgs === void 0) { keyArgs = false; }\n    return {\n        keyArgs: keyArgs,\n        merge: function (existing, incoming, _a) {\n            var args = _a.args;\n            var merged = existing ? existing.slice(0) : [];\n            if (incoming) {\n                if (args) {\n                    var _b = args.offset, offset = _b === void 0 ? 0 : _b;\n                    for (var i = 0; i < incoming.length; ++i) {\n                        merged[offset + i] = incoming[i];\n                    }\n                }\n                else {\n                    merged.push.apply(merged, incoming);\n                }\n            }\n            return merged;\n        },\n    };\n}\nexport function relayStylePagination(keyArgs) {\n    if (keyArgs === void 0) { keyArgs = false; }\n    return {\n        keyArgs: keyArgs,\n        read: function (existing, _a) {\n            var canRead = _a.canRead, readField = _a.readField;\n            if (!existing)\n                return existing;\n            var edges = [];\n            var firstEdgeCursor = \"\";\n            var lastEdgeCursor = \"\";\n            existing.edges.forEach(function (edge) {\n                if (canRead(readField(\"node\", edge))) {\n                    edges.push(edge);\n                    if (edge.cursor) {\n                        firstEdgeCursor = firstEdgeCursor || edge.cursor || \"\";\n                        lastEdgeCursor = edge.cursor || lastEdgeCursor;\n                    }\n                }\n            });\n            var _b = existing.pageInfo || {}, startCursor = _b.startCursor, endCursor = _b.endCursor;\n            return __assign(__assign({}, getExtras(existing)), { edges: edges, pageInfo: __assign(__assign({}, existing.pageInfo), { startCursor: startCursor || firstEdgeCursor, endCursor: endCursor || lastEdgeCursor }) });\n        },\n        merge: function (existing, incoming, _a) {\n            var args = _a.args, isReference = _a.isReference, readField = _a.readField;\n            if (!existing) {\n                existing = makeEmptyData();\n            }\n            if (!incoming) {\n                return existing;\n            }\n            var incomingEdges = incoming.edges ? incoming.edges.map(function (edge) {\n                if (isReference(edge = __assign({}, edge))) {\n                    edge.cursor = readField(\"cursor\", edge);\n                }\n                return edge;\n            }) : [];\n            if (incoming.pageInfo) {\n                var pageInfo_1 = incoming.pageInfo;\n                var startCursor = pageInfo_1.startCursor, endCursor = pageInfo_1.endCursor;\n                var firstEdge = incomingEdges[0];\n                var lastEdge = incomingEdges[incomingEdges.length - 1];\n                if (firstEdge && startCursor) {\n                    firstEdge.cursor = startCursor;\n                }\n                if (lastEdge && endCursor) {\n                    lastEdge.cursor = endCursor;\n                }\n                var firstCursor = firstEdge && firstEdge.cursor;\n                if (firstCursor && !startCursor) {\n                    incoming = mergeDeep(incoming, {\n                        pageInfo: {\n                            startCursor: firstCursor,\n                        },\n                    });\n                }\n                var lastCursor = lastEdge && lastEdge.cursor;\n                if (lastCursor && !endCursor) {\n                    incoming = mergeDeep(incoming, {\n                        pageInfo: {\n                            endCursor: lastCursor,\n                        },\n                    });\n                }\n            }\n            var prefix = existing.edges;\n            var suffix = [];\n            if (args && args.after) {\n                var index = prefix.findIndex(function (edge) { return edge.cursor === args.after; });\n                if (index >= 0) {\n                    prefix = prefix.slice(0, index + 1);\n                }\n            }\n            else if (args && args.before) {\n                var index = prefix.findIndex(function (edge) { return edge.cursor === args.before; });\n                suffix = index < 0 ? prefix : prefix.slice(index);\n                prefix = [];\n            }\n            else if (incoming.edges) {\n                prefix = [];\n            }\n            var edges = __spreadArray(__spreadArray(__spreadArray([], prefix, true), incomingEdges, true), suffix, true);\n            var pageInfo = __assign(__assign({}, incoming.pageInfo), existing.pageInfo);\n            if (incoming.pageInfo) {\n                var _b = incoming.pageInfo, hasPreviousPage = _b.hasPreviousPage, hasNextPage = _b.hasNextPage, startCursor = _b.startCursor, endCursor = _b.endCursor, extras = __rest_1(_b, [\"hasPreviousPage\", \"hasNextPage\", \"startCursor\", \"endCursor\"]);\n                Object.assign(pageInfo, extras);\n                if (!prefix.length) {\n                    if (void 0 !== hasPreviousPage)\n                        pageInfo.hasPreviousPage = hasPreviousPage;\n                    if (void 0 !== startCursor)\n                        pageInfo.startCursor = startCursor;\n                }\n                if (!suffix.length) {\n                    if (void 0 !== hasNextPage)\n                        pageInfo.hasNextPage = hasNextPage;\n                    if (void 0 !== endCursor)\n                        pageInfo.endCursor = endCursor;\n                }\n            }\n            return __assign(__assign(__assign({}, getExtras(existing)), getExtras(incoming)), { edges: edges, pageInfo: pageInfo });\n        },\n    };\n}\nvar getExtras = function (obj) { return __rest(obj, notExtras); };\nvar notExtras = [\"edges\", \"pageInfo\"];\nfunction makeEmptyData() {\n    return {\n        edges: [],\n        pageInfo: {\n            hasPreviousPage: false,\n            hasNextPage: true,\n            startCursor: \"\",\n            endCursor: \"\",\n        },\n    };\n}\n//# sourceMappingURL=pagination.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"./Observable.js\";\nimport { iterateObserversSafely } from \"./iteration.js\";\nimport { fixObservableSubclass } from \"./subclassing.js\";\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\nvar Concast = (function (_super) {\n    __extends(Concast, _super);\n    function Concast(sources) {\n        var _this = _super.call(this, function (observer) {\n            _this.addObserver(observer);\n            return function () { return _this.removeObserver(observer); };\n        }) || this;\n        _this.observers = new Set();\n        _this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        _this.handlers = {\n            next: function (result) {\n                if (_this.sub !== null) {\n                    _this.latest = [\"next\", result];\n                    _this.notify(\"next\", result);\n                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    if (sub)\n                        setTimeout(function () { return sub.unsubscribe(); });\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    _this.notify(\"error\", error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    var value = _this.sources.shift();\n                    if (!value) {\n                        if (sub)\n                            setTimeout(function () { return sub.unsubscribe(); });\n                        _this.sub = null;\n                        if (_this.latest &&\n                            _this.latest[0] === \"next\") {\n                            _this.resolve(_this.latest[1]);\n                        }\n                        else {\n                            _this.resolve();\n                        }\n                        _this.notify(\"complete\");\n                        iterateObserversSafely(_this.observers, \"complete\");\n                    }\n                    else if (isPromiseLike(value)) {\n                        value.then(function (obs) { return _this.sub = obs.subscribe(_this.handlers); });\n                    }\n                    else {\n                        _this.sub = value.subscribe(_this.handlers);\n                    }\n                }\n            },\n        };\n        _this.nextResultListeners = new Set();\n        _this.cancel = function (reason) {\n            _this.reject(reason);\n            _this.sources = [];\n            _this.handlers.complete();\n        };\n        _this.promise.catch(function (_) { });\n        if (typeof sources === \"function\") {\n            sources = [new Observable(sources)];\n        }\n        if (isPromiseLike(sources)) {\n            sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);\n        }\n        else {\n            _this.start(sources);\n        }\n        return _this;\n    }\n    Concast.prototype.start = function (sources) {\n        if (this.sub !== void 0)\n            return;\n        this.sources = Array.from(sources);\n        this.handlers.complete();\n    };\n    Concast.prototype.deliverLastMessage = function (observer) {\n        if (this.latest) {\n            var nextOrError = this.latest[0];\n            var method = observer[nextOrError];\n            if (method) {\n                method.call(observer, this.latest[1]);\n            }\n            if (this.sub === null &&\n                nextOrError === \"next\" &&\n                observer.complete) {\n                observer.complete();\n            }\n        }\n    };\n    Concast.prototype.addObserver = function (observer) {\n        if (!this.observers.has(observer)) {\n            this.deliverLastMessage(observer);\n            this.observers.add(observer);\n        }\n    };\n    Concast.prototype.removeObserver = function (observer) {\n        if (this.observers.delete(observer) &&\n            this.observers.size < 1) {\n            this.handlers.complete();\n        }\n    };\n    Concast.prototype.notify = function (method, arg) {\n        var nextResultListeners = this.nextResultListeners;\n        if (nextResultListeners.size) {\n            this.nextResultListeners = new Set;\n            nextResultListeners.forEach(function (listener) { return listener(method, arg); });\n        }\n    };\n    Concast.prototype.beforeNext = function (callback) {\n        var called = false;\n        this.nextResultListeners.add(function (method, arg) {\n            if (!called) {\n                called = true;\n                callback(method, arg);\n            }\n        });\n    };\n    return Concast;\n}(Observable));\nexport { Concast };\nfixObservableSubclass(Concast);\n//# sourceMappingURL=Concast.js.map","import { Observable } from \"./Observable.js\";\nexport function asyncMap(observable, mapFn, catchFn) {\n    return new Observable(function (observer) {\n        var next = observer.next, error = observer.error, complete = observer.complete;\n        var activeCallbackCount = 0;\n        var completed = false;\n        var promiseQueue = {\n            then: function (callback) {\n                return new Promise(function (resolve) { return resolve(callback()); });\n            },\n        };\n        function makeCallback(examiner, delegate) {\n            if (examiner) {\n                return function (arg) {\n                    ++activeCallbackCount;\n                    var both = function () { return examiner(arg); };\n                    promiseQueue = promiseQueue.then(both, both).then(function (result) {\n                        --activeCallbackCount;\n                        next && next.call(observer, result);\n                        if (completed) {\n                            handler.complete();\n                        }\n                    }, function (error) {\n                        --activeCallbackCount;\n                        throw error;\n                    }).catch(function (caught) {\n                        error && error.call(observer, caught);\n                    });\n                };\n            }\n            else {\n                return function (arg) { return delegate && delegate.call(observer, arg); };\n            }\n        }\n        var handler = {\n            next: makeCallback(mapFn, next),\n            error: makeCallback(catchFn, error),\n            complete: function () {\n                completed = true;\n                if (!activeCallbackCount) {\n                    complete && complete.call(observer);\n                }\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n//# sourceMappingURL=asyncMap.js.map","export function 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}\n//# sourceMappingURL=iteration.js.map","import { Observable } from \"./Observable.js\";\nimport { canUseSymbol } from \"../common/canUse.js\";\nexport function fixObservableSubclass(subclass) {\n    function set(key) {\n        Object.defineProperty(subclass, key, { value: Observable });\n    }\n    if (canUseSymbol && Symbol.species) {\n        set(Symbol.species);\n    }\n    set(\"@@species\");\n    return subclass;\n}\n//# sourceMappingURL=subclassing.js.map"],"sourceRoot":""}