{"version":3,"sources":["webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/core/types/Cache.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/core/cache.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/core/types/common.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/policies.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/LocalState.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/QueryInfo.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/QueryManager.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/ApolloClient.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/version.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/Reobserver.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/ObservableQuery.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/index.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/core/networkStatus.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/errors/index.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/core/ApolloLink.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/core/concat.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/core/empty.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/core/execute.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/core/from.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/core/split.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/HttpLink.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/createHttpLink.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/checkFetcher.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/selectURI.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/createSignalIfSupported.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/utils/fromError.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/utils/throwServerError.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/utils/validateOperation.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/utils/createOperation.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/link/utils/transformOperation.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/node_modules/graphql-tag/lib/index.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/context/ApolloContext.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/context/ApolloConsumer.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/context/ApolloProvider.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/hooks/useApolloClient.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/data/OperationData.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/data/SubscriptionData.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/data/QueryData.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/data/MutationData.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/hooks/useQuery.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/hooks/utils/useBaseQuery.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/hooks/utils/useDeepMemo.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/react/parser/index.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/graphql/directives.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/filterInPlace.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/graphql/transform.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/observables/Observable.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/observables/iteration.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/observables/subclassing.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/observables/Concast.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/arrays.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/canUse.js","webpack://uconn-today-plugin/./node_modules/@apollo/client/utilities/common/compact.js"],"names":["Cache","ApolloCache","this","getFragmentDoc","prototype","recordOptimisticTransaction","transaction","optimisticId","performTransaction","transformDocument","document","identify","object","gc","modify","options","transformForLink","readQuery","optimistic","read","rootId","id","query","variables","returnPartialData","readFragment","fragment","fragmentName","writeQuery","write","dataId","result","data","broadcast","writeFragment","MissingFieldError","message","path","clientOnly","hasOwn","Object","hasOwnProperty","TypeOrFieldNameRegExp","storeFieldName","match","selectionSetMatchesResult","selectionSet","Array","isArray","every","item","selections","field","key","call","storeValueIsStoreObject","value","DELETE","create","delModifier","INVALIDATE","EntityStore","policies","group","_this","rootIds","refs","getFieldValue","objectOrReference","get","__ref","canRead","objOrRef","has","toReference","objOrIdOrRef","mergeIntoStore","ref","merge","toObject","lookup","fieldName","depend","storeObject","rootTypenamesById","Layer","parent","dependOnExistence","incoming","existing","merged","storeObjectReconciler","caching","fieldsToDirty_1","__exists","keys","forEach","hasKeyArgs","__typename","dirty","fields","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","isReference","readField","fieldNameOrOptions","from","store","fieldValue","newValue","storage","getStorage","delete","args","_a","typename","getStoreFieldName","evict","evicted","clear","replace","extract","obj","extraRootIds","getRootIdSet","push","length","__META","sort","newData","rest_1","retain","release","count","ids","Set","add","snapshot","findChildRefIds","idsToRemove","root_1","found_1","workSet_1","canTraverse_1","values","filter","makeCacheKey","_i","arguments","keyMaker","lookupArray","CacheGroup","d","makeDepKey","Root","_super","_b","resultCaching","seed","storageTrie","sharedLayerGroup","addLayer","layerId","replay","removeLayer","fromParent","p","apply","existingObject","incomingObject","property","existingValue","incomingValue","supportsResultCaching","missingFromInvariant","err","context","slice","StoreReader","config","executeSelectionSet","execSelectionSetImpl","keyArgs","varString","knownResults","WeakMap","executeSubSelectedArray","execSubSelectedArrayImpl","array","addTypename","diffQueryAgainstStore","_c","cache","execResult","JSON","stringify","fragmentMap","hasMissingFields","missing","complete","isFresh","latest","peek","objectsToMerge","finalResult","getMissing","handleMissing","rootIdsByTypename","workSet","selection","name","resultName","wasClientOnly","directives","some","pop","fragmentMatches","set","childResult","i","map","StoreWriter","reader","writeToStore","operationDefinition","merger","processSelectionSet","mergeTree","Map","written","keyObject","sets","indexOf","incomingFields","resultFieldKey","childTree","getChildMergeTree","processFieldValue","childTypename","getMergeFunction","info","maybeRecycleChildMergeTree","usingPossibleTypes","entityRef_1","size","applyMerges","getStorageArgs","e_1","i_1","getValue_1","String","eVal","iVal","aVal","runMergeFunction","emptyMergeTreePool","cacheSlot","consumeAndIterate","callback","items_1","cacheInfoMap","getCacheInfo","vars","dep","makeVar","caches","listeners","rv","listener","getValue","attach","onNextChange","attachCache","forgetCache","broadcastWatches","argsFromFieldSpecifier","spec","defaultDataIdFromObject","_id","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","_","Policies","typePolicies","toBeAdded","supertypeMap","fuzzySubtypes","dataIdFromObject","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","ROOT_QUERY","policy","getTypePolicy","keyFn","specifierOrId","keyFieldsFnFromSpecifier","queryType","mutationType","subscriptionType","updateTypePolicy","keyFields","setMerge","getFieldPolicy","keyArgsFnFromSpecifier","which","toUpperCase","old","supertype","getSupertypeSet","subtype","RegExp","policy_1","supertypes","rest","assign","inbox","splice","createIfMissing","fieldPolicies","supertypeSet","typeCondition","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","needToCheckFuzzySubtypes","regExp","fuzzyString","fieldSpec","specifierOrString","readOptions","makeFieldFunctionOptions","withValue","parentTypename","makeMergeObjectsFunction","eType","iType","specifier","computeKeyObject","trie","aliasMap","makeAliasMap","workQueue","alias","responseKey","storeKey","aliases","subsets","response","strict","prevKey","keyObj","s","subset","responseName","defaultConfig","InMemoryCache","watches","typenameDocumentCache","txCount","maybeBroadcastWatch","c","fromOptimisticTransaction","broadcastWatch","optimisticData","watchDep","storeWriter","storeReader","restore","e","diff","watch","immediate","forget","reset","Promise","resolve","removeOptimistic","idToRemove","newOptimisticData","perform","layer","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","node","arg","kind","rootValue","mainDefinition","fragments","definitionOperation","defaultOperationType","execContext","operation","charAt","resolveSelectionSet","resultsToMerge","execute","resolveField","fieldResult","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directive","resolveSubSelectedArray","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","original","cancelNotifyTimeout","clearTimeout","QueryInfo","lastRequestId","subscriptions","stopped","observableQuery","init","networkStatus","networkError","graphQLErrors","setObservableQuery","getDiff","updateWatch","setDiff","oldDiff","notifyTimeout","setTimeout","notify","oq","oqListener","reobserve","shouldNotify","fetchPolicy","stop","cancel","sub","unsubscribe","stopPolling","lastWatch","shouldWrite","lastWrite","dmCount","markResult","allowCacheWrite","errors","shouldWriteResult","errorPolicy","markReady","markError","error","ignoreErrors","writeWithErrors","QueryManager","link","queryDeduplication","onBroadcast","ssrMode","_d","clientAwareness","localState","assumeImmutableResults","queries","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","mutationStore","_info","queryId","stopQueryNoBroadcast","cancelPendingFetches","mutate","mutation","optimisticResponse","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","update","_e","mutationId","mutationStoreValue","self","_f","label","generateMutationId","transform","getVariables","hasClientExports","sent","loading","markMutationOptimistic","broadcastQueries","reject","storeResult","getObservableFromLink","subscribe","next","markMutationResult","refetchQueryPromises","refetchQuery","queryName","refetch","queryOptions","cacheWrites_1","updateQueries_1","updater","currentQueryResult","nextQueryResult","mutationResult","queryVariables","fetchQuery","fetchQueryObservable","promise","getQueryStore","resetErrors","queryInfo","undefined","transformed","forLink","cacheEntry_1","hasForcedResolvers","defaultVars","doc","watchQuery","notifyOnNetworkStatusChange","observable","ObservableQuery","queryManager","pollInterval","generateQueryId","finally","stopQuery","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","hasObservers","resetLastResults","getQuery","startGraphQLSubscription","makeObservable","observablePromise_1","observer","removeQuery","getLocalState","deduplication","inFlightLinkObservables_1","operationName","forceFetch","byVariables_1","varJson_1","concast","cleanup","getResultsFromLink","hasErrors","aqr","oldNetworkStatus","normalized","fromVariables","fetchQueryByPolicy","reason","nextFetchPolicy","readCache","resultsFromCache","fromData","partial","resolved","resultsFromLink","newContext","mergeOptions","defaults","ApolloClient","defaultOptions","resetStoreCallbacks","clearStoreCallbacks","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","window","__APOLLO_CLIENT__","typeDefs","clientAwarenessName","clientAwarenessVersion","version","disableNetworkFetches","bind","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","__actionHookForDevTools","cb","__requestRaw","payload","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","setLink","newLink","Reobserver","fetch","shouldFetch","newOptions","newNetworkStatus","updateOptions","updatePolling","removeObserver","addObserver","pollingInfo","timeout","interval","maybeFetch","poll","onSubscribe","observers","lastError","isDifferentFromLastResult","updateLastResult","lastResult","isTornDown","opDef","defineProperty","enumerable","configurable","subscription","getCurrentResult","saveAsLastResult","newResult","lastResultSnapshot","getLastResult","getLastError","resetQueryStoreErrors","reobserveOptions","newReobserver","fetchMore","fetchMoreOptions","combinedOptions","qid","observe","fetchMoreResult","updateQuery","previous","subscribeToMore","subscriptionData","onError","setOptions","setVariables","mapFn","previousResult","startPolling","getReobserver","reobserver","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","catch","tearDownQuery","shareOptions","currentOptions","NetworkStatus","isNetworkRequestInFlight","isApolloError","ApolloError","errorMessage","extraInfo","graphQLError","__proto__","Error","passthrough","op","forward","toLink","handler","ApolloLink","isTerminating","request","empty","links","reduce","x","y","concat","split","test","left","right","leftLink","rightLink","second","firstLink","nextLink","setOnError","serializeFetchParameter","serialized","parseError","fallbackHttpConfig","http","includeQuery","includeExtensions","accept","method","HttpLink","linkOptions","fetcher","useGETForQueries","includeUnusedVariables","requestOptions","checkFetcher","linkConfig","fetchOptions","chosenURI","fallbackURI","getContext","selectURI","clientAwarenessHeaders","name_1","controller","contextHeaders","contextConfig","fallbackConfig","configs","extensions","body","selectHttpOptionsAndBody","unusedNames_1","Variable","_key","signal","AbortController","createSignalIfSupported","_controller","definitions","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","join","rewriteURIForGET","operations","setContext","text","bodyText","parse","statusCode","status","abort","createHttpLink","fromError","errorValue","throwServerError","validateOperation","OPERATION_FIELDS","createOperation","starting","transformOperation","transformedOperation","docCache","fragmentSourceMap","printFragmentWarnings","experimentalFragmentVariables","normalize","string","trim","parseDocument","source","ast","seenKeys","cacheKey","parsed","loc","startToken","endToken","stripLoc","fragmentDefinition","sourceKey","substring","start","end","sourceKeySet","console","warn","gql","literals","resetCaches","disableFragmentWarnings","enableExperimentalFragmentVariables","disableExperimentalFragmentVariables","displayName","ApolloProvider","children","ApolloContext","Consumer","Provider","useApolloClient","OperationData","isMounted","previousOptions","getOptions","storePrevious","unmount","refreshClient","isNew","verifyDocumentType","type","parser","SubscriptionData","setResult","currentObservable","initialize","skip","currentResult","getLoadingResult","shouldResubscribe","startSubscription","afterExecute","endSubscription","updateCurrentData","updateError","completeSubscription","updateResult","onSubscriptionData","onSubscriptionComplete","QueryData","MutationData","runMutation","mutationFunctionOptions","onMutationStart","generateNewMutationId","onMutationCompleted","onMutationError","mostRecentMutationId","ignoreResults","called","onCompleted","isMostRecentMutation","onNewData","runLazy","runLazyQuery","lazyOptions","getQueryResult","observableQueryFields","partialRefetch","previousData","obsRefetch","obsFetchMore","obsUpdateQuery","obsStartPolling","obsStopPolling","obsSubscribeToMore","removeQuerySubscription","removeObservable","updateObservableQuery","startQuerySubscription","getExecuteSsrResult","getExecuteResult","executeLazy","fetchData","ssr","lazy","handleErrorOrCompleted","ssrInitiated","renderPromises","ssrDisabled","fetchDisabled","ssrLoading","stale","addQueryPromise","prepareObservableQueryOptions","initializeObservableQuery","getSSRObservable","observableQueryOptions","registerSSRObservable","newObservableQueryOptions","currentSubscription","resubscribeToQuery","andDelete","useQuery","useContext","useReducer","tick","forceUpdate","updatedOptions","queryDataRef","useRef","queryData","current","memoFn","queryResult","useEffect","DocumentType","Query","Mutation","Subscription","cached","definition","variableDefinitions","shouldInclude","isInclusionDirective","directiveArguments","ifArgument","ifValue","getInclusionDirectives","evaledValue","hasDirectives","names","root","getDirectiveNames","getFragmentQueryDocument","actualFragmentName","createFragmentMap","symTable","getFragmentFromSelection","makeReference","Boolean","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","argumentsObjectFromField","argObj_1","resultKeyNameFromField","getTypenameFromResult","isInlineFragment","checkDocument","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","queryDef","getMainDefinition","queryDoc","getDefaultValues","defaultValues","defs","def","defaultValue","variable","filterInPlace","target","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","fragmentDef","getFragmentDefinition","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Field","remove","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","v","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","removeArgumentsFromDocument","fs","FragmentDefinition","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","added","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","sources","mergeDeepArray","DeepMerger","isObject","defaultReconciler","reconciler","pastCopies","targetValue","shallowCopyForMerge","getPrototypeOf","toString","cloneDeep","cloneDeepHelper","val","seen","copy_1","child","copy_2","maybeDeepFreeze","iterateObserversSafely","observersWithMethod","obs","asyncMap","catchFn","activeCallbackCount","completed","makeCallback","examiner","delegate","fixObservableSubclass","subclass","Symbol","species","isPromiseLike","Concast","addCount","handlers","shift","iterable","deliverLastMessage","nextOrError","quietly","once","isNonEmptyArray","graphQLResultHasError","canUseWeakMap","navigator","product","compact","objects"],"mappings":"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","file":"apolloVendor.js","sourcesContent":["export var Cache;\n(function (Cache) {\n})(Cache || (Cache = {}));\n//# sourceMappingURL=Cache.js.map","import { wrap } from 'optimism';\nimport { getFragmentQueryDocument, } from \"../../utilities/index.js\";\nvar ApolloCache = (function () {\n    function ApolloCache() {\n        this.getFragmentDoc = wrap(getFragmentQueryDocument);\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.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.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read({\n            rootId: options.id || 'ROOT_QUERY',\n            query: options.query,\n            variables: options.variables,\n            returnPartialData: options.returnPartialData,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read({\n            query: this.getFragmentDoc(options.fragment, options.fragmentName),\n            variables: options.variables,\n            rootId: options.id,\n            returnPartialData: options.returnPartialData,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.writeQuery = function (options) {\n        return this.write({\n            dataId: options.id || 'ROOT_QUERY',\n            result: options.data,\n            query: options.query,\n            variables: options.variables,\n            broadcast: options.broadcast,\n        });\n    };\n    ApolloCache.prototype.writeFragment = function (options) {\n        return this.write({\n            dataId: options.id,\n            result: options.data,\n            variables: options.variables,\n            query: this.getFragmentDoc(options.fragment, options.fragmentName),\n            broadcast: options.broadcast,\n        });\n    };\n    return ApolloCache;\n}());\nexport { ApolloCache };\n//# sourceMappingURL=cache.js.map","var MissingFieldError = (function () {\n    function MissingFieldError(message, path, query, clientOnly, variables) {\n        this.message = message;\n        this.path = path;\n        this.query = query;\n        this.clientOnly = clientOnly;\n        this.variables = variables;\n    }\n    return MissingFieldError;\n}());\nexport { MissingFieldError };\n//# sourceMappingURL=common.js.map","import { isReference, isField, DeepMerger, resultKeyNameFromField, shouldInclude, } from \"../../utilities/index.js\";\nexport var hasOwn = Object.prototype.hasOwnProperty;\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 (result && typeof result === \"object\") {\n        return Array.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 value !== null &&\n        typeof value === \"object\" &&\n        !isReference(value) &&\n        !Array.isArray(value);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger;\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __extends, __rest } from \"tslib\";\nimport { dep, KeyTrie } from 'optimism';\nimport { equal } from '@wry/equality';\nimport { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, } 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 (dataId, incoming) {\n        var _this = this;\n        var existing = this.lookup(dataId);\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                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,\n                            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) {\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) {\n                evicted = this.parent.evict(options) || 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 workSet_1 = new Set([this.data[dataId]]);\n            var canTraverse_1 = function (obj) { return obj !== null && typeof obj === 'object'; };\n            workSet_1.forEach(function (obj) {\n                if (isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                }\n                else if (canTraverse_1(obj)) {\n                    Object.values(obj)\n                        .filter(canTraverse_1)\n                        .forEach(workSet_1.add, workSet_1);\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return this.group.keyMaker.lookupArray(args);\n    };\n    return EntityStore;\n}());\nexport { EntityStore };\nvar CacheGroup = (function () {\n    function CacheGroup(caching) {\n        this.caching = caching;\n        this.d = null;\n        this.keyMaker = new KeyTrie(canUseWeakMap);\n        this.d = caching ? dep() : null;\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        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName));\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    return storeFieldName + '#' + dataId;\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.storageTrie = new KeyTrie(canUseWeakMap);\n            _this.sharedLayerGroup = new CacheGroup(resultCaching);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            return new Layer(layerId, this, replay, this.sharedLayerGroup);\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                    if (_this.data[dataId] !== parent.lookup(dataId)) {\n                        _this.delete(dataId);\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));\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 { wrap } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { isField, resultKeyNameFromField, isReference, makeReference, createFragmentMap, shouldInclude, addTypenameToDocument, getDefaultValues, getFragmentDefinitions, getMainDefinition, getQueryDefinition, maybeDeepFreeze, mergeDeepArray, getFragmentFromSelection, } from \"../../utilities/index.js\";\nimport { supportsResultCaching } from \"./entityStore.js\";\nimport { getTypenameFromStoreObject } from \"./helpers.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\n;\nfunction missingFromInvariant(err, context) {\n    return new MissingFieldError(err.message, context.path.slice(), context.query, context.clientOnly, context.variables);\n}\nvar StoreReader = (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.config = config;\n        this.executeSelectionSet = wrap(function (options) { return _this.execSelectionSetImpl(options); }, {\n            keyArgs: function (options) {\n                return [\n                    options.selectionSet,\n                    options.objectOrReference,\n                    options.context,\n                ];\n            },\n            makeCacheKey: function (selectionSet, parent, context) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString);\n                }\n            }\n        });\n        this.knownResults = new WeakMap();\n        this.executeSubSelectedArray = wrap(function (options) {\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\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        this.config = __assign({ addTypename: true }, config);\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;\n        var policies = this.config.cache.policies;\n        variables = __assign(__assign({}, getDefaultValues(getQueryDefinition(query))), variables);\n        var execResult = this.executeSelectionSet({\n            selectionSet: getMainDefinition(query).selectionSet,\n            objectOrReference: makeReference(rootId),\n            context: {\n                store: store,\n                query: query,\n                policies: policies,\n                variables: variables,\n                varString: JSON.stringify(variables),\n                fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n                path: [],\n                clientOnly: false,\n            },\n        });\n        var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n        if (hasMissingFields && !returnPartialData) {\n            throw execResult.missing[0];\n        }\n        return {\n            result: execResult.result,\n            missing: execResult.missing,\n            complete: !hasMissingFields,\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);\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, context = _a.context;\n        if (isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: {},\n                missing: [missingFromInvariant(process.env.NODE_ENV === \"production\" ? new InvariantError(4) : new InvariantError(\"Dangling reference to missing \" + objectOrReference.__ref + \" object\"), context)],\n            };\n        }\n        var variables = context.variables, policies = context.policies, store = context.store;\n        var objectsToMerge = [];\n        var finalResult = { result: null };\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            objectsToMerge.push({ __typename: typename });\n        }\n        function getMissing() {\n            return finalResult.missing || (finalResult.missing = []);\n        }\n        function handleMissing(result) {\n            var _a;\n            if (result.missing)\n                (_a = getMissing()).push.apply(_a, result.missing);\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a;\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                context.path.push(resultName);\n                var wasClientOnly = context.clientOnly;\n                context.clientOnly = wasClientOnly || !!(selection.directives &&\n                    selection.directives.some(function (d) { return d.name.value === \"client\"; }));\n                if (fieldValue === void 0) {\n                    if (!addTypenameToDocument.added(selection)) {\n                        getMissing().push(missingFromInvariant(process.env.NODE_ENV === \"production\" ? new InvariantError(5) : new InvariantError(\"Can't find field '\" + selection.name.value + \"' on \" + (isReference(objectOrReference)\n                            ? objectOrReference.__ref + \" object\"\n                            : \"object \" + JSON.stringify(objectOrReference, null, 2))), context));\n                    }\n                }\n                else if (Array.isArray(fieldValue)) {\n                    fieldValue = handleMissing(_this.executeSubSelectedArray({\n                        field: selection,\n                        array: fieldValue,\n                        context: context,\n                    }));\n                }\n                else if (!selection.selectionSet) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        assertSelectionSetForIdValue(context.store, selection, fieldValue);\n                        maybeDeepFreeze(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        context: context,\n                    }));\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_a = {}, _a[resultName] = fieldValue, _a));\n                }\n                context.clientOnly = wasClientOnly;\n                invariant(context.path.pop() === resultName);\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.fragmentMap);\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        finalResult.result = mergeDeepArray(objectsToMerge);\n        if (process.env.NODE_ENV !== 'production') {\n            Object.freeze(finalResult.result);\n        }\n        this.knownResults.set(finalResult.result, selectionSet);\n        return finalResult;\n    };\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, context = _a.context;\n        var missing;\n        function handleMissing(childResult, i) {\n            if (childResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, childResult.missing);\n            }\n            invariant(context.path.pop() === i);\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            context.path.push(i);\n            if (Array.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    context: context,\n                }), i);\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    context: context,\n                }), i);\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            invariant(context.path.pop() === i);\n            return item;\n        });\n        if (process.env.NODE_ENV !== 'production') {\n            Object.freeze(array);\n        }\n        return { result: array, missing: missing };\n    };\n    return StoreReader;\n}());\nexport { StoreReader };\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (value && typeof value === \"object\") {\n                process.env.NODE_ENV === \"production\" ? invariant(!isReference(value), 6) : invariant(!isReference(value), \"Missing selection set for object of type \" + getTypenameFromStoreObject(store, value) + \" returned for query field \" + field.name.value);\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n//# sourceMappingURL=readFromStore.js.map","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { equal } from '@wry/equality';\nimport { createFragmentMap, getFragmentFromSelection, getDefaultValues, getFragmentDefinitions, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, hasDirectives, cloneDeep, } from \"../../utilities/index.js\";\nimport { makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject } from \"./helpers.js\";\n;\nvar StoreWriter = (function () {\n    function StoreWriter(cache, reader) {\n        this.cache = cache;\n        this.reader = reader;\n    }\n    StoreWriter.prototype.writeToStore = function (_a) {\n        var query = _a.query, result = _a.result, dataId = _a.dataId, store = _a.store, variables = _a.variables;\n        var operationDefinition = getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);\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: {\n                store: store,\n                written: Object.create(null),\n                merge: function (existing, incoming) {\n                    return merger.merge(existing, incoming);\n                },\n                variables: variables,\n                varString: JSON.stringify(variables),\n                fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n            },\n        });\n        if (!isReference(ref)) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(7) : new InvariantError(\"Could not identify object \" + JSON.stringify(result));\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 _b = policies.identify(result, selectionSet, context.fragmentMap), id = _b[0], keyObject = _b[1];\n        dataId = dataId || id;\n        if (\"string\" === typeof dataId) {\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            var ref = makeReference(dataId);\n            if (sets.indexOf(selectionSet) >= 0)\n                return ref;\n            sets.push(selectionSet);\n            if (this.reader && this.reader.isFresh(result, ref, selectionSet, context)) {\n                return ref;\n            }\n        }\n        var incomingFields = Object.create(null);\n        if (keyObject) {\n            incomingFields = context.merge(incomingFields, keyObject);\n        }\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            incomingFields.__typename = typename;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, context.variables))\n                return;\n            if (isField(selection)) {\n                var resultFieldKey = resultKeyNameFromField(selection);\n                var value = result[resultFieldKey];\n                if (typeof value !== 'undefined') {\n                    var storeFieldName = policies.getStoreFieldName({\n                        typename: typename,\n                        fieldName: selection.name.value,\n                        field: selection,\n                        variables: context.variables,\n                    });\n                    var childTree = getChildMergeTree(mergeTree, storeFieldName);\n                    var incomingValue = _this.processFieldValue(value, selection, context, childTree);\n                    var childTypename = selection.selectionSet\n                        && context.store.getFieldValue(incomingValue, \"__typename\")\n                        || void 0;\n                    var merge = policies.getMergeFunction(typename, selection.name.value, childTypename);\n                    if (merge) {\n                        childTree.info = {\n                            field: selection,\n                            typename: typename,\n                            merge: merge,\n                        };\n                    }\n                    else {\n                        maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                    }\n                    incomingFields = context.merge(incomingFields, (_a = {},\n                        _a[storeFieldName] = incomingValue,\n                        _a));\n                }\n                else if (policies.usingPossibleTypes &&\n                    !hasDirectives([\"defer\", \"client\"], selection)) {\n                    throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Missing field '\" + resultFieldKey + \"' in \" + JSON.stringify(result, null, 2).substring(0, 100));\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.fragmentMap);\n                if (fragment &&\n                    policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        if (\"string\" === typeof dataId) {\n            var entityRef_1 = makeReference(dataId);\n            if (mergeTree.map.size) {\n                incomingFields = this.applyMerges(mergeTree, entityRef_1, incomingFields, context);\n            }\n            if (process.env.NODE_ENV !== \"production\") {\n                var hasSelectionSet_1 = function (storeFieldName) {\n                    return fieldsWithSelectionSets_1.has(fieldNameFromStoreName(storeFieldName));\n                };\n                var fieldsWithSelectionSets_1 = new Set();\n                workSet.forEach(function (selection) {\n                    if (isField(selection) && selection.selectionSet) {\n                        fieldsWithSelectionSets_1.add(selection.name.value);\n                    }\n                });\n                var hasMergeFunction_1 = function (storeFieldName) {\n                    var childTree = mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(incomingFields).forEach(function (storeFieldName) {\n                    if (hasSelectionSet_1(storeFieldName) &&\n                        !hasMergeFunction_1(storeFieldName)) {\n                        warnAboutDataLoss(entityRef_1, incomingFields, storeFieldName, context.store);\n                    }\n                });\n            }\n            context.store.merge(dataId, incomingFields);\n            return entityRef_1;\n        }\n        return incomingFields;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            return process.env.NODE_ENV === 'production' ? value : cloneDeep(value);\n        }\n        if (Array.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.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 = (!Array.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 Array.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                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                var eVal = getValue_1(e_1, storeFieldName);\n                var iVal = getValue_1(i_1, storeFieldName);\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 = (Array.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 maybeRecycleChildMergeTree(_a, name) {\n    var map = _a.map;\n    var childTree = map.get(name);\n    if (childTree &&\n        !childTree.info &&\n        !childTree.map.size) {\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 = parentType + \".\" + fieldName;\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    if (!Array.isArray(existing) &&\n        !Array.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    process.env.NODE_ENV === \"production\" || invariant.warn(\"Cache data may be lost when replacing the \" + fieldName + \" field of a \" + parentType + \" object.\\n\\nTo address this problem (which is not a bug in Apollo Client), \" + (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 \" + typeDotName + \" field, so InMemoryCache can safely merge these objects:\\n\\n  existing: \" + JSON.stringify(existing).slice(0, 1000) + \"\\n  incoming: \" + 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 { dep } from \"optimism\";\nimport { Slot } from \"@wry/context\";\nexport var cacheSlot = new Slot();\nfunction consumeAndIterate(set, callback) {\n    if (set.size) {\n        var items_1 = [];\n        set.forEach(function (item) { return items_1.push(item); });\n        set.clear();\n        items_1.forEach(callback);\n    }\n}\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                consumeAndIterate(listeners, 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, __rest } from \"tslib\";\nimport { KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { getFragmentFromSelection, isField, getTypenameFromResult, storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, canUseWeakMap, compact, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName, storeValueIsStoreObject, selectionSetMatchesResult, TypeOrFieldNameRegExp, } from \"./helpers.js\";\nimport { cacheSlot } from \"./reactiveVars.js\";\nfunction argsFromFieldSpecifier(spec) {\n    return spec.args !== void 0 ? spec.args :\n        spec.field ? argumentsObjectFromField(spec.field, spec.variables) : null;\n}\nexport var defaultDataIdFromObject = function (_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                id !== void 0 ? { id: id } :\n                    _id !== void 0 ? { _id: _id } :\n                        void 0;\n        }\n        if (id === void 0)\n            id = _id;\n        if (id !== void 0) {\n            return __typename + \":\" + ((typeof id === \"number\" ||\n                typeof id === \"string\") ? id : JSON.stringify(id));\n        }\n    }\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, selectionSet, fragmentMap) {\n        var typename = selectionSet && fragmentMap\n            ? getTypenameFromResult(object, selectionSet, fragmentMap)\n            : object.__typename;\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        var context = {\n            typename: typename,\n            selectionSet: selectionSet,\n            fragmentMap: fragmentMap,\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 (Array.isArray(specifierOrId)) {\n                keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n            }\n            else {\n                id = specifierOrId;\n                break;\n            }\n        }\n        id = id && String(id);\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                Array.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                            Array.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            process.env.NODE_ENV === \"production\" ? invariant(!old || old === which, 1) : invariant(!old || old === which, \"Cannot change root \" + which + \" __typename more than once\");\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            this.updateTypePolicy(typename, compact.apply(void 0, inbox.splice(0)));\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                            process.env.NODE_ENV === \"production\" || invariant.warn(\"Inferring subtype \" + typename + \" of supertype \" + 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 (Array.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        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.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.getFieldValue)(existing, incoming);\n        }\n        if (merge === mergeFalseFn) {\n            return incoming;\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, getFieldValue = _a.getFieldValue, 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 (fieldNameOrOptions, from) {\n            var options = typeof fieldNameOrOptions === \"string\" ? {\n                fieldName: fieldNameOrOptions,\n                from: from,\n            } : __assign({}, fieldNameOrOptions);\n            if (void 0 === options.from) {\n                options.from = objectOrReference;\n            }\n            if (void 0 === options.variables) {\n                options.variables = variables;\n            }\n            return policies.readField(options, context);\n        },\n        mergeObjects: makeMergeObjectsFunction(getFieldValue),\n    };\n}\nfunction makeMergeObjectsFunction(getFieldValue) {\n    return function mergeObjects(existing, incoming) {\n        if (Array.isArray(existing) || Array.isArray(incoming)) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"Cannot automatically merge arrays\");\n        }\n        if (existing && typeof existing === \"object\" &&\n            incoming && typeof incoming === \"object\") {\n            var eType = getFieldValue(existing, \"__typename\");\n            var iType = getFieldValue(incoming, \"__typename\");\n            var typesDiffer = eType && iType && eType !== iType;\n            if (typesDiffer ||\n                !storeValueIsStoreObject(existing) ||\n                !storeValueIsStoreObject(incoming)) {\n                return incoming;\n            }\n            return __assign(__assign({}, existing), incoming);\n        }\n        return incoming;\n    };\n}\nfunction keyArgsFnFromSpecifier(specifier) {\n    return function (args, context) {\n        return args ? context.fieldName + \":\" + JSON.stringify(computeKeyObject(args, specifier, false)) : context.fieldName;\n    };\n}\nfunction keyFieldsFnFromSpecifier(specifier) {\n    var trie = new KeyTrie(canUseWeakMap);\n    return function (object, context) {\n        var aliasMap;\n        if (context.selectionSet && context.fragmentMap) {\n            var info = trie.lookupArray([\n                context.selectionSet,\n                context.fragmentMap,\n            ]);\n            aliasMap = info.aliasMap || (info.aliasMap = makeAliasMap(context.selectionSet, context.fragmentMap));\n        }\n        var keyObject = context.keyObject =\n            computeKeyObject(object, specifier, true, aliasMap);\n        return context.typename + \":\" + JSON.stringify(keyObject);\n    };\n}\nfunction makeAliasMap(selectionSet, fragmentMap) {\n    var map = Object.create(null);\n    var workQueue = new Set([selectionSet]);\n    workQueue.forEach(function (selectionSet) {\n        selectionSet.selections.forEach(function (selection) {\n            if (isField(selection)) {\n                if (selection.alias) {\n                    var responseKey = selection.alias.value;\n                    var storeKey = selection.name.value;\n                    if (storeKey !== responseKey) {\n                        var aliases = map.aliases || (map.aliases = Object.create(null));\n                        aliases[storeKey] = responseKey;\n                    }\n                }\n                if (selection.selectionSet) {\n                    var subsets = map.subsets || (map.subsets = Object.create(null));\n                    subsets[selection.name.value] =\n                        makeAliasMap(selection.selectionSet, fragmentMap);\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, fragmentMap);\n                if (fragment) {\n                    workQueue.add(fragment.selectionSet);\n                }\n            }\n        });\n    });\n    return map;\n}\nfunction computeKeyObject(response, specifier, strict, aliasMap) {\n    var keyObj = Object.create(null);\n    var prevKey;\n    specifier.forEach(function (s) {\n        if (Array.isArray(s)) {\n            if (typeof prevKey === \"string\") {\n                var subsets = aliasMap && aliasMap.subsets;\n                var subset = subsets && subsets[prevKey];\n                keyObj[prevKey] = computeKeyObject(response[prevKey], s, strict, subset);\n            }\n        }\n        else {\n            var aliases = aliasMap && aliasMap.aliases;\n            var responseName = aliases && aliases[s] || s;\n            if (hasOwn.call(response, responseName)) {\n                keyObj[prevKey = s] = response[responseName];\n            }\n            else {\n                process.env.NODE_ENV === \"production\" ? invariant(!strict, 3) : invariant(!strict, \"Missing field '\" + responseName + \"' while computing key fields\");\n                prevKey = void 0;\n            }\n        }\n    });\n    return keyObj;\n}\n//# sourceMappingURL=policies.js.map","import { __assign, __extends } from \"tslib\";\nimport \"./fixPolyfills.js\";\nimport { dep, wrap } from 'optimism';\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 { defaultDataIdFromObject, Policies, } from \"./policies.js\";\nimport { hasOwn } from \"./helpers.js\";\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    typePolicies: {},\n};\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.maybeBroadcastWatch = wrap(function (c, fromOptimisticTransaction) {\n            return _this.broadcastWatch.call(_this, c, !!fromOptimisticTransaction);\n        }, {\n            makeCacheKey: function (c) {\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, rootId = c.rootId, variables = c.variables;\n                    return store.makeCacheKey(c.query, c.callback, JSON.stringify({ optimistic: optimistic, rootId: rootId, variables: variables }));\n                }\n            }\n        });\n        _this.watchDep = dep();\n        _this.config = __assign(__assign({}, defaultConfig), 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.data = new EntityStore.Root({\n            policies: _this.policies,\n            resultCaching: _this.config.resultCaching,\n        });\n        _this.optimisticData = _this.data;\n        _this.storeWriter = new StoreWriter(_this, _this.storeReader = new StoreReader({\n            cache: _this,\n            addTypename: _this.addTypename,\n        }));\n        return _this;\n    }\n    InMemoryCache.prototype.restore = function (data) {\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).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({\n                store: options.optimistic ? this.optimisticData : this.data,\n                query: options.query,\n                variables: options.variables,\n                rootId: options.rootId,\n                config: this.config,\n                returnPartialData: returnPartialData,\n            }).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({\n                store: this.data,\n                query: options.query,\n                result: options.result,\n                dataId: options.dataId,\n                variables: options.variables,\n            });\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({\n            store: options.optimistic ? this.optimisticData : this.data,\n            rootId: options.id || \"ROOT_QUERY\",\n            query: options.query,\n            variables: options.variables,\n            returnPartialData: options.returnPartialData,\n            config: this.config,\n        });\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.watchDep.dirty(watch);\n            _this.maybeBroadcastWatch.forget(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function () {\n        return this.optimisticData.gc();\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        return isReference(object) ? object.__ref :\n            this.policies.identify(object)[0];\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);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function () {\n        this.data.clear();\n        this.optimisticData = this.data;\n        this.broadcastWatches();\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.performTransaction = function (transaction, optimisticId) {\n        var _this = this;\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                transaction(_this);\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        var fromOptimisticTransaction = false;\n        if (typeof optimisticId === 'string') {\n            this.optimisticData = this.optimisticData.addLayer(optimisticId, perform);\n            fromOptimisticTransaction = true;\n        }\n        else if (optimisticId === null) {\n            perform(this.data);\n        }\n        else {\n            perform();\n        }\n        this.broadcastWatches(fromOptimisticTransaction);\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        if (this.addTypename) {\n            var result = this.typenameDocumentCache.get(document);\n            if (!result) {\n                result = addTypenameToDocument(document);\n                this.typenameDocumentCache.set(document, result);\n                this.typenameDocumentCache.set(result, result);\n            }\n            return result;\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function (fromOptimisticTransaction) {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, fromOptimisticTransaction); });\n        }\n    };\n    InMemoryCache.prototype.broadcastWatch = function (c, fromOptimisticTransaction) {\n        this.watchDep.dirty(c);\n        this.watchDep(c);\n        var diff = this.diff({\n            query: c.query,\n            variables: c.variables,\n            optimistic: c.optimistic,\n        });\n        if (c.optimistic && fromOptimisticTransaction) {\n            diff.fromOptimisticTransaction = true;\n        }\n        c.callback(diff);\n    };\n    return InMemoryCache;\n}(ApolloCache));\nexport { InMemoryCache };\n//# sourceMappingURL=inMemoryCache.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { visit, BREAK, } from 'graphql';\nimport { invariant } from 'ts-invariant';\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,\n            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,\n                        client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (isField(selection)) {\n                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== 'undefined') {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            process.env.NODE_ENV === \"production\" ? invariant(fragment, 11) : invariant(fragment, \"No fragment named \" + selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2];\n                    });\n                }); };\n                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(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 { equal } from \"@wry/equality\";\nimport { isNonEmptyArray, graphQLResultHasError, canUseWeakMap, } from \"../utilities/index.js\";\nimport { NetworkStatus, isNetworkRequestInFlight, } from \"./networkStatus.js\";\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(cache) {\n        this.cache = cache;\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.diff = null;\n        this.observableQuery = null;\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.diff = null;\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.diff = null;\n        this.dirty = false;\n    };\n    QueryInfo.prototype.getDiff = function (variables) {\n        if (variables === void 0) { variables = this.variables; }\n        if (this.diff && equal(variables, this.variables)) {\n            return this.diff;\n        }\n        this.updateWatch(this.variables = variables);\n        return this.diff = this.cache.diff({\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n        });\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var oldDiff = this.diff;\n        this.diff = diff;\n        if (!this.dirty &&\n            (diff && diff.result) !== (oldDiff && oldDiff.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                if (_this.getDiff().fromOptimisticTransaction) {\n                    oq[\"observe\"]();\n                }\n                else {\n                    oq.reobserve();\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.cancel();\n            delete this.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        if (!this.lastWatch ||\n            this.lastWatch.query !== this.document ||\n            !equal(variables, this.lastWatch.variables)) {\n            this.cancel();\n            this.cancel = this.cache.watch(this.lastWatch = {\n                query: this.document,\n                variables: variables,\n                optimistic: true,\n                callback: function (diff) { return _this.setDiff(diff); },\n            });\n        }\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, options, allowCacheWrite) {\n        var _this = this;\n        this.graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];\n        this.reset();\n        if (options.fetchPolicy === 'no-cache') {\n            this.diff = { result: result.data, complete: true };\n        }\n        else if (!this.stopped && allowCacheWrite) {\n            if (shouldWriteResult(result, options.errorPolicy)) {\n                this.cache.performTransaction(function (cache) {\n                    if (_this.shouldWrite(result, options.variables)) {\n                        cache.writeQuery({\n                            query: _this.document,\n                            data: result.data,\n                            variables: options.variables,\n                        });\n                        _this.lastWrite = {\n                            result: result,\n                            variables: options.variables,\n                            dmCount: destructiveMethodCounts.get(_this.cache),\n                        };\n                    }\n                    else {\n                        if (_this.diff && _this.diff.complete) {\n                            result.data = _this.diff.result;\n                            return;\n                        }\n                    }\n                    var diff = cache.diff({\n                        query: _this.document,\n                        variables: options.variables,\n                        returnPartialData: true,\n                        optimistic: true,\n                    });\n                    if (!_this.stopped) {\n                        _this.updateWatch(options.variables);\n                    }\n                    _this.diff = diff;\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 'ts-invariant';\nimport { equal } from '@wry/equality';\nimport { execute } from \"../link/core/index.js\";\nimport { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, removeConnectionDirectiveFromDocument, canUseWeakMap, Observable, asyncMap, isNonEmptyArray, Concast, } from \"../utilities/index.js\";\nimport { ApolloError, isApolloError } from \"../errors/index.js\";\nimport { ObservableQuery } 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, _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.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(process.env.NODE_ENV === \"production\" ? new InvariantError(12) : new InvariantError('QueryManager stopped while query was in flight'));\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 mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, mutationStoreValue, self;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        process.env.NODE_ENV === \"production\" ? invariant(mutation, 13) : invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        process.env.NODE_ENV === \"production\" ? invariant(!fetchPolicy || fetchPolicy === 'no-cache', 14) : invariant(!fetchPolicy || fetchPolicy === 'no-cache', \"Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.\");\n                        mutationId = this.generateMutationId();\n                        mutation = this.transform(mutation).document;\n                        variables = this.getVariables(mutation, variables);\n                        if (!this.transform(mutation).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = _f.sent();\n                        _f.label = 2;\n                    case 2:\n                        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                                errorPolicy: errorPolicy,\n                                updateQueries: updateQueries,\n                                update: updateWithProxyFn,\n                            });\n                        }\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                var storeResult;\n                                var error;\n                                self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError({\n                                                graphQLErrors: result.errors,\n                                            });\n                                            return;\n                                        }\n                                        if (mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = null;\n                                        }\n                                        if (fetchPolicy !== 'no-cache') {\n                                            try {\n                                                self.markMutationResult({\n                                                    mutationId: mutationId,\n                                                    result: result,\n                                                    document: mutation,\n                                                    variables: variables,\n                                                    errorPolicy: errorPolicy,\n                                                    updateQueries: updateQueries,\n                                                    update: updateWithProxyFn,\n                                                });\n                                            }\n                                            catch (e) {\n                                                error = new ApolloError({\n                                                    networkError: e,\n                                                });\n                                                return;\n                                            }\n                                        }\n                                        storeResult = result;\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(new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                    complete: function () {\n                                        if (error && mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = error;\n                                        }\n                                        if (optimisticResponse) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        if (error) {\n                                            reject(error);\n                                            return;\n                                        }\n                                        if (typeof refetchQueries === 'function') {\n                                            refetchQueries = refetchQueries(storeResult);\n                                        }\n                                        var refetchQueryPromises = [];\n                                        if (isNonEmptyArray(refetchQueries)) {\n                                            refetchQueries.forEach(function (refetchQuery) {\n                                                if (typeof refetchQuery === 'string') {\n                                                    self.queries.forEach(function (_a) {\n                                                        var observableQuery = _a.observableQuery;\n                                                        if (observableQuery &&\n                                                            observableQuery.queryName === refetchQuery) {\n                                                            refetchQueryPromises.push(observableQuery.refetch());\n                                                        }\n                                                    });\n                                                }\n                                                else {\n                                                    var queryOptions = {\n                                                        query: refetchQuery.query,\n                                                        variables: refetchQuery.variables,\n                                                        fetchPolicy: 'network-only',\n                                                    };\n                                                    if (refetchQuery.context) {\n                                                        queryOptions.context = refetchQuery.context;\n                                                    }\n                                                    refetchQueryPromises.push(self.query(queryOptions));\n                                                }\n                                            });\n                                        }\n                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                                            if (errorPolicy === 'ignore' &&\n                                                storeResult &&\n                                                graphQLResultHasError(storeResult)) {\n                                                delete storeResult.errors;\n                                            }\n                                            resolve(storeResult);\n                                        }, reject);\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        if (shouldWriteResult(mutation.result, mutation.errorPolicy)) {\n            var cacheWrites_1 = [{\n                    result: mutation.result.data,\n                    dataId: 'ROOT_MUTATION',\n                    query: mutation.document,\n                    variables: mutation.variables,\n                }];\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                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: mutation.result,\n                            queryName: document && getOperationName(document) || void 0,\n                            queryVariables: variables,\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites_1.push({\n                                result: nextQueryResult,\n                                dataId: 'ROOT_QUERY',\n                                query: document,\n                                variables: variables,\n                            });\n                        }\n                    }\n                });\n            }\n            cache.performTransaction(function (c) {\n                cacheWrites_1.forEach(function (write) { return c.write(write); });\n                var update = mutation.update;\n                if (update) {\n                    update(c, mutation.result);\n                }\n            }, null);\n        }\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                process.env.NODE_ENV === \"production\" || 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 forLink = removeConnectionDirectiveFromDocument(this.cache.transformForLink(transformed));\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = forLink && this.localState.serverQuery(forLink);\n            var cacheEntry_1 = {\n                document: transformed,\n                hasClientExports: hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: getDefaultValues(getOperationDefinition(transformed)),\n            };\n            var add = function (doc) {\n                if (doc && !transformCache.has(doc)) {\n                    transformCache.set(doc, cacheEntry_1);\n                }\n            };\n            add(document);\n            add(transformed);\n            add(clientQuery);\n            add(serverQuery);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options) {\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.cache);\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: options.query,\n            observableQuery: observable,\n            variables: options.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(options.query, 15) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        process.env.NODE_ENV === \"production\" ? invariant(options.query.kind === 'Document', 16) : invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.returnPartialData, 17) : invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.pollInterval, 18) : invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');\n        var queryId = this.generateQueryId();\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 () {\n        this.cancelPendingFetches(process.env.NODE_ENV === \"production\" ? new InvariantError(19) : new InvariantError('Store reset while query was in flight (not completed in link chain)'));\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();\n    };\n    QueryManager.prototype.resetStore = function () {\n        var _this = this;\n        return this.clearStore().then(function () {\n            return _this.reFetchObservableQueries();\n        });\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery && observableQuery.hasObservers()) {\n                var fetchPolicy = observableQuery.options.fetchPolicy;\n                observableQuery.resetLastResults();\n                if (fetchPolicy !== 'cache-only' &&\n                    (includeStandby || fetchPolicy !== 'standby')) {\n                    observableQueryPromises.push(observableQuery.refetch());\n                }\n                _this.getQuery(queryId).setDiff(null);\n            }\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, false).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        this.getQuery(queryId).stop();\n        this.queries.delete(queryId);\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 = JSON.stringify(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.cleanup(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, allowCacheWrite, options) {\n        var lastRequestId = queryInfo.lastRequestId;\n        return asyncMap(this.getObservableFromLink(queryInfo.document, options.context, options.variables), function (result) {\n            var hasErrors = isNonEmptyArray(result.errors);\n            if (lastRequestId >= queryInfo.lastRequestId) {\n                if (hasErrors && options.errorPolicy === \"none\") {\n                    throw queryInfo.markError(new ApolloError({\n                        graphQLErrors: result.errors,\n                    }));\n                }\n                queryInfo.markResult(result, options, allowCacheWrite);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: queryInfo.networkStatus || NetworkStatus.ready,\n            };\n            if (hasErrors && options.errorPolicy !== \"ignore\") {\n                aqr.errors = result.errors;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = isApolloError(networkError)\n                ? networkError\n                : new ApolloError({ networkError: networkError });\n            if (lastRequestId >= 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 oldNetworkStatus = queryInfo.networkStatus;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? \"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 mightUseNetwork = fetchPolicy === \"cache-first\" ||\n            fetchPolicy === \"cache-and-network\" ||\n            fetchPolicy === \"network-only\" ||\n            fetchPolicy === \"no-cache\";\n        if (mightUseNetwork &&\n            notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus)) {\n            if (fetchPolicy !== \"cache-first\") {\n                fetchPolicy = \"cache-and-network\";\n            }\n            returnPartialData = true;\n        }\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            return _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n        };\n        this.fetchCancelFns.set(queryId, function (reason) {\n            Promise.resolve().then(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.cleanup(function () {\n            _this.fetchCancelFns.delete(queryId);\n            var nextFetchPolicy = options.nextFetchPolicy;\n            if (nextFetchPolicy) {\n                options.nextFetchPolicy = void 0;\n                options.fetchPolicy = typeof nextFetchPolicy === \"function\"\n                    ? nextFetchPolicy.call(options, options.fetchPolicy || \"cache-first\")\n                    : nextFetchPolicy;\n            }\n        });\n        return concast;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, options, networkStatus) {\n        var _this = this;\n        var query = options.query, variables = options.variables, fetchPolicy = options.fetchPolicy, errorPolicy = options.errorPolicy, returnPartialData = options.returnPartialData, context = options.context;\n        queryInfo.init({\n            document: query,\n            variables: variables,\n            lastRequestId: this.generateRequestId(),\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 (process.env.NODE_ENV !== 'production' &&\n                isNonEmptyArray(diff.missing) &&\n                !equal(data, {}) &&\n                !returnPartialData) {\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing cache result fields: \" + diff.missing.map(function (m) { return m.path.join('.'); }).join(', '), 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 (_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); });\n            }\n            return fromData(data);\n        };\n        var resultsFromLink = function (allowCacheWrite) {\n            return _this.getResultsFromLink(queryInfo, allowCacheWrite, {\n                variables: variables,\n                context: context,\n                fetchPolicy: fetchPolicy,\n                errorPolicy: errorPolicy,\n            });\n        };\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) {\n                    return [\n                        resultsFromCache(diff),\n                        resultsFromLink(true),\n                    ];\n                }\n                return [\n                    resultsFromLink(true),\n                ];\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData) {\n                    return [\n                        resultsFromCache(diff),\n                        resultsFromLink(true),\n                    ];\n                }\n                return [\n                    resultsFromLink(true),\n                ];\n            }\n            case \"cache-only\":\n                return [\n                    resultsFromCache(readCache(), queryInfo.markReady()),\n                ];\n            case \"network-only\":\n                return [resultsFromLink(true)];\n            case \"no-cache\":\n                return [resultsFromLink(false)];\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.cache));\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","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { ApolloLink, execute } from \"../link/core/index.js\";\nimport { compact } from \"../utilities/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;\nexport function mergeOptions(defaults, options) {\n    return compact(defaults, options, options.variables && {\n        variables: __assign(__assign({}, defaults.variables), options.variables),\n    });\n}\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.defaultOptions = {};\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            process.env.NODE_ENV !== 'production' : _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 process.env.NODE_ENV === \"production\" ? new InvariantError(9) : 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\");\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || {};\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        if (connectToDevTools && typeof window === 'object') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self &&\n                !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                    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            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        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'cache-and-network', 10) : invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +\n            'client.query can only return a single result. Please use client.watchQuery ' +\n            'to receive multiple results from the cache and the network, or consider ' +\n            'using a different fetchPolicy, such as cache-first or network-only.');\n        if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = 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            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    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.3.11';\n//# sourceMappingURL=version.js.map","import { NetworkStatus } from \"./networkStatus.js\";\nimport { compact } from \"../utilities/index.js\";\nimport { invariant } from 'ts-invariant';\nvar Reobserver = (function () {\n    function Reobserver(observer, options, fetch, shouldFetch) {\n        this.observer = observer;\n        this.options = options;\n        this.fetch = fetch;\n        this.shouldFetch = shouldFetch;\n    }\n    Reobserver.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        if (newOptions) {\n            this.updateOptions(newOptions);\n        }\n        else {\n            this.updatePolling();\n        }\n        var concast = this.fetch(this.options, newNetworkStatus);\n        if (this.concast) {\n            this.concast.removeObserver(this.observer, true);\n        }\n        concast.addObserver(this.observer);\n        return (this.concast = concast).promise;\n    };\n    Reobserver.prototype.updateOptions = function (newOptions) {\n        Object.assign(this.options, compact(newOptions));\n        this.updatePolling();\n        return this;\n    };\n    Reobserver.prototype.stop = function () {\n        if (this.concast) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n        }\n        if (this.pollingInfo) {\n            clearTimeout(this.pollingInfo.timeout);\n            this.options.pollInterval = 0;\n            this.updatePolling();\n        }\n    };\n    Reobserver.prototype.updatePolling = function () {\n        var _this = this;\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        process.env.NODE_ENV === \"production\" ? invariant(pollInterval, 20) : invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');\n        if (this.shouldFetch === false) {\n            return;\n        }\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            if (_this.pollingInfo) {\n                if (_this.shouldFetch && _this.shouldFetch()) {\n                    _this.reobserve({\n                        fetchPolicy: \"network-only\",\n                        nextFetchPolicy: _this.options.fetchPolicy || \"cache-first\",\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    return Reobserver;\n}());\nexport { Reobserver };\n//# sourceMappingURL=Reobserver.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from 'ts-invariant';\nimport { equal } from '@wry/equality';\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { cloneDeep, getOperationDefinition, Observable, iterateObserversSafely, isNonEmptyArray, fixObservableSubclass, } from \"../utilities/index.js\";\nimport { Reobserver } from \"./Reobserver.js\";\nvar warnedAboutUpdateQuery = false;\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            return _this.onSubscribe(observer);\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.observer = {\n            next: function (result) {\n                if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n                    _this.updateLastResult(result);\n                    iterateObserversSafely(_this.observers, 'next', result);\n                }\n            },\n            error: function (error) {\n                _this.updateLastResult(__assign(__assign({}, _this.lastResult), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false }));\n                iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n            },\n        };\n        _this.isTornDown = false;\n        _this.options = options;\n        _this.queryId = queryManager.generateQueryId();\n        var opDef = getOperationDefinition(options.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        _this.queryManager = queryManager;\n        _this.queryInfo = queryInfo;\n        return _this;\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.lastResult;\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        if (this.isTornDown) {\n            return result;\n        }\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? 'cache-first' : _a;\n        if (fetchPolicy === 'no-cache' ||\n            fetchPolicy === 'network-only') {\n            delete result.partial;\n        }\n        else if (!result.data ||\n            !this.queryManager.transform(this.options.query).hasForcedResolvers) {\n            var diff = this.queryInfo.getDiff();\n            result.data = (diff.complete ||\n                this.options.returnPartialData) ? diff.result : void 0;\n            if (diff.complete) {\n                if (result.networkStatus === NetworkStatus.loading &&\n                    (fetchPolicy === 'cache-first' ||\n                        fetchPolicy === 'cache-only')) {\n                    result.networkStatus = NetworkStatus.ready;\n                    result.loading = false;\n                }\n                delete result.partial;\n            }\n            else {\n                result.partial = true;\n            }\n        }\n        if (saveAsLastResult) {\n            this.updateLastResult(result);\n        }\n        return result;\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        return !equal(this.lastResultSnapshot, newResult);\n    };\n    ObservableQuery.prototype.getLastResult = function () {\n        return this.lastResult;\n    };\n    ObservableQuery.prototype.getLastError = function () {\n        return this.lastError;\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.lastResult;\n        delete this.lastResultSnapshot;\n        delete this.lastError;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        this.queryManager.resetErrors(this.queryId);\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var reobserveOptions = {\n            pollInterval: 0,\n        };\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'cache-and-network') {\n            reobserveOptions.fetchPolicy = 'network-only';\n            reobserveOptions.nextFetchPolicy = fetchPolicy || \"cache-first\";\n        }\n        if (variables && !equal(this.options.variables, variables)) {\n            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);\n        }\n        return this.newReobserver(false).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({}, this.options), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) }))), { fetchPolicy: \"no-cache\" });\n        var qid = this.queryManager.generateQueryId();\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            this.queryInfo.networkStatus = NetworkStatus.fetchMore;\n            this.observe();\n        }\n        return this.queryManager.fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore).then(function (fetchMoreResult) {\n            var data = fetchMoreResult.data;\n            var updateQuery = fetchMoreOptions.updateQuery;\n            if (updateQuery) {\n                if (process.env.NODE_ENV !== \"production\" &&\n                    !warnedAboutUpdateQuery) {\n                    process.env.NODE_ENV === \"production\" || invariant.warn(\"The updateQuery callback for fetchMore is deprecated, and will be removed\\nin the next major version of Apollo Client.\\n\\nPlease convert updateQuery functions to field policies with appropriate\\nread and merge functions, or use/adapt a helper function (such as\\nconcatPagination, offsetLimitPagination, or relayStylePagination) from\\n@apollo/client/utilities.\\n\\nThe field policy system handles pagination more effectively than a\\nhand-written updateQuery function, and you only need to define the policy\\nonce, rather than every time you call fetchMore.\");\n                    warnedAboutUpdateQuery = true;\n                }\n                _this.updateQuery(function (previous) { return updateQuery(previous, {\n                    fetchMoreResult: data,\n                    variables: combinedOptions.variables,\n                }); });\n            }\n            else {\n                _this.queryManager.cache.writeQuery({\n                    query: combinedOptions.query,\n                    variables: combinedOptions.variables,\n                    data: data,\n                });\n            }\n            return fetchMoreResult;\n        }).finally(function () {\n            _this.queryManager.stopQuery(qid);\n            _this.reobserve();\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                process.env.NODE_ENV === \"production\" || invariant.error('Unhandled GraphQL subscription error', err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (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        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? 'cache-first' : _a;\n        var reobserveOptions = {\n            fetchPolicy: fetchPolicy,\n            variables: variables,\n        };\n        if (fetchPolicy !== 'cache-first' &&\n            fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'network-only') {\n            reobserveOptions.fetchPolicy = 'cache-and-network';\n            reobserveOptions.nextFetchPolicy = fetchPolicy;\n        }\n        return this.reobserve(reobserveOptions, NetworkStatus.setVariables);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var _a;\n        var queryManager = this.queryManager;\n        var result = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            previousResult: (_a = this.lastResult) === null || _a === void 0 ? void 0 : _a.data,\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.getReobserver().updateOptions({ pollInterval: pollInterval });\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        if (this.reobserver) {\n            this.reobserver.updateOptions({ pollInterval: 0 });\n        }\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult) {\n        var previousResult = this.lastResult;\n        this.lastResult = newResult;\n        this.lastResultSnapshot = this.queryManager.assumeImmutableResults\n            ? newResult\n            : cloneDeep(newResult);\n        if (!isNonEmptyArray(newResult.errors)) {\n            delete this.lastError;\n        }\n        return previousResult;\n    };\n    ObservableQuery.prototype.onSubscribe = function (observer) {\n        var _this = this;\n        if (observer === this.observer) {\n            return function () { };\n        }\n        try {\n            var subObserver = observer._subscription._observer;\n            if (subObserver && !subObserver.error) {\n                subObserver.error = defaultSubscriptionObserverErrorCallback;\n            }\n        }\n        catch (_a) { }\n        var first = !this.observers.size;\n        this.observers.add(observer);\n        if (this.lastError) {\n            observer.error && observer.error(this.lastError);\n        }\n        else if (this.lastResult) {\n            observer.next && observer.next(this.lastResult);\n        }\n        if (first) {\n            this.reobserve().catch(function (_) {\n            });\n        }\n        return function () {\n            if (_this.observers.delete(observer) && !_this.observers.size) {\n                _this.tearDownQuery();\n            }\n        };\n    };\n    ObservableQuery.prototype.getReobserver = function () {\n        return this.reobserver || (this.reobserver = this.newReobserver(true));\n    };\n    ObservableQuery.prototype.newReobserver = function (shareOptions) {\n        var _this = this;\n        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;\n        queryManager.setObservableQuery(this);\n        return new Reobserver(this.observer, shareOptions ? this.options : __assign({}, this.options), function (currentOptions, newNetworkStatus) {\n            queryManager.setObservableQuery(_this);\n            return queryManager.fetchQueryObservable(queryId, currentOptions, newNetworkStatus);\n        }, !queryManager.ssrMode && (function () { return !isNetworkRequestInFlight(_this.queryInfo.networkStatus); }));\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        this.isTornDown = false;\n        return this.getReobserver().reobserve(newOptions, newNetworkStatus);\n    };\n    ObservableQuery.prototype.observe = function () {\n        this.observer.next(this.getCurrentResult(false));\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.reobserver) {\n            this.reobserver.stop();\n            delete this.reobserver;\n        }\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);\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\n//# sourceMappingURL=ObservableQuery.js.map","export { 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(\"log\");\nimport gql from 'graphql-tag';\nexport var resetCaches = gql.resetCaches, disableFragmentWarnings = gql.disableFragmentWarnings, enableExperimentalFragmentVariables = gql.enableExperimentalFragmentVariables, disableExperimentalFragmentVariables = gql.disableExperimentalFragmentVariables;\nexport { gql };\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 { 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)) {\n        err.graphQLErrors.forEach(function (graphQLError) {\n            var errorMessage = graphQLError\n                ? graphQLError.message\n                : 'Error message not found.';\n            message += errorMessage + \"\\n\";\n        });\n    }\n    if (err.networkError) {\n        message += err.networkError.message + \"\\n\";\n    }\n    message = message.replace(/\\n$/, '');\n    return message;\n};\nvar ApolloError = (function (_super) {\n    __extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.networkError = networkError || null;\n        _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 'ts-invariant';\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            process.env.NODE_ENV === \"production\" || invariant.warn(new LinkError(\"You are calling concat on a terminating link, which will have no effect\", firstLink));\n            return firstLink;\n        }\n        var nextLink = toLink(second);\n        if (isTerminating(nextLink)) {\n            return new ApolloLink(function (operation) {\n                return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n            });\n        }\n        else {\n            return new ApolloLink(function (operation, forward) {\n                return (firstLink.request(operation, function (op) {\n                    return nextLink.request(op, forward) || Observable.of();\n                }) || Observable.of());\n            });\n        }\n    };\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 process.env.NODE_ENV === \"production\" ? new InvariantError(21) : new InvariantError('request is not implemented');\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 { ApolloLink } from \"./ApolloLink.js\";\nexport var concat = ApolloLink.concat;\n//# sourceMappingURL=concat.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var empty = ApolloLink.empty;\n//# sourceMappingURL=empty.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var execute = ApolloLink.execute;\n//# sourceMappingURL=execute.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 { throwServerError } from \"../utils/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function parseAndCheckHttpResponse(operations) {\n    return function (response) { return response\n        .text()\n        .then(function (bodyText) {\n        try {\n            return JSON.parse(bodyText);\n        }\n        catch (err) {\n            var parseError = err;\n            parseError.name = 'ServerParseError';\n            parseError.response = response;\n            parseError.statusCode = response.status;\n            parseError.bodyText = bodyText;\n            throw parseError;\n        }\n    })\n        .then(function (result) {\n        if (response.status >= 300) {\n            throwServerError(response, result, \"Response not successful: Received status code \" + response.status);\n        }\n        if (!Array.isArray(result) &&\n            !hasOwnProperty.call(result, 'data') &&\n            !hasOwnProperty.call(result, 'errors')) {\n            throwServerError(response, result, \"Server response was missing for query '\" + (Array.isArray(operations)\n                ? operations.map(function (op) { return op.operationName; })\n                : operations.operationName) + \"'.\");\n        }\n        return result;\n    }); };\n}\n//# sourceMappingURL=parseAndCheckHttpResponse.js.map","import { InvariantError } from 'ts-invariant';\nexport var serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = process.env.NODE_ENV === \"production\" ? new InvariantError(23) : new InvariantError(\"Network request failed. \" + label + \" is not serializable: \" + e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n//# sourceMappingURL=serializeFetchParameter.js.map","import { __assign } from \"tslib\";\nimport { print } from 'graphql';\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n};\nvar defaultHeaders = {\n    accept: '*/*',\n    'content-type': 'application/json',\n};\nvar defaultOptions = {\n    method: 'POST',\n};\nexport var fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nexport var selectHttpOptionsAndBody = function (operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = __assign(__assign({}, fallbackConfig.options), { headers: fallbackConfig.headers, credentials: fallbackConfig.credentials });\n    var http = fallbackConfig.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        http = __assign(__assign({}, http), config.http);\n    });\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    if (http.includeQuery)\n        body.query = print(query);\n    return {\n        options: options,\n        body: body,\n    };\n};\n//# sourceMappingURL=selectHttpOptionsAndBody.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 { __assign, __rest } from \"tslib\";\nimport { visit } from 'graphql/language/visitor';\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nimport { selectURI } from \"./selectURI.js\";\nimport { parseAndCheckHttpResponse } from \"./parseAndCheckHttpResponse.js\";\nimport { checkFetcher } from \"./checkFetcher.js\";\nimport { selectHttpOptionsAndBody, fallbackHttpConfig } from \"./selectHttpOptionsAndBody.js\";\nimport { createSignalIfSupported } from \"./createSignalIfSupported.js\";\nimport { rewriteURIForGET } from \"./rewriteURIForGET.js\";\nimport { fromError } from \"../utils/index.js\";\nexport var createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, fetcher = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, _b = linkOptions.includeUnusedVariables, includeUnusedVariables = _b === void 0 ? false : _b, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"includeExtensions\", \"useGETForQueries\", \"includeUnusedVariables\"]);\n    checkFetcher(fetcher);\n    if (!fetcher) {\n        fetcher = fetch;\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders['apollographql-client-name'] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders['apollographql-client-version'] = version;\n            }\n        }\n        var contextHeaders = __assign(__assign({}, clientAwarenessHeaders), context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        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 (options.method === 'GET') {\n            var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, 'Payload');\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            fetcher(chosenURI, options)\n                .then(function (response) {\n                operation.setContext({ response: response });\n                return response;\n            })\n                .then(parseAndCheckHttpResponse(operation))\n                .then(function (result) {\n                observer.next(result);\n                observer.complete();\n                return result;\n            })\n                .catch(function (err) {\n                if (err.name === 'AbortError')\n                    return;\n                if (err.result && err.result.errors && err.result.data) {\n                    observer.next(err.result);\n                }\n                observer.error(err);\n            });\n            return function () {\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n//# sourceMappingURL=createHttpLink.js.map","import { InvariantError } from 'ts-invariant';\nexport var checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === 'undefined') {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(22) : 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    \");\n    }\n};\n//# sourceMappingURL=checkFetcher.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","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 { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nexport function rewriteURIForGET(chosenURI, body) {\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(key + \"=\" + encodeURIComponent(value));\n    };\n    if ('query' in body) {\n        addQueryParam('query', body.query);\n    }\n    if (body.operationName) {\n        addQueryParam('operationName', body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('variables', serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('extensions', serializedExtensions);\n    }\n    var fragment = '', preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf('#');\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n    var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n    return { newURI: newURI };\n}\n//# sourceMappingURL=rewriteURIForGET.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 { InvariantError } from 'ts-invariant';\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 process.env.NODE_ENV === \"production\" ? new InvariantError(26) : new InvariantError(\"illegal argument: \" + key);\n        }\n    }\n    return operation;\n}\n//# sourceMappingURL=validateOperation.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 { __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        });\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}\nexport default Object.assign(gql, {\n    gql: gql,\n    \"default\": gql,\n    resetCaches: resetCaches,\n    disableFragmentWarnings: disableFragmentWarnings,\n    enableExperimentalFragmentVariables: enableExperimentalFragmentVariables,\n    disableExperimentalFragmentVariables: disableExperimentalFragmentVariables\n});\n//# sourceMappingURL=index.js.map","import React from 'react';\nimport { canUseWeakMap } from \"../../utilities/index.js\";\nvar cache = new (canUseWeakMap ? WeakMap : Map)();\nexport function getApolloContext() {\n    var context = cache.get(React.createContext);\n    if (!context) {\n        context = React.createContext({});\n        context.displayName = 'ApolloContext';\n        cache.set(React.createContext, context);\n    }\n    return context;\n}\nexport { getApolloContext as resetApolloContext };\n//# sourceMappingURL=ApolloContext.js.map","import React from 'react';\nimport { invariant } from 'ts-invariant';\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloConsumer = function (props) {\n    var ApolloContext = getApolloContext();\n    return React.createElement(ApolloContext.Consumer, null, function (context) {\n        process.env.NODE_ENV === \"production\" ? invariant(context && context.client, 27) : invariant(context && context.client, 'Could not find \"client\" in the context of ApolloConsumer. ' +\n            'Wrap the root component in an <ApolloProvider>.');\n        return props.children(context.client);\n    });\n};\n//# sourceMappingURL=ApolloConsumer.js.map","import React from 'react';\nimport { invariant } from 'ts-invariant';\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        process.env.NODE_ENV === \"production\" ? invariant(context.client, 28) : invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +\n            'sure you pass in your client via the \"client\" prop.');\n        return (React.createElement(ApolloContext.Provider, { value: context }, children));\n    });\n};\n//# sourceMappingURL=ApolloProvider.js.map","import React from 'react';\nimport { invariant } from 'ts-invariant';\nimport { getApolloContext } from \"../context/index.js\";\nexport function useApolloClient() {\n    var client = React.useContext(getApolloContext()).client;\n    process.env.NODE_ENV === \"production\" ? invariant(client, 33) : invariant(client, 'No Apollo Client instance can be found. Please ensure that you ' +\n        'have called `ApolloProvider` higher up in your tree.');\n    return client;\n}\n//# sourceMappingURL=useApolloClient.js.map","import { equal } from '@wry/equality';\nimport { invariant } from 'ts-invariant';\nimport { parser, operationName } from \"../parser/index.js\";\nvar OperationData = (function () {\n    function OperationData(options, context) {\n        this.isMounted = false;\n        this.previousOptions = {};\n        this.context = {};\n        this.options = {};\n        this.options = options || {};\n        this.context = context || {};\n    }\n    OperationData.prototype.getOptions = function () {\n        return this.options;\n    };\n    OperationData.prototype.setOptions = function (newOptions, storePrevious) {\n        if (storePrevious === void 0) { storePrevious = false; }\n        if (storePrevious && !equal(this.options, newOptions)) {\n            this.previousOptions = this.options;\n        }\n        this.options = newOptions;\n    };\n    OperationData.prototype.unmount = function () {\n        this.isMounted = false;\n    };\n    OperationData.prototype.refreshClient = function () {\n        var client = (this.options && this.options.client) ||\n            (this.context && this.context.client);\n        process.env.NODE_ENV === \"production\" ? invariant(!!client, 29) : 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 ' +\n            'ApolloClient instance in via options.');\n        var isNew = false;\n        if (client !== this.client) {\n            isNew = true;\n            this.client = client;\n            this.cleanup();\n        }\n        return {\n            client: this.client,\n            isNew: isNew\n        };\n    };\n    OperationData.prototype.verifyDocumentType = function (document, type) {\n        var operation = parser(document);\n        var requiredOperationName = operationName(type);\n        var usedOperationName = operationName(operation.type);\n        process.env.NODE_ENV === \"production\" ? invariant(operation.type === type, 30) : invariant(operation.type === type, \"Running a \" + requiredOperationName + \" requires a graphql \" +\n            (requiredOperationName + \", but a \" + usedOperationName + \" was used instead.\"));\n    };\n    return OperationData;\n}());\nexport { OperationData };\n//# sourceMappingURL=OperationData.js.map","import { __assign, __extends } from \"tslib\";\nimport { equal } from '@wry/equality';\nimport { OperationData } from \"./OperationData.js\";\nvar SubscriptionData = (function (_super) {\n    __extends(SubscriptionData, _super);\n    function SubscriptionData(_a) {\n        var options = _a.options, context = _a.context, setResult = _a.setResult;\n        var _this = _super.call(this, options, context) || this;\n        _this.currentObservable = {};\n        _this.setResult = setResult;\n        _this.initialize(options);\n        return _this;\n    }\n    SubscriptionData.prototype.execute = function (result) {\n        if (this.getOptions().skip === true) {\n            this.cleanup();\n            return {\n                loading: false,\n                error: undefined,\n                data: undefined,\n                variables: this.getOptions().variables\n            };\n        }\n        var currentResult = result;\n        if (this.refreshClient().isNew) {\n            currentResult = this.getLoadingResult();\n        }\n        var shouldResubscribe = this.getOptions().shouldResubscribe;\n        if (typeof shouldResubscribe === 'function') {\n            shouldResubscribe = !!shouldResubscribe(this.getOptions());\n        }\n        if (shouldResubscribe !== false &&\n            this.previousOptions &&\n            Object.keys(this.previousOptions).length > 0 &&\n            (this.previousOptions.subscription !== this.getOptions().subscription ||\n                !equal(this.previousOptions.variables, this.getOptions().variables) ||\n                this.previousOptions.skip !== this.getOptions().skip)) {\n            this.cleanup();\n            currentResult = this.getLoadingResult();\n        }\n        this.initialize(this.getOptions());\n        this.startSubscription();\n        this.previousOptions = this.getOptions();\n        return __assign(__assign({}, currentResult), { variables: this.getOptions().variables });\n    };\n    SubscriptionData.prototype.afterExecute = function () {\n        this.isMounted = true;\n    };\n    SubscriptionData.prototype.cleanup = function () {\n        this.endSubscription();\n        delete this.currentObservable.query;\n    };\n    SubscriptionData.prototype.initialize = function (options) {\n        if (this.currentObservable.query || this.getOptions().skip === true)\n            return;\n        this.currentObservable.query = this.refreshClient().client.subscribe({\n            query: options.subscription,\n            variables: options.variables,\n            fetchPolicy: options.fetchPolicy\n        });\n    };\n    SubscriptionData.prototype.startSubscription = function () {\n        if (this.currentObservable.subscription)\n            return;\n        this.currentObservable.subscription = this.currentObservable.query.subscribe({\n            next: this.updateCurrentData.bind(this),\n            error: this.updateError.bind(this),\n            complete: this.completeSubscription.bind(this)\n        });\n    };\n    SubscriptionData.prototype.getLoadingResult = function () {\n        return {\n            loading: true,\n            error: undefined,\n            data: undefined\n        };\n    };\n    SubscriptionData.prototype.updateResult = function (result) {\n        if (this.isMounted) {\n            this.setResult(result);\n        }\n    };\n    SubscriptionData.prototype.updateCurrentData = function (result) {\n        var onSubscriptionData = this.getOptions().onSubscriptionData;\n        this.updateResult({\n            data: result.data,\n            loading: false,\n            error: undefined\n        });\n        if (onSubscriptionData) {\n            onSubscriptionData({\n                client: this.refreshClient().client,\n                subscriptionData: result\n            });\n        }\n    };\n    SubscriptionData.prototype.updateError = function (error) {\n        this.updateResult({\n            error: error,\n            loading: false\n        });\n    };\n    SubscriptionData.prototype.completeSubscription = function () {\n        var onSubscriptionComplete = this.getOptions().onSubscriptionComplete;\n        if (onSubscriptionComplete)\n            onSubscriptionComplete();\n        this.endSubscription();\n    };\n    SubscriptionData.prototype.endSubscription = function () {\n        if (this.currentObservable.subscription) {\n            this.currentObservable.subscription.unsubscribe();\n            delete this.currentObservable.subscription;\n        }\n    };\n    return SubscriptionData;\n}(OperationData));\nexport { SubscriptionData };\n//# sourceMappingURL=SubscriptionData.js.map","import { __assign, __extends } from \"tslib\";\nimport { equal } from '@wry/equality';\nimport { ApolloError } from \"../../errors/index.js\";\nimport { NetworkStatus } from \"../../core/index.js\";\nimport { DocumentType } from \"../parser/index.js\";\nimport { OperationData } from \"./OperationData.js\";\nvar QueryData = (function (_super) {\n    __extends(QueryData, _super);\n    function QueryData(_a) {\n        var options = _a.options, context = _a.context, onNewData = _a.onNewData;\n        var _this = _super.call(this, options, context) || this;\n        _this.runLazy = false;\n        _this.previous = Object.create(null);\n        _this.runLazyQuery = function (options) {\n            _this.cleanup();\n            _this.runLazy = true;\n            _this.lazyOptions = options;\n            _this.onNewData();\n        };\n        _this.getQueryResult = function () {\n            var result = _this.observableQueryFields();\n            var options = _this.getOptions();\n            if (options.skip) {\n                result = __assign(__assign({}, result), { data: undefined, error: undefined, loading: false, networkStatus: NetworkStatus.ready, called: true });\n            }\n            else if (_this.currentObservable) {\n                var currentResult = _this.currentObservable.getCurrentResult();\n                var data = currentResult.data, loading = currentResult.loading, partial = currentResult.partial, networkStatus = currentResult.networkStatus, errors = currentResult.errors;\n                var error = currentResult.error;\n                if (errors && errors.length > 0) {\n                    error = new ApolloError({ graphQLErrors: errors });\n                }\n                result = __assign(__assign({}, result), { data: data,\n                    loading: loading,\n                    networkStatus: networkStatus,\n                    error: error, called: true });\n                if (loading) {\n                }\n                else if (error) {\n                    Object.assign(result, {\n                        data: (_this.currentObservable.getLastResult() || {})\n                            .data\n                    });\n                }\n                else {\n                    var fetchPolicy = _this.currentObservable.options.fetchPolicy;\n                    var partialRefetch = options.partialRefetch;\n                    if (partialRefetch &&\n                        partial &&\n                        (!data || Object.keys(data).length === 0) &&\n                        fetchPolicy !== 'cache-only') {\n                        Object.assign(result, {\n                            loading: true,\n                            networkStatus: NetworkStatus.loading\n                        });\n                        result.refetch();\n                        return result;\n                    }\n                }\n            }\n            result.client = _this.client;\n            _this.setOptions(options, true);\n            var previousResult = _this.previous.result;\n            _this.previous.loading =\n                previousResult && previousResult.loading || false;\n            result.previousData = previousResult &&\n                (previousResult.data || previousResult.previousData);\n            _this.previous.result = result;\n            _this.currentObservable && _this.currentObservable.resetQueryStoreErrors();\n            return result;\n        };\n        _this.obsRefetch = function (variables) { var _a; return (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.refetch(variables); };\n        _this.obsFetchMore = function (fetchMoreOptions) { return _this.currentObservable.fetchMore(fetchMoreOptions); };\n        _this.obsUpdateQuery = function (mapFn) { return _this.currentObservable.updateQuery(mapFn); };\n        _this.obsStartPolling = function (pollInterval) {\n            var _a;\n            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.startPolling(pollInterval);\n        };\n        _this.obsStopPolling = function () {\n            var _a;\n            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.stopPolling();\n        };\n        _this.obsSubscribeToMore = function (options) { return _this.currentObservable.subscribeToMore(options); };\n        _this.onNewData = onNewData;\n        return _this;\n    }\n    QueryData.prototype.execute = function () {\n        this.refreshClient();\n        var _a = this.getOptions(), skip = _a.skip, query = _a.query;\n        if (skip || query !== this.previous.query) {\n            this.removeQuerySubscription();\n            this.removeObservable(!skip);\n            this.previous.query = query;\n        }\n        this.updateObservableQuery();\n        if (this.isMounted)\n            this.startQuerySubscription();\n        return this.getExecuteSsrResult() || this.getExecuteResult();\n    };\n    QueryData.prototype.executeLazy = function () {\n        return !this.runLazy\n            ? [\n                this.runLazyQuery,\n                {\n                    loading: false,\n                    networkStatus: NetworkStatus.ready,\n                    called: false,\n                    data: undefined\n                }\n            ]\n            : [this.runLazyQuery, this.execute()];\n    };\n    QueryData.prototype.fetchData = function () {\n        var _this = this;\n        var options = this.getOptions();\n        if (options.skip || options.ssr === false)\n            return false;\n        return new Promise(function (resolve) { return _this.startQuerySubscription(resolve); });\n    };\n    QueryData.prototype.afterExecute = function (_a) {\n        var _b = (_a === void 0 ? {} : _a).lazy, lazy = _b === void 0 ? false : _b;\n        this.isMounted = true;\n        if (!lazy || this.runLazy) {\n            this.handleErrorOrCompleted();\n        }\n        this.previousOptions = this.getOptions();\n        return this.unmount.bind(this);\n    };\n    QueryData.prototype.cleanup = function () {\n        this.removeQuerySubscription();\n        this.removeObservable(true);\n        delete this.previous.result;\n    };\n    QueryData.prototype.getOptions = function () {\n        var options = _super.prototype.getOptions.call(this);\n        if (this.lazyOptions) {\n            options.variables = __assign(__assign({}, options.variables), this.lazyOptions.variables);\n            options.context = __assign(__assign({}, options.context), this.lazyOptions.context);\n        }\n        if (this.runLazy) {\n            delete options.skip;\n        }\n        return options;\n    };\n    QueryData.prototype.ssrInitiated = function () {\n        return this.context && this.context.renderPromises;\n    };\n    QueryData.prototype.getExecuteResult = function () {\n        var result = this.getQueryResult();\n        this.startQuerySubscription();\n        return result;\n    };\n    ;\n    QueryData.prototype.getExecuteSsrResult = function () {\n        var _a = this.getOptions(), ssr = _a.ssr, skip = _a.skip;\n        var ssrDisabled = ssr === false;\n        var fetchDisabled = this.refreshClient().client.disableNetworkFetches;\n        var ssrLoading = __assign({ loading: true, networkStatus: NetworkStatus.loading, called: true, data: undefined, stale: false, client: this.client }, this.observableQueryFields());\n        if (ssrDisabled && (this.ssrInitiated() || fetchDisabled)) {\n            this.previous.result = ssrLoading;\n            return ssrLoading;\n        }\n        var result;\n        if (this.ssrInitiated()) {\n            if (skip) {\n                result = this.getQueryResult();\n            }\n            else {\n                result =\n                    this.context.renderPromises.addQueryPromise(this, this.getQueryResult) || ssrLoading;\n            }\n            ;\n        }\n        return result;\n    };\n    QueryData.prototype.prepareObservableQueryOptions = function () {\n        var options = this.getOptions();\n        this.verifyDocumentType(options.query, DocumentType.Query);\n        var displayName = options.displayName || 'Query';\n        if (this.ssrInitiated() &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options.fetchPolicy = 'cache-first';\n        }\n        return __assign(__assign({}, options), { displayName: displayName, context: options.context });\n    };\n    QueryData.prototype.initializeObservableQuery = function () {\n        if (this.ssrInitiated()) {\n            this.currentObservable = this.context.renderPromises.getSSRObservable(this.getOptions());\n        }\n        if (!this.currentObservable) {\n            var observableQueryOptions = this.prepareObservableQueryOptions();\n            this.previous.observableQueryOptions = __assign(__assign({}, observableQueryOptions), { children: null });\n            this.currentObservable = this.refreshClient().client.watchQuery(__assign({}, observableQueryOptions));\n            if (this.ssrInitiated()) {\n                this.context.renderPromises.registerSSRObservable(this.currentObservable, observableQueryOptions);\n            }\n        }\n    };\n    QueryData.prototype.updateObservableQuery = function () {\n        if (!this.currentObservable) {\n            this.initializeObservableQuery();\n            return;\n        }\n        if (this.getOptions().skip)\n            return;\n        var newObservableQueryOptions = __assign(__assign({}, this.prepareObservableQueryOptions()), { children: null });\n        if (!equal(newObservableQueryOptions, this.previous.observableQueryOptions)) {\n            this.previous.observableQueryOptions = newObservableQueryOptions;\n            this.currentObservable\n                .setOptions(newObservableQueryOptions)\n                .catch(function () { });\n        }\n    };\n    QueryData.prototype.startQuerySubscription = function (onNewData) {\n        var _this = this;\n        if (onNewData === void 0) { onNewData = this.onNewData; }\n        if (this.currentSubscription || this.getOptions().skip)\n            return;\n        this.currentSubscription = this.currentObservable.subscribe({\n            next: function (_a) {\n                var loading = _a.loading, networkStatus = _a.networkStatus, data = _a.data;\n                var previousResult = _this.previous.result;\n                if (previousResult &&\n                    previousResult.loading === loading &&\n                    previousResult.networkStatus === networkStatus &&\n                    equal(previousResult.data, data)) {\n                    return;\n                }\n                onNewData();\n            },\n            error: function (error) {\n                _this.resubscribeToQuery();\n                if (!error.hasOwnProperty('graphQLErrors'))\n                    throw error;\n                var previousResult = _this.previous.result;\n                if ((previousResult && previousResult.loading) ||\n                    !equal(error, _this.previous.error)) {\n                    _this.previous.error = error;\n                    onNewData();\n                }\n            }\n        });\n    };\n    QueryData.prototype.resubscribeToQuery = function () {\n        this.removeQuerySubscription();\n        var currentObservable = this.currentObservable;\n        if (currentObservable) {\n            var lastError = currentObservable.getLastError();\n            var lastResult = currentObservable.getLastResult();\n            currentObservable.resetLastResults();\n            this.startQuerySubscription();\n            Object.assign(currentObservable, {\n                lastError: lastError,\n                lastResult: lastResult\n            });\n        }\n    };\n    QueryData.prototype.handleErrorOrCompleted = function () {\n        if (!this.currentObservable || !this.previous.result)\n            return;\n        var _a = this.previous.result, data = _a.data, loading = _a.loading, error = _a.error;\n        if (!loading) {\n            var _b = this.getOptions(), query = _b.query, variables = _b.variables, onCompleted = _b.onCompleted, onError = _b.onError, skip = _b.skip;\n            if (this.previousOptions &&\n                !this.previous.loading &&\n                equal(this.previousOptions.query, query) &&\n                equal(this.previousOptions.variables, variables)) {\n                return;\n            }\n            if (onCompleted && !error && !skip) {\n                onCompleted(data);\n            }\n            else if (onError && error) {\n                onError(error);\n            }\n        }\n    };\n    QueryData.prototype.removeQuerySubscription = function () {\n        if (this.currentSubscription) {\n            this.currentSubscription.unsubscribe();\n            delete this.currentSubscription;\n        }\n    };\n    QueryData.prototype.removeObservable = function (andDelete) {\n        if (this.currentObservable) {\n            this.currentObservable[\"tearDownQuery\"]();\n            if (andDelete) {\n                delete this.currentObservable;\n            }\n        }\n    };\n    QueryData.prototype.observableQueryFields = function () {\n        var _a;\n        return {\n            variables: (_a = this.currentObservable) === null || _a === void 0 ? void 0 : _a.variables,\n            refetch: this.obsRefetch,\n            fetchMore: this.obsFetchMore,\n            updateQuery: this.obsUpdateQuery,\n            startPolling: this.obsStartPolling,\n            stopPolling: this.obsStopPolling,\n            subscribeToMore: this.obsSubscribeToMore\n        };\n    };\n    return QueryData;\n}(OperationData));\nexport { QueryData };\n//# sourceMappingURL=QueryData.js.map","import { __assign, __extends } from \"tslib\";\nimport { equal } from '@wry/equality';\nimport { DocumentType } from \"../parser/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { OperationData } from \"./OperationData.js\";\nimport { mergeOptions } from \"../../core/index.js\";\nvar MutationData = (function (_super) {\n    __extends(MutationData, _super);\n    function MutationData(_a) {\n        var options = _a.options, context = _a.context, result = _a.result, setResult = _a.setResult;\n        var _this = _super.call(this, options, context) || this;\n        _this.runMutation = function (mutationFunctionOptions) {\n            if (mutationFunctionOptions === void 0) { mutationFunctionOptions = {}; }\n            _this.onMutationStart();\n            var mutationId = _this.generateNewMutationId();\n            return _this.mutate(mutationFunctionOptions)\n                .then(function (response) {\n                _this.onMutationCompleted(response, mutationId);\n                return response;\n            })\n                .catch(function (error) {\n                _this.onMutationError(error, mutationId);\n                if (!_this.getOptions().onError)\n                    throw error;\n            });\n        };\n        _this.verifyDocumentType(options.mutation, DocumentType.Mutation);\n        _this.result = result;\n        _this.setResult = setResult;\n        _this.mostRecentMutationId = 0;\n        return _this;\n    }\n    MutationData.prototype.execute = function (result) {\n        this.isMounted = true;\n        this.verifyDocumentType(this.getOptions().mutation, DocumentType.Mutation);\n        return [\n            this.runMutation,\n            __assign(__assign({}, result), { client: this.refreshClient().client })\n        ];\n    };\n    MutationData.prototype.afterExecute = function () {\n        this.isMounted = true;\n        return this.unmount.bind(this);\n    };\n    MutationData.prototype.cleanup = function () {\n    };\n    MutationData.prototype.mutate = function (options) {\n        return this.refreshClient().client.mutate(mergeOptions(this.getOptions(), options));\n    };\n    MutationData.prototype.onMutationStart = function () {\n        if (!this.result.loading && !this.getOptions().ignoreResults) {\n            this.updateResult({\n                loading: true,\n                error: undefined,\n                data: undefined,\n                called: true\n            });\n        }\n    };\n    MutationData.prototype.onMutationCompleted = function (response, mutationId) {\n        var _a = this.getOptions(), onCompleted = _a.onCompleted, ignoreResults = _a.ignoreResults;\n        var data = response.data, errors = response.errors;\n        var error = errors && errors.length > 0\n            ? new ApolloError({ graphQLErrors: errors })\n            : undefined;\n        var callOncomplete = function () {\n            return onCompleted ? onCompleted(data) : null;\n        };\n        if (this.isMostRecentMutation(mutationId) && !ignoreResults) {\n            this.updateResult({\n                called: true,\n                loading: false,\n                data: data,\n                error: error\n            });\n        }\n        callOncomplete();\n    };\n    MutationData.prototype.onMutationError = function (error, mutationId) {\n        var onError = this.getOptions().onError;\n        if (this.isMostRecentMutation(mutationId)) {\n            this.updateResult({\n                loading: false,\n                error: error,\n                data: undefined,\n                called: true\n            });\n        }\n        if (onError) {\n            onError(error);\n        }\n    };\n    MutationData.prototype.generateNewMutationId = function () {\n        return ++this.mostRecentMutationId;\n    };\n    MutationData.prototype.isMostRecentMutation = function (mutationId) {\n        return this.mostRecentMutationId === mutationId;\n    };\n    MutationData.prototype.updateResult = function (result) {\n        if (this.isMounted &&\n            (!this.previousResult || !equal(this.previousResult, result))) {\n            this.setResult(result);\n            this.previousResult = result;\n        }\n    };\n    return MutationData;\n}(OperationData));\nexport { MutationData };\n//# sourceMappingURL=MutationData.js.map","import { useBaseQuery } from \"./utils/useBaseQuery.js\";\nexport function useQuery(query, options) {\n    return useBaseQuery(query, options, false);\n}\n//# sourceMappingURL=useQuery.js.map","import { __assign } from \"tslib\";\nimport { useContext, useEffect, useReducer, useRef } from 'react';\nimport { QueryData } from \"../../data/index.js\";\nimport { useDeepMemo } from \"./useDeepMemo.js\";\nimport { getApolloContext } from \"../../context/index.js\";\nexport function useBaseQuery(query, options, lazy) {\n    if (lazy === void 0) { lazy = false; }\n    var context = useContext(getApolloContext());\n    var _a = useReducer(function (x) { return x + 1; }, 0), tick = _a[0], forceUpdate = _a[1];\n    var updatedOptions = options ? __assign(__assign({}, options), { query: query }) : { query: query };\n    var queryDataRef = useRef();\n    var queryData = queryDataRef.current || (queryDataRef.current = new QueryData({\n        options: updatedOptions,\n        context: context,\n        onNewData: function () {\n            if (!queryData.ssrInitiated()) {\n                Promise.resolve().then(function () { return queryDataRef.current && forceUpdate(); });\n            }\n            else {\n                forceUpdate();\n            }\n        }\n    }));\n    queryData.setOptions(updatedOptions);\n    queryData.context = context;\n    var memo = {\n        options: __assign(__assign({}, updatedOptions), { onError: undefined, onCompleted: undefined }),\n        context: context,\n        tick: tick\n    };\n    var result = useDeepMemo(function () { return (lazy ? queryData.executeLazy() : queryData.execute()); }, memo);\n    var queryResult = lazy\n        ? result[1]\n        : result;\n    useEffect(function () {\n        return function () { return queryData.cleanup(); };\n    }, []);\n    useEffect(function () { return queryData.afterExecute({ lazy: lazy }); }, [\n        queryResult.loading,\n        queryResult.networkStatus,\n        queryResult.error,\n        queryResult.data,\n    ]);\n    return result;\n}\n//# sourceMappingURL=useBaseQuery.js.map","import { useRef } from 'react';\nimport { equal } from '@wry/equality';\nexport function useDeepMemo(memoFn, key) {\n    var ref = useRef();\n    if (!ref.current || !equal(key, ref.current.key)) {\n        ref.current = { key: key, value: memoFn() };\n    }\n    return ref.current.value;\n}\n//# sourceMappingURL=useDeepMemo.js.map","import { invariant } from 'ts-invariant';\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    process.env.NODE_ENV === \"production\" ? invariant(!!document && !!document.kind, 34) : invariant(!!document && !!document.kind, \"Argument of \" + 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\");\n    var fragments = document.definitions.filter(function (x) { return x.kind === 'FragmentDefinition'; });\n    var queries = document.definitions.filter(function (x) {\n        return x.kind === 'OperationDefinition' && x.operation === 'query';\n    });\n    var mutations = document.definitions.filter(function (x) {\n        return x.kind === 'OperationDefinition' && x.operation === 'mutation';\n    });\n    var subscriptions = document.definitions.filter(function (x) {\n        return x.kind === 'OperationDefinition' && x.operation === 'subscription';\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(!fragments.length ||\n        (queries.length || mutations.length || subscriptions.length), 35) : 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\");\n    process.env.NODE_ENV === \"production\" ? invariant(queries.length + mutations.length + subscriptions.length <= 1, 36) : invariant(queries.length + mutations.length + subscriptions.length <= 1, \"react-apollo only supports a query, subscription, or a mutation per HOC. \" +\n        (document + \" had \" + queries.length + \" queries, \" + subscriptions.length + \" \") +\n        (\"subscriptions and \" + mutations.length + \" mutations. \") +\n        \"You can use 'compose' to join multiple operation types to a component\");\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    process.env.NODE_ENV === \"production\" ? invariant(definitions.length === 1, 37) : invariant(definitions.length === 1, \"react-apollo only supports one definition per HOC. \" + document + \" had \" +\n        (definitions.length + \" definitions. \") +\n        \"You can use 'compose' to join multiple operation types to a component\");\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}\n//# sourceMappingURL=index.js.map","import { visit, } from 'graphql';\nimport { invariant } from 'ts-invariant';\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            process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 38) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\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 function hasDirectives(names, root) {\n    return getDirectiveNames(root).some(function (name) { return names.indexOf(name) > -1; });\n}\nexport function hasClientExports(document) {\n    return (document &&\n        hasDirectives(['client'], document) &&\n        hasDirectives(['export'], document));\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\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            process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 39) : invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\" + directiveName + \" directive.\");\n            var ifArgument = directiveArguments[0];\n            process.env.NODE_ENV === \"production\" ? invariant(ifArgument.name && ifArgument.name.value === 'if', 40) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n            var ifValue = ifArgument.value;\n            process.env.NODE_ENV === \"production\" ? invariant(ifValue &&\n                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 41) : invariant(ifValue &&\n                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\n//# sourceMappingURL=directives.js.map","import { __assign, __spreadArrays } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\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 process.env.NODE_ENV === \"production\" ? new InvariantError(42) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 43) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArrays([\n            {\n                kind: 'OperationDefinition',\n                operation: 'query',\n                selectionSet: {\n                    kind: 'SelectionSet',\n                    selections: [\n                        {\n                            kind: 'FragmentSpread',\n                            name: {\n                                kind: 'Name',\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions) });\n    return query;\n}\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 fragment = fragmentMap && fragmentMap[selection.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(fragment, 44) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n            return fragment;\n        }\n        default:\n            return null;\n    }\n}\n//# sourceMappingURL=fragments.js.map","import stringify from 'fast-json-stable-stringify';\nimport { InvariantError } from 'ts-invariant';\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}\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 process.env.NODE_ENV === \"production\" ? new InvariantError(53) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.');\n    }\n}\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 function getStoreKeyName(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 directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n        }\n        else {\n            return directives['connection']['key'];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\" + stringifiedArgs + \")\";\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n            }\n            else {\n                completeFieldName += \"@\" + key;\n            }\n        });\n    }\n    return completeFieldName;\n}\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","import { invariant, InvariantError } from 'ts-invariant';\nimport { valueToObjectRepresentation } from \"./storeUtils.js\";\nexport function checkDocument(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 45) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(46) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n        }\n        return definition;\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 47) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\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    process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 48) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 49) : invariant(doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    process.env.NODE_ENV === \"production\" ? invariant(doc.definitions.length <= 1, 50) : invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.');\n    var fragmentDef = doc.definitions[0];\n    process.env.NODE_ENV === \"production\" ? invariant(fragmentDef.kind === 'FragmentDefinition', 51) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\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 process.env.NODE_ENV === \"production\" ? new InvariantError(52) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\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","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, __spreadArrays } from \"tslib\";\nimport { visit, } from 'graphql';\nimport { invariant } from 'ts-invariant';\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, fragments) {\n    return op.selectionSet.selections.every(function (selection) {\n        return selection.kind === 'FragmentSpread' &&\n            isEmpty(fragments[selection.name.value], fragments);\n    });\n}\nfunction nullIfDocIsEmpty(doc) {\n    return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))\n        ? null\n        : doc;\n}\nfunction getDirectiveMatcher(directives) {\n    return function directiveMatcher(directive) {\n        return directives.some(function (dir) {\n            return (dir.name && dir.name === directive.name.value) ||\n                (dir.test && dir.test(directive));\n        });\n    };\n}\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 function addTypenameToDocument(doc) {\n    return visit(checkDocument(doc), {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind === 'OperationDefinition') {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === '__typename' ||\n                            selection.name.value.lastIndexOf('__', 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === 'export'; })) {\n                    return;\n                }\n                return __assign(__assign({}, node), { selections: __spreadArrays(selections, [TYPENAME_FIELD]) });\n            },\n        },\n    });\n}\naddTypenameToDocument.added = function (field) {\n    return field === TYPENAME_FIELD;\n};\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === 'connection';\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' +\n                    'You may want to use the key parameter to specify a store key.');\n            }\n        }\n        return willRemove;\n    },\n};\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, __spreadArrays } from \"tslib\";\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}\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\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 = isObject;\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 (isObject(source) && isObject(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, __spreadArrays([target, source, sourceKey], context));\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 (isObject(value) && !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        return value;\n    };\n    return DeepMerger;\n}());\nexport { DeepMerger };\n//# sourceMappingURL=mergeDeep.js.map","import Observable from 'zen-observable';\nimport 'symbol-observable';\nObservable.prototype['@@observable'] = function () { return this; };\nexport { Observable };\n//# sourceMappingURL=Observable.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","import { isDevelopment, isTest } from \"./environment.js\";\nfunction isObject(value) {\n    return value !== null && typeof value === \"object\";\n}\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isObject(obj)) {\n            if (!Object.isFrozen(obj))\n                Object.freeze(obj);\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nexport function maybeDeepFreeze(obj) {\n    if (process.env.NODE_ENV !== \"production\" && (isDevelopment() || isTest())) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n//# sourceMappingURL=maybeDeepFreeze.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\";\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        function makeCallback(examiner, delegate) {\n            if (examiner) {\n                return function (arg) {\n                    ++activeCallbackCount;\n                    new Promise(function (resolve) { return resolve(examiner(arg)); }).then(function (result) {\n                        --activeCallbackCount;\n                        next && next.call(observer, result);\n                        if (completed) {\n                            handler.complete();\n                        }\n                    }, function (e) {\n                        --activeCallbackCount;\n                        error && error.call(observer, e);\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","import { Observable } from \"./Observable.js\";\nexport function fixObservableSubclass(subclass) {\n    function set(key) {\n        Object.defineProperty(subclass, key, { value: Observable });\n    }\n    if (typeof Symbol === \"function\" && Symbol.species) {\n        set(Symbol.species);\n    }\n    set(\"@@species\");\n    return subclass;\n}\n//# sourceMappingURL=subclassing.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.addCount = 0;\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                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    if (sub)\n                        Promise.resolve().then(function () { return sub.unsubscribe(); });\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                if (_this.sub !== null) {\n                    var value = _this.sources.shift();\n                    if (!value) {\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                        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.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            ++this.addCount;\n        }\n    };\n    Concast.prototype.removeObserver = function (observer, quietly) {\n        if (this.observers.delete(observer) &&\n            --this.addCount < 1 &&\n            !quietly) {\n            this.handlers.error(new Error(\"Observable cancelled prematurely\"));\n        }\n    };\n    Concast.prototype.cleanup = function (callback) {\n        var _this = this;\n        var called = false;\n        var once = function () {\n            if (!called) {\n                called = true;\n                _this.observers.delete(observer);\n                callback();\n            }\n        };\n        var observer = {\n            next: once,\n            error: once,\n            complete: once,\n        };\n        var count = this.addCount;\n        this.addObserver(observer);\n        this.addCount = count;\n    };\n    return Concast;\n}(Observable));\nexport { Concast };\nfixObservableSubclass(Concast);\n//# sourceMappingURL=Concast.js.map","export function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrays.js.map","export function graphQLResultHasError(result) {\n    return (result.errors && result.errors.length > 0) || false;\n}\n//# sourceMappingURL=errorHandling.js.map","export var canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&\n    navigator.product === 'ReactNative');\n//# sourceMappingURL=canUse.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"],"sourceRoot":""}